Java线程池及原理详解（原创）

个人简介

作者是一个来自河源的大三在校生，以下笔记都是作者自学之路的一些浅薄经验，如有错误请指正，将来会不断的完善笔记，帮助更多的Java爱好者入门。

Java线程池及原理

线程池的好处

• 可以实现线程的复用，避免重新创建线程和销毁线程。创建线程和销毁线程对CPU的开销是很大的。
• 可以限制最大可创建的线程数，可根据自己的机器性能动态调整线程池参数，提高应用性能。
• 提供定时执行、并发数控制等功能。
• 统一管理线程。

创建线程池的五种方式

• 1：缓存线程池（不推荐）
• 2：固定容量线程池（不推荐）
• 3：单个线程池（不推荐）
• 4：定时任务线程池（不推荐）
• 5：通过ThreadPoolExecutor构造方法创建线程池（阿里巴巴开发手册十分推荐）

前面4种创建线程池的方式都是通过Executors的静态方法来创建。

缓存线程池CachedThreadPool

	ExecutorService executorService = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
    
    
            final int finalI = i;
            executorService.execute(new Runnable() {
    
    
                public void run() {
    
    
                    System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
                }
            });
        }

为什么不推荐使用缓存线程池？源码分析

public static ExecutorService newCachedThreadPool() {
    
    
        return new ThreadPoolExecutor(0, 2147483647, 60L, TimeUnit.SECONDS, new SynchronousQueue());
    }

 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
    
    
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler);
    }

• 通过上面两个代码片段，我们可以看出CachedThreadPool的maximumPoolSize为Integer的最大值2147483647，相当于可以无限的创建线程，而创建线程是需要内存的，这样就会造成内存溢出，而且一般的机器也没用那么大的内存给它创建这么大量的线程。

固定容量线程池FixedThreadPool

• newFixedThreadPool(int num)，num就是我们要指定的固定线程数量

	ExecutorService executorService = Executors.newFixedThreadPool(5);

      for (int i = 0; i < 10; i++) {
    
    
          final int finalI = i;
          executorService.execute(new Runnable() {
    
    
              public void run() {
    
    
                  System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
              }
          });
      }

输出：

pool-1-thread-5<thread->run>4
pool-1-thread-4<thread->run>3
pool-1-thread-5<thread->run>5
pool-1-thread-3<thread->run>2
pool-1-thread-3<thread->run>8
pool-1-thread-3<thread->run>9
pool-1-thread-2<thread->run>1
pool-1-thread-1<thread->run>0
pool-1-thread-5<thread->run>7
pool-1-thread-4<thread->run>6

• 可以看出起到了线程的复用。

为什么FixedThreadPool是固定线程池？源码分析

public static ExecutorService newFixedThreadPool(int nThreads) {
    
    
        return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());
    }

• 通过这个源码可以看出，核心线程数（corePoolSize）和最大线程数（maximumPoolSize）都为nThreads，因为只有这样，线程池才不会进行扩容，线程数才固定。

单个线程池SingleThreadExecutor

	ExecutorService executorService = Executors.newSingleThreadExecutor();

      for (int i = 0; i < 10; i++) {
    
    
          final int finalI = i;
          executorService.execute(new Runnable() {
    
    
              public void run() {
    
    
                  System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
              }
          });

      }

为什么SingleThreadExecutor只含有一个线程？源码分析

public static ExecutorService newSingleThreadExecutor() {
    
    
        return new Executors.FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()));
    }

• 通过这个源码可以看出，核心线程数（corePoolSize）和最大线程数（maximumPoolSize）都为1，所以它只含有一个线程。

定时任务线程池ScheduledThreadPool

	  int initDelay=10; //初始化延时
      int period=1;//初始化延迟过了之后，每秒的延时

      ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

      scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
    
    
          @Override
          public void run() {
    
    
              System.out.println(Thread.currentThread().getName()+"<thread->run>");
          }
      },initDelay,period, TimeUnit.SECONDS);

• 这段代码的效果是：程序运行之后等10秒，然后输出第一次结果，之后每隔1秒输出一次结果。

为什么不推荐使用ScheduledThreadPool？源码分析

public ScheduledThreadPoolExecutor(int corePoolSize) {
    
    
        super(corePoolSize, 2147483647, 10L, TimeUnit.MILLISECONDS, new ScheduledThreadPoolExecutor.DelayedWorkQueue());
    }

• 可以看出ScheduledThreadPool的最大线程数（maximumPoolSize）为Integer的最大值2147483647，相当于可以无限的创建线程，而创建线程是需要内存的，这样就会造成内存溢出，而且一般的机器也没用那么大的内存给它创建这么大量的线程。

ThreadPoolExecutor创建线程池（十分推荐）

	ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20,
              2L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5),
              Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

      for (int i = 0; i < 12; i++) {
    
    
          final int finalI = i;
          threadPoolExecutor.execute(new Runnable() {
    
    
              public void run() {
    
    
                  System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
              }
          });
      }

ThreadPoolExecutor的七个参数详解

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

• corePoolSize：核心线程数。这些线程一旦被创建不会被销毁，是一直存在的。线程池默认是没有线程的，当有任务到来了，就会通过ThreadFactory去创建线程，并一直存在。
• maximumPoolSize：最大线程数。非核心线程数=maximumPoolSize-corePoolSize，非核心线程数其实就是可扩容的线程数，可能会被销毁。
• keepAliveTime：非核心线程的空闲存活时间。当通过扩容生成的非核心线程数在keepAliveTime这个时间后还处于空闲状态，则会销毁这些非核心线程。
• unit：keepAliveTime的时间单位，例如：秒
• workQueue：等待区。当来了>corePoolSize的任务时会把任务存放在workQueue这个阻塞队列中，等待其他线程处理。
• threadFactory：线程工厂。创建线程的一种方式。
• handler：拒绝策略。当来了>最大线程数+workQueue的容量则会执行拒绝策略

workQueue

• ArrayBlockingQueue：有界阻塞队列。队列有大小限制，当容量超过时则会触发扩容或者拒绝策略。

	public ArrayBlockingQueue(int capacity) {
    
    
        this(capacity, false);
    }

• LinkedBlockingQueue：无界阻塞队列，队列无大小限制，可能会造成内存溢出。

	 public LinkedBlockingQueue() {
    
    
        this(2147483647);
    }

handler

• AbortPolicy：直接抛异常

	public static class AbortPolicy implements RejectedExecutionHandler {
    
    
        public AbortPolicy() {
    
    
        }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    
    
            throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString());
        }
    }

• DiscardPolicy：不作任何操作。默默丢弃任务

	public static class DiscardPolicy implements RejectedExecutionHandler {
    
    
        public DiscardPolicy() {
    
    
        }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    
    
        }
    }

• DiscardOldestPolicy：丢掉存在时间最长的任务

	public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    
    
        public DiscardOldestPolicy() {
    
    
        }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    
    
            if (!e.isShutdown()) {
    
    
                e.getQueue().poll();
                e.execute(r);
            }

        }
    }

• CallerRunsPolicy：让提交任务的线程去处理任务

	public static class CallerRunsPolicy implements RejectedExecutionHandler {
    
    
        public CallerRunsPolicy() {
    
    
        }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    
    
            if (!e.isShutdown()) {
    
    
                r.run();
            }

        }
    }

threadFactory

	ThreadFactory threadFactory = Executors.defaultThreadFactory();

      threadFactory.newThread(new Runnable() {
    
    
          @Override
          public void run() {
    
    
              System.out.println("threadFactory");
          }
      }).start();

如何触发拒绝策略和线程池扩容？

	ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20,
              2L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5),
              Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

      for (int i = 0; i < 26; i++) {
    
     //并发数26
          final int finalI = i;
          threadPoolExecutor.execute(new Runnable() {
    
    
              public void run() {
    
    
                  System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
              }
          });
      }
      /**
       * 核心线程数=10，最大线程数=20，故可扩容线程数=20-10
       * BlockingQueue的大小为5，故等待区的大小为5，也就是当并发数<=核心线程数+5不会扩容，并发数大于16才会扩容
       *
       * 触发扩容：并发数>核心线程数+阻塞队列的大小
       * 对于这段代码，如果来了26个并发，10个并发会被核心线程处理，5个会在等待区，剩下11个会因为等待区满了而触发扩容
       * 因为这里最多能够扩容10个，这里却是11个，所以会触发拒绝策略
       */

为什么这段代码会触发拒绝策略

• 对于这段代码，如果来了26个并发，10个并发会被核心线程处理，5个会在等待区，剩下11个会因为等待区满了而触发扩容，但是又因为因为这里最多能够扩容10个，这里却是11个，所以会触发拒绝策略。

怎么触发扩容

• 触发扩容：并发数>核心线程数（corePoolSize）+阻塞队列（workQueue）的大小

使用Java纯手写一个线程池

• 这个留到下期文章再讲，敬请期待