JAVA线程池的几种使用方式以及线程同步详解

public class MyThread extends Thread {

    @Override
    public void run(){
        // do something
    }
}

public class MyRunnable implements Runnable{

	@Override
	public void run() {

	}
}

new Thread(() -> {
	log.info("run....");
}).start();

public class MyCallable implements Callable<Integer> {

	@Override
	public Integer call() throws Exception {        
		// TODO Auto-generated method stub
		return 1111;
	}
}

/**
 * Creates a new {@code ThreadPoolExecutor} with the given initial
 * parameters and default thread factory.
 *
 * @param corePoolSize the number of threads to keep in the pool, even
 *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
 * 核心线程数，
 * 核心线程数时最小的存活线程数量
 * 设置allowCoreThreadTimeout=true（默认false）时，核心线程数为0，所限线程都会超时关闭
 * @param maximumPoolSize the maximum number of threads to allow in the
 *        pool
 * 最大线程数，超过最大线程数将不会再创建线程，新进来的任务会等待或被拒绝
 * @param keepAliveTime when the number of threads is greater than
 *        the core, this is the maximum time that excess idle threads
 *        will wait for new tasks before terminating.
 * 线程空闲时间
 * 线程空闲会等待keepAliveTime之后，超时退出，直到线程数为核心线程数
 * 如果allowCoreThreadTimeOut=true，会直到线程数为0
 * @param unit the time unit for the {@code keepAliveTime} argument
 *             keepAliveTime的单位
 *             TimeUnit是一个枚举类型，其包括：
 *             NANOSECONDS ： 1微毫秒 = 1微秒 / 1000
 *             MICROSECONDS ： 1微秒 = 1毫秒 / 1000
 *             MILLISECONDS ： 1毫秒 = 1秒 /1000
 *             SECONDS ： 秒
 *             MINUTES ： 分
 *             HOURS ： 小时
 *             DAYS ： 天
 * @param workQueue the queue to use for holding tasks before they are
 *        executed.  This queue will hold only the {@code Runnable}
 *        tasks submitted by the {@code execute} method.
 *                  线程池中的任务队列：维护着等待执行的Runnable对象
 *        SynchronousQueue：这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，无缓冲的等待队列
 *                  如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，
 *                  使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大
 *        LinkedBlockingQueue：无界缓存的等待队列，这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；
 *                  如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，
 *                  这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize
 *        ArrayBlockingQueue：有界缓存的等待队列，可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，
 *                  如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误
 *        DelayQueue：无界缓存的等待队列，队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。
 *                  这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务
 * @param handler the handler to use when execution is blocked
 *        because the thread bounds and queue capacities are reached
 *          任务拒绝处理器，默认是AbortPolicy
 *          ThreadPoolExecutor类有几个内部实现类来处理这类情况：
 *          AbortPolicy 丢弃任务，抛运行时异常
 *          CallerRunsPolicy 执行任务
 *          DiscardPolicy 忽视，什么都不会发生
 *          DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务
 * @throws IllegalArgumentException if one of the following holds:<br>
 *         {@code corePoolSize < 0}<br>
 *         {@code keepAliveTime < 0}<br>
 *         {@code maximumPoolSize <= 0}<br>
 *         {@code maximumPoolSize < corePoolSize}
 * @throws NullPointerException if {@code workQueue}
 *         or {@code handler} is null
 */
public ThreadPoolExecutor(int corePoolSize,
						  int maximumPoolSize,
						  long keepAliveTime,
						  TimeUnit unit,
						  BlockingQueue<Runnable> workQueue,
						  RejectedExecutionHandler handler) {
	this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
			Executors.defaultThreadFactory(), handler);
}

public class Executors {
    /**
     * 创建一个最大线程数目固定的线程池，该线程池用一个共享的无界队列来存储提交的任务。
     * 参数nThreads指定线程池的最大线程数
     * 创建线程池时，如果线程池没有接收到任何任务，则线程池中不会创建新线程
     * 在线程池中线程数目少于最大线程数时，每来一个新任务就创建一个新线程
     * 当线程数达到最大线程数时，不再创建新线程，新来的任务存储在队列中
     */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new java.util.concurrent.ThreadPoolExecutor(nThreads, nThreads,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>());
    }


    /**
     * 参数threadFactory是线程工厂类，主要用于自定义线程池中创建新线程时的行为
     */
    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new java.util.concurrent.ThreadPoolExecutor(nThreads, nThreads,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(),
                threadFactory);
    }

    /**
     * 这两个方法用于创建ForkJoin框架中用到的ForkJoinPool线程池
     * 参数用于指定并行数
     */
    public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
                (parallelism,
                        ForkJoinPool.defaultForkJoinWorkerThreadFactory,
                        null, true);
    }

    /**
     * 默认使用当前机器可用的CPU个数作为并行数
     */
    public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
                (Runtime.getRuntime().availableProcessors(),
                        ForkJoinPool.defaultForkJoinWorkerThreadFactory,
                        null, true);
    }

    /**
     * 用于创建只有一个线程的线程池
     * 线程池中的任务使用无界队列存储
     */
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
                (new java.util.concurrent.ThreadPoolExecutor(1, 1,
                        0L, TimeUnit.MILLISECONDS,
                        new LinkedBlockingQueue<Runnable>()));
    }

    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
                (new java.util.concurrent.ThreadPoolExecutor(1, 1,
                        0L, TimeUnit.MILLISECONDS,
                        new LinkedBlockingQueue<Runnable>(),
                        threadFactory));
    }

    /**
     * 用于创建线程数数目可以随着实际情况自动调节的线程池
     */
    public static ExecutorService newCachedThreadPool() {
        return new java.util.concurrent.ThreadPoolExecutor(0, Integer.MAX_VALUE,
                60L, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>());
    }
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new java.util.concurrent.ThreadPoolExecutor(0, Integer.MAX_VALUE,
                60L, TimeUnit.SECONDS,
                new SynchronousQueue<Runnable>(),
                threadFactory);
    }

    /**
     * 用于创建只有一个线程的线程池，并且该线程定时周期性地执行给定的任务
     */
    public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new DelegatedScheduledExecutorService
                (new ScheduledThreadPoolExecutor(1));
    }
    public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
        return new DelegatedScheduledExecutorService
                (new ScheduledThreadPoolExecutor(1, threadFactory));
    }


    /**
     * 用于创建一个线程池，线程池中得线程能够周期性地执行给定的任务
     * corePoolSize是核心线程数，由于使用了无界队列，所有执行线程最大只有核心线程数
     */
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

    public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

    /**
     * 用于包装现有的线程池，包装之后的线程池不能修改，相当于final的
     */
    public static ExecutorService unconfigurableExecutorService(ExecutorService executor) {
        if (executor == null)
            throw new NullPointerException();
        return new DelegatedExecutorService(executor);
    }

    /**
     * 用于包装可以周期性执行任务的线程池，包装之后的线程池不能修改，相当于final
     */
    public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor) {
        if (executor == null)
            throw new NullPointerException();
        return new DelegatedScheduledExecutorService(executor);
    }

    /**
     * 返回默认的工厂方法类，默认的工厂方法为线程池中新创建的线程命名为
     * pool-[虚拟机中线程池编号]-thread-[线程编号]
     */
    public static ThreadFactory defaultThreadFactory() {
        return new DefaultThreadFactory();
    }

    /** Cannot instantiate. */
    private Executors() {}
}

private volatile int count = 0;

private void add() {
	try {
		Thread.sleep(1);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	this.count++;
}


public void test(int size) {
	count = 0;
	log.info("begin size: {}, count:{}", size, count);
	for (int i = 0; i < size; i++) {
		new Thread(() -> add()).start();
	}

	log.info("over size: {}, count:{}", size, count);

}

private int numOne;
private int numTwo;
private int numThree;
private String str;
private volatile boolean initFlag = false;


public void init(){
	numOne = 1;
	numTwo = 2;
	numThree = 3;
	str = "abc";
	initFlag = true;

}