线程池

　　所谓的线程池指的就是多个线程封装在一起操作。

线程池简介

　　在生活之中经常遇见这样的场景，例如：现在于经理说了。兄弟们有活，三天完成，要求20个人一起干，相当于20个人就是20个线程，这些线程捆绑在一起执行。

　　但是在实际的环境下也有可能出现这样几种情况，

　　　　这个活很大，有多少人我要多少人，一直到完成；

　　　　这个活很大，但是就要求只能招聘10个人

　　　　这个活很大，但是就允许一个人做。

　　从JDK1.5之后追加了一个并发访问的程序包：java.util.concurrent,对于此线程的操作核心类和接口定义在此包中，这里面有两个核心的接口：

　　　　普通执行线程池定义：java.util.concurrent Interface ExecutorService

　　　　调度线程池：java.util.concurrent Interface ScheduledExecutorService

　　那么如果要进行线程池的创建一般使用java.util.concurrent.Executors类完成

　　　　创建无大小限制的线程池：public static ExecutorService newCachedThreadPool

　　　　创建固定大小的线程池：public static ExecutorService newFixedThreadPool(int nThreads)

　　　　创建单线程池：public static ScheduledExecutorService newSingleScheduledExecutor()

　　　　创建定时调度池：public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

1.创建无线大小的线程池

 1 package cn.Tony.demo;
 2 
 3 import java.util.concurrent.ExecutorService;
 4 import java.util.concurrent.Executors;
 5 
 6 public  class TestDemo {
 7     public static void main(String[] args) throws Exception {
 8         //创建了一个线程池的模型，但是里面现在没有线程
 9         ExecutorService executorService = Executors.newCachedThreadPool();
10         for(int x=0;x<10;x++) {
11             Thread.sleep(200);
12             int index=x;//保存一下x的内容
13             executorService.submit(() ->{
14                 System.out.println(Thread.currentThread().getName()+",x="+index);
15             });//执行线程操作
16         }
17         executorService.shutdown();//关闭线程池
18     }
19 }

2.创建单线程的线程池

 1 package cn.Tony.demo;
 2 import java.util.concurrent.ExecutorService;
 3 import java.util.concurrent.Executors;
 4 
 5 public  class TestDemo {
 6     public static void main(String[] args) throws Exception {
 7         //创建了一个线程池的模型，但是里面现在没有线程
 8         ExecutorService executorService = Executors.newSingleThreadExecutor();
 9         for(int x=0;x<10;x++) {
10             Thread.sleep(200);
11             int index=x;//保存一下x的内容
12             executorService.submit(() ->{
13                 System.out.println(Thread.currentThread().getName()+",x="+index);
14             });//执行线程操作
15         }
16         executorService.shutdown();//关闭线程池
17     }
18 }

3.创建固定大小的线程池

 1 package cn.Tony.demo;
 2 import java.util.concurrent.ExecutorService;
 3 import java.util.concurrent.Executors;
 4 
 5 public  class TestDemo {
 6     public static void main(String[] args) throws Exception {
 7         //创建了一个线程池的模型，但是里面现在没有线程
 8         ExecutorService executorService = Executors.newFixedThreadPool(5);
 9         for(int x=0;x<10;x++) {
10             Thread.sleep(200);
11             int index=x;//保存一下x的内容
12             executorService.submit(() ->{
13                 System.out.println(Thread.currentThread().getName()+",x="+index);
14             });//执行线程操作
15         }
16         executorService.shutdown();//关闭线程池
17     }
18 }

4.定时调度池

 1 package cn.Tony.demo;
 2 import java.util.concurrent.Executors;
 3 import java.util.concurrent.ScheduledExecutorService;
 4 import java.util.concurrent.TimeUnit;
 5 
 6 public  class TestDemo {
 7     public static void main(String[] args) throws Exception {
 8         //创建一个具备有三个大小的定时调度线程池
 9         ScheduledExecutorService  executorService = Executors.newScheduledThreadPool(1);
10         for(int x=0;x<10;x++) {
11             int index=x;//保存一下x的内容
12             executorService.scheduleAtFixedRate(new Runnable() {
13                 @Override
14                 public void run() {
15                     System.out.println(Thread.currentThread().getName()+",x="+index);
16                 }
17             },3,2,TimeUnit.SECONDS);//使用的是一个秒的单位。表示3秒后开始执行。而后没两秒执行一次
18         }
19     }
20 }

　　线程池给开发者带来唯一好处是允许多个线程按照组的模式进行程序的处理，这在某一个业务逻辑非常的复制的环境下，性能可以得到很好的提升。