并发学习笔记 (6)

tutorial site1
tutorial site2

一个问题：

每启动一个新线程都会有相应的性能开销(涉及到OS的交互：建立线程，销毁线程)，并且每一个线程都须要给栈分配一些内存等等。这种代价随着新线程不断的建立，将会大大下降性能甚至使JVM崩溃。

如何解决？
使线程能够复用，执行完一个任务，并不被销毁，而是能够继续执行其余的任务。这样避免了建立以及销毁线程的代价以及线程过多形成内存消耗过分以及切换过分问题。

线程池

何为线程池

线程池（Thread Pool）的引入就是：限制应用程序中同一时刻运行的线程数。根据系统的环境，能够手动或者自动设置线程数量，达到最佳效果。

能够把并发执行的任务传递给一个线程池，来替代为每一个并发执行的任务都启动一个新的线程。只要池里有空闲的线程，任务就会分配给一个线程执行。 在线程池的内部，任务被插入一个阻塞队列(任务队列), 线程池的线程会去取这个队列的任务。当一个新任务插入队列时，一个空闲线程就会成功的从队列中取出任务并执行它。

线程池常常应用在多线程服务器上。每一个经过网络到达服务器的链接都被包装成一个任务而且传递给线程池。线程池的线程会并发的处理链接上的请求。Java 5 在 java.util.concurrent 包中自带了内置的线程池，因此你不用非得实现本身的线程池。

好处

线程池的做用：
合理利用线程池可以带来三个好处。
第一：下降资源消耗。经过重复利用已建立的线程下降线程建立和销毁形成的消耗。
第二：提升响应速度。当任务到达时，任务能够不须要等到线程建立就能当即执行。
第三：提升线程的可管理性。线程是稀缺资源，若是无限制的建立，不只会消耗系统资源，还会下降系统的稳定性，使用线程池能够进行统一的分配，调优和监控。可是要作到合理的利用线程池，必须对其原理了如指掌。

线程池实现了系统中线程的数量。
根据系统的环境状况，能够自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了形成系统拥挤效率不高。用线程池控制线程数量，其余线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务须要运行时，若是线程池中有等待的工做线程，就能够开始运行了；不然进入等待队列。

实现

JUC 包，线程池顶级接口是Executor. 可是严格意义讲Executor并非一个线程。 而只是一个执行线程的工具。真正的线程池的接口是ExecutorService.

ExecutorService	真正的线程池的接口
ScheduledExecutorService	能和Timer/TimerTask相似，解决那些须要任务重复执行的问题
ThreadPoolExecutor	ExecutorService的默认实现
ScheduledThreadPoolExecutor	继承 ThreadPoolExecutor 的 ScheduledExecutorService 接口实现，周期性任务调度的类实现

要配置一个线程池是比较复杂的，尤为是对于线程池的原理不是很清楚的状况下，颇有可能配置的线程池不是较优的，所以在 Executors 类里面提供了一些静态工厂，生成一些经常使用的线程池。
1. newSingleThreadExecutor()
建立一个单线程的线程池。这个线程池只有一个线程在工做，也就是至关于单线程串行执行全部任务。若是这个惟一的线程由于异常结束，那么会有一个新的线程来替代它。此线程池保证全部任务的执行顺序按照任务的提交顺序执行。

javapublic classMyThread extends Thread {
    publicvoid run() {
        System.out.println(Thread.currentThread().getName() + " 正在执行。。。");
    }
}

public classTestSingleThreadExecutor {
    public static void main(String[] args) {
        // 建立一个可重用固定线程数的线程池
        ExecutorService pool = Executors.newSingleThreadExecutor();
        // 建立实现了 Runnable 接口对象，Thread 对象固然也实现了 Runnable 接口
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        Thread t3 = new MyThread();
        Thread t4 = new MyThread();
        Thread t5 = new MyThread();
        // 将线程放入池中进行执行
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        // 关闭线程池
        pool.shutdown();
    }
}

2.newFixedThreadPool()
建立固定大小的线程池。每次提交一个任务就建立一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，若是某个线程由于执行异常而结束，那么线程池会补充一个新线程。

javapublicclass TestFixedThreadPool {
    publicstaticvoid main(String[] args) {
        // 建立一个可重用固定线程数的线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        // 建立实现了 Runnable 接口对象，Thread 对象固然也实现了 Runnable 接口
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        Thread t3 = new MyThread();
        Thread t4 = new MyThread();
        Thread t5 = new MyThread();
        // 将线程放入池中进行执行
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        // 关闭线程池
        pool.shutdown();
    }
}

1. newCachedThreadPool
   建立一个可缓存的线程池。若是线程池的大小超过了处理任务所须要的线程，
   那么就会回收部分空闲（60 秒不执行任务）的线程，当任务数增长时，此线程池又能够智能的添加新线程来处理任务。此线程池不会对线程池大小作限制，线程池大小彻底依赖于操做系统（或者说 JVM）可以建立的最大线程大小。

javapublicclass TestCachedThreadPool {
    publicstaticvoid main(String[] args) {
        // 建立一个可重用固定线程数的线程池
        ExecutorService pool = Executors.newCachedThreadPool();
        // 建立实现了 Runnable 接口对象，Thread 对象固然也实现了 Runnable 接口
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        Thread t3 = new MyThread();
        Thread t4 = new MyThread();
        Thread t5 = new MyThread();
        // 将线程放入池中进行执行
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        // 关闭线程池
        pool.shutdown();
    }
}

4.newScheduledThreadPool
建立一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

javapublicclass TestScheduledThreadPoolExecutor {
    publicstaticvoid main(String[] args) {
        ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);
        exec.scheduleAtFixedRate(new Runnable() {// 每隔一段时间就触发异常
                      @Override
                      publicvoid run() {
                           //throw new RuntimeException();
                           System.out.println("================");
                      }
                  }, 1000, 5000, TimeUnit.MILLISECONDS);
        exec.scheduleAtFixedRate(new Runnable() {// 每隔一段时间打印系统时间，证实二者是互不影响的
                      @Override
                      publicvoid run() {
                           System.out.println(System.nanoTime());
                      }
                  }, 1000, 2000, TimeUnit.MILLISECONDS);
    }
}