java中的多线程

简介

　　为了给并发程序开发提供更好的支持，java不仅提供了Thread类、Runnable接口等简单的多线程支持工具，还提供了用于多线程管理的线程池，用于提高并发程序的性能。

无限制线程的缺陷

　　多线程的软件设计方法确实可以提高多核处理器的计算能力，提高系统的性能和吞吐量，但是如果不加限制的使用多线程，对于系统性能不仅不能提升，反而会下降产生不利影响。

　　简单的线程创建方法new Thread().start()，通过thread来启动线程，并且由系统自动的回收线程。在简单的系统这样做并没有问题，但是在真实的生产系统中，在某一时刻会有大量的请求，这样就需要为每一个请求创建一个线程，而当线程数量过大时，会耗尽CPU和内存资源。

　　虽然线程是一种轻量级的工具，但是其创建和销毁也需要消耗一定的时间；其次，线程本身也是需要占用内存空间的，大量的线程会抢占内存只有，导致Out of memory异常，并且大量线程的回收会给GC带来很大压力，延长GC停顿的时间。

　　因此，对线程的使用必须控制一个度，在适当的范围内使用会提供系统性能，但是，一旦超过了这个范围，大量的线程就会拖垮整个系统。在生产环境下，必须要对其进行管理和控制。

简单线程池的实现

　　前面介绍在多线程中不断的创建和销毁线程会带来额外的开销，这样就需要引入一种线程复用机制，即线程池。线程池的基本功能就是进行线程复用，当系统接受一个提交的任务，需要一个线程时，并不急于去创建一个线程，而是去现场池中寻找，是否有闲置的线程，若有，直接使用线程池中的线程工作，如没有，再去创建新的线程。待任务完成后，也不是简单的销毁线程，而是将线程放回线程池中，以便下次复用。

　　上面已经把线程池实现的原理简单说明了一下，下面我们自己实现一个线程，来了解一下线程池实现的核心功能，有助于理解线程池的实现。

　　线程池实现代码：

public class ThreadPool {
private static ThreadPool instance = null;
//空闲线程队列
private List<PThread> idelThreads;
//已有的线程总数
private int threadCounter;
private boolean isShutdown = false;

public ThreadPool() {
idelThreads = new Vector<PThread>(5);
threadCounter=0;
}

public synchronized int getCreatedThreadsCount() {

return threadCounter;
}

//取得线程池实例
public synchronized static ThreadPool getInstatce(){
if(instance==null){
instance = new ThreadPool();
}
return instance;
}

//把线程重新放回到池中

public synchronized void repool(PThread repoolThread){
if(!isShutdown){
idelThreads.add(repoolThread);
}else{
repoolThread.shutdown();
}
}

//停止池中所有线程
public synchronized void shutdown(){
isShutdown = true;
for (int i = 0; i < idelThreads.size(); i++) {
PThread pthread = idelThreads.get(i);
pthread.shutdown();
}
}
//执行任务
public synchronized void start(Runnable target){
PThread pthread = null;
//如果有闲置线程
if(idelThreads.size()>0){
int index = idelThreads.size()-1;
pthread=idelThreads.get(index);
idelThreads.remove(index);
pthread.setTarget(target);
}else{//如果没有闲置线程
threadCounter++;
PThread p = new PThread(instance, target, "PThread#"+threadCounter);
p.start();
}
}

}

　　从代码中可以看出，线程池中有一个闲置线程的队列，在执行任务时，如果有闲置线程，则从线程池中取线程执行任务，如果没有现在线程，则创建新的线程，并且在现场使用完毕后，会将线程重新放回到闲置线程队列中。

　　另外，线程池的使用还需要一个永不退出的线程的配合使用，该线程在手动关闭前永不结束，并且一直等待新任务的到来。代码如下：

public class PThread extends Thread{
//线程池
private ThreadPool pool;
//任务
private Runnable target;
private boolean isShutDown = false;
private boolean isIdle = false;
public PThread(ThreadPool pool, Runnable target,String name) {
super(name);
this.pool = pool;
this.target = target;
}

public synchronized Runnable getTarget() {
return target;
}
public synchronized boolean isIdle() {
return isIdle;
}

@Override
public void run() {

while(!isShutDown){
isIdle = false;

if(target!=null){
//运行任务
target.run();
}
//任务结束，闲置任务
isIdle=true;

try {
pool.repool(this);
synchronized (this) {
//线程闲置，等待任务到来
wait();
}
} catch (Exception e) {
// TODO: handle exception
}

isIdle=false;
}

}

public synchronized void setTarget(Runnable target){
this.target=target;
//设置任务之后，通知run方法，开始执行
notifyAll();
}

public synchronized void shutdown(){
isShutDown=true;
notifyAll();
}

}

　　执行线程：

public class MyThread implements Runnable{

private String name;

public MyThread() {

}

public MyThread(String name) {
this.name = name;
}

@Override
public void run() {
// TODO Auto-generated method stub
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

　　测试代码：

public class TestClient {
public static void main(String[] args) {

ExecutorService executor = Executors.newCachedThreadPool();

long begin = System.currentTimeMillis();

for (int i = 0; i < 1000; i++) {
//new Thread(new MyThread("testnopoolThread"+i)).start();

ThreadPool.getInstatce().start(new MyThread("testpoolThread"+i));

//executor.execute(new MyThread("executorpoolThread"+i));
}

System.out.println(System.currentTimeMillis()-begin);

}
}

　　线程池能减少线程频繁调度的开销，线程的复用，对系统性能的提升效果比较明显。

Executor框架

　　JDK提供了一整套的Executor框架，帮助开发人员有效的进行线程控制。ThreadPoolExecutor表示一个线程池，Executors类扮演着线程池工厂的角色，通过Executor可以取得一个特定功能的线程池。

　　newFixedThreadPool():该方法返回一个固定线程数量的线程池，该线程池中线程的数量始终保持不变。当一个任务提交后，线程池中若有空闲线程则立即执行，若没有，新任务会被保存在一个任务队列中，待有现车空闲时，便处理任务队列中的任务。

　　newSingleThreadExecutor():该方法返回只有一个线程的线程池。若多余的任务被提交到该线程池，任务会被保存到一个任务队列中，若线程空闲，按先进先出的顺序执行队列中的任务。

　　newCacheThreadPool()：该方法返回一个根据实际情况调整线程数量的线程池。若有空闲线程可以复用，则优先选择使用可复用的线程，否则，创建新的线程处理新任务。

　　newSingleThreadScheduledExecutor()方法：该方法返回一个ScheduledExecutorService对象，线程池大小为1，在给定时间内执行某一任务。

自定义线程池

　　newFixedThreadPool、newSingleThreadExecutor、newCacheThreadPool的内部实现都实现了ThreadPoolExecutor。在ThreadPoolExecutor中有一个最主要的构造函数：

public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}

　　corePoolSize：线程池中核心线程的数量；

　　maximumPoolSize：线程池中最大线程的数量；

　　keepAliveTime：当线程池中的线程数量超过corePoolSize时，多余的空闲线程的存活时间；

　　unit：keepAliveTime的单位；

　　workQueue：任务队列，提交但是尚未执行的任务；

　　threadFactory：线程工厂，用于创建线程；

　　hander:拒绝策略，当任务太多时，怎么拒绝任务。

　　主要来介绍下workQueue和hander：

　　workQueue任务队列，提交但是尚未执行的任务，主要由以下几种实现方式：

　　直接提交的队列：该功能由SynchronousQueue对象提供。SynchronousQueue是一个特殊的BlockingQueue,它没有容量，每当插入操作都要等待响应的删除操作，反之，每当删除操作斗鱼等待线程插入操作。它不保证任务，总是将任务提交给线程来执行，如果没有空闲线程，则创建新的线程，当线程数达到最大数值时，则执行拒绝策略。因此，如果使用SynchronousQueue，通常会设置很大的maximumPoolSize，否则很容易执行拒绝策略。

　　有界任务队列：当使用有界任务队列，若有新的任务需要执行，如果线程池的实际线程数小于corePoolSize，则会创建新的线程，若大于corePoolSize，则将新任务加入到等待队列中，若任务队列已满，无法加入，则在总数不大于maximumPoolSize的前提下，创建新的线程执行。若大于maximumPoolSize，则执行拒绝策略。如ArrayBlockingQueue队列。

　　无界任务队列：于有界任务队列相比，除非耗尽系统资源，否则不会出现任务放入任务队列失败的情况。当有新的任务到来时，系统的线程数小于corePoolSize，线程池就会产生新的线程执行任务。当系统的线程数达到corePoolSize，就不再增加。如后续仍有新的任务产生，但是没有空闲的线程资源，那么线程进入任务队列进行等待。如：LinkedBlockingQueue队列。

　　优先任务队列：优先任务队列是带有执行优先级的队列。可以控制任务的执行顺序，是一个特殊的无界队列。如PriorityBlockingQueue队列。PriorityBlockingQueue可以根据任务自身的优先级顺序先后执行，在确保系统性能的同时，也能有很好的质量保证。线程要实现comparable接口。

　　hander是线程池的拒绝策略：

　　JDK内置的拒绝策略如下：

　　AbortPolicy策略:该策略会直接抛出异常，阻止系统的正常工作。

　　CallerRunsPolicy策略：只要线程池未关系，该策略直接在调用者线程中，运行当前被丢弃的任务。

　　DiscardOledestPolicy策略：该策略将丢弃最老的一个请求，尝试再次执行提交当前任务。

　　DiscardPolicy策略：该策略丢弃无法处理的任务，不予以任何处理。

　　在JDK所提供的线程池不能满足需求的时候，可以考虑实现自定义的线程池，自定义的线程池可以提供更为灵活的任务处理和调度方式。

扩展ThreadPoolExecutor

　　ThreadPoolExecutor是一个可扩展的线程池，它提供了beforeExecute()、afterExecute()和terminated()三个方法实现对线程池的控制。

　　在默认的ThreadPoolExecutor实现中，提供了空的beforeExecute()、afterExecute()的实现。在实际应用中，可以对其进行扩展，实现对线程池状态的跟踪，输出一些有用的调试信息，以帮助系统故障诊断。

　　下面就是一个带有日志输出功能的线程池，该线程池会在任务执行前输入任务执行的名称和id，同时，在任务执行完毕后，可以输出线程的id和当前线程池的线程数量。

　　

public class MyThreadPoolExecutor extends ThreadPoolExecutor{

public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, handler);
}

@Override
protected void beforeExecute(Thread t, Runnable r) {
System.out.println("BeforeExecute MyThread name:"+((MyThread)r).getName()+"ID: "+t.getId() );
}

@Override
protected void afterExecute(Runnable r, Throwable t) {
System.out.println("AfterExecute MyThread ID:"+Thread.currentThread().getId());
System.out.println("AfterExecute Poolsize:"+this.getPoolSize());
}

}