多线程简单介绍（摘记）

按照JDK文档的描述，

• 如果池中的实际线程数小于corePoolSize,无论是否其中有空闲的线程，都会给新的任务产生新的线程
• 如果池中的线程数>corePoolSize and <maximumPoolSize,而又有空闲线程，就给新任务使用空闲线程，如没有空闲线程，则产生新线程
• 如果池中的线程数＝maximumPoolSize，则有空闲线程使用空闲线程，否则新任务放入workQueue。（线程的空闲只有在workQueue中不再有任务时才成立）

ThreadPoolExecutor中有方法setCorePoolSize()和setMaximumPoolSize来设置corePoolSize和maximumPoolSize的大小，

• 如果新值大于旧值，则对新任务新线程
• 如果新值小于旧值，则在有线程空闲时，减少池中的线程数

但是在实际应用中想实时修改池的线程数，得有一定的条件，特别是要减少线程数，

• 首先，如果提交的新任务太多，以至总是没有线程空闲下来，线程就不会减少
• 即使有线程空闲，也不一定能减少线程，这还同所使用的workQueue有关，还需要workQueue.remainingCapacity==0。在JDK所提供的所有BlockingQueue中，只有SynchronousQueue的remainingCapacity()能返回0。

而如果实际应用中需要使用ScheduledThreadPoolExecutor来安排任务，同时需要新安排的任务数又非常多，这时要即时动态线程池的大小，就几乎不可能了，因为ScheduledThreadPoolExecutor用的是LinkedBlockingQueue。这时可以按照JDK的方式实现一个自己的ScheduledThreadPoolExecutor，

首先，稍微修改一下JDK的ThreadPoolExecutor就能实现一个自己的ThreadPoolExecutor,

• 在setCorePoolSize方法中,去掉workQueue.remainingCapacity==0的条件
• 让ThreadPoolExecutor中的Worker的interruptIfIdle()方法给Worker设置一个标志，让这个Worker不再检查workQueue中还没有执行的任务，立即中止
• 还有就是修改一下ThreadPoolExecutor中实现的RejectedExecutionHandler，毕竟很多情况下都可以不需要它

有了自己ThreadPoolExecutor，就可以继承它来实现自己的ScheduledThreadPoolExecutor了（再原本照抄JDK的ScheduledThreadPoolExecutor的实现就可以了^_^）。

 

终于有了符合自己需要的ScheduledThreadPoolExecutor了，现在用它来每秒运行1000个任务，还需要每个小时改变并发任务数（50～200之间的随机值），至少要维持30天。

===========================================================================

• corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
• maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
• keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
• unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

• workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：

ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;

　　ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

• threadFactory：线程工厂，主要用来创建线程；
• handler：表示当拒绝处理任务时的策略，有以下四种取值：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务 

=========================================================================================

不过在java doc中，并不提倡我们直接使用ThreadPoolExecutor，而是使用Executors类中提供的几个静态方法来创建线程池：

1 2 3

Executors.newCachedThreadPool();       //创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE Executors.newSingleThreadExecutor();  //创建容量为1的缓冲池 Executors.newFixedThreadPool(int);   //创建固定容量大小的缓冲池

newFixedThreadPool创建的线程池corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue；

　　newSingleThreadExecutor将corePoolSize和maximumPoolSize都设置为1，也使用的LinkedBlockingQueue；

　　newCachedThreadPool将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，使用的SynchronousQueue，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程。

================================================================================================

ThreadPoolExecutor类中其他的一些比较重要成员变量：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

private final BlockingQueue<Runnable> workQueue;              //任务缓存队列，用来存放等待执行的任务 private final ReentrantLock mainLock = new ReentrantLock();   //线程池的主要状态锁，对线程池状态（比如线程池大小                                                                //、runState等）的改变都要使用这个锁 private final HashSet<Worker> workers = new HashSet<Worker>();  //用来存放工作集   private volatile long  keepAliveTime;    //线程存货时间    private volatile boolean allowCoreThreadTimeOut;   //是否允许为核心线程设置存活时间 private volatile int   corePoolSize;     //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列） private volatile int   maximumPoolSize;   //线程池最大能容忍的线程数   private volatile int   poolSize;       //线程池中当前的线程数   private volatile RejectedExecutionHandler handler; //任务拒绝策略   private volatile ThreadFactory threadFactory;   //线程工厂，用来创建线程   private int largestPoolSize;   //用来记录线程池中曾经出现过的最大线程数   private long completedTaskCount;   //用来记录已经执行完毕的任务个数

===========================代码示例==================================================

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 *
 */

/**
 * @Description: 这里用一句话描述这个类的作用
 * @see: threadTest 此处填写需要参考的类
 * @version 2015年8月7日 上午9:58:28
 * @author
 */
public class threadTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // 固定线程池大小
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        // 可缓存的线程池
        // ExecutorService threadPool = Executors.newCachedThreadPool();
        // 单线程的线程池
        // ExecutorService threadPool = Executors.newSingleThreadExecutor();

        // 向线程池中放入10个任务，每次只能为一个任务服务（单线程的线程池）
        for (int i = 1; i <= 10; i++) {
            final int task = i;
            // 执行任务（可以与new Thread（new Runnable(){}）相比，相当于10个任务创建10个线程，而此时只有一个线程）
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    for (int j = 1; j <= 10; j++) {
                        try {
                            Thread.sleep(20);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + " is looping of " + j + " for  task of " + task);
                    }
                }
            });
        }
        // 10个任务放入线程池后，才会执行下面的代码，打印出此提示信息，说明已经放入了10个任务
        System.out.println("all of 10 tasks have committed! ");

        // 当线程池内存在线程时，是不会停止的，想要停止使用如下语句
        // threadPool.shutdownNow();

        // 定时执行任务
        // Executors.newScheduledThreadPool(3).scheduleAtFixedRate(
        // new Runnable(){
        // @Override
        // public void run() {
        // System.out.println("bombing!");
        //
        // }},
        // 6,
        // 2,
        // TimeUnit.SECONDS);
    }

}