Java的四種线程池的简单理解

参考自：点击打开链接

在正常的工作学习中，我们通常需要执行多种操作，而一个线程一次只能执行一个任务，而这就意味着，我们需要同时使用多个线程，而同时使用多个线程需要占据很大的内存，这显然与我们期望的有所区别，所以，线程池这个概念就随之产生了。那么，什么时线程池呢？

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。简而言之，线程池就是开辟出一块固定的订房用于存放线程，从而减少线程的重复创建，达到节省资源的目的。那么如何创建线程池呢？

在Java中，线程是有Executor这个类来是实现的，Executors类中支持创建四种现线程池，分别为：

1.newCachedThreadPool 创建一个无限大小的线程池，这个线程池是可缓存的线程池，如果线程池的长度超过了护处理的需求，可以灵活的回收线程。如果没有可以回收的线程，就新建一个线程。实例代码如下：

1. package test;  
2. import java.util.concurrent.ExecutorService;  
3. import java.util.concurrent.Executors;  
4. public class ThreadPoolExecutorTest {  
5.  public static void main(String[] args) {  
6.   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
7.   for (int i = 0; i < 10; i++) {  
8.    final int index = i;  
9.    try {  
10.     Thread.sleep(index * 1000);  
11.    } catch (InterruptedException e) {  
12.     e.printStackTrace();  
13.    }  
14.    cachedThreadPool.execute(new Runnable() {  
15.     public void run() {  
16.      System.out.println(index);  
17.     }  
18.    });  
19.   }  
20.  }  
21. }  

2.newFixedThreadPool 创建出一个定长的线程池，可以控制最大的线程并发数量，超出的线程会在队列中等待。实例代码如下：

1. package test;  
2. import java.util.concurrent.ExecutorService;  
3. import java.util.concurrent.Executors;  
4. public class ThreadPoolExecutorTest {  
5.  public static void main(String[] args) {  
6.   ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
7.   for (int i = 0; i < 10; i++) {  
8.    final int index = i;  
9.    fixedThreadPool.execute(new Runnable() {  
10.     public void run() {  
11.      try {  
12.       System.out.println(index);  
13.       Thread.sleep(2000);  
14.      } catch (InterruptedException e) {  
15.       e.printStackTrace();  
16.      }  
17.     }  
18.    });  
19.   }  
20.  }  
21. }  

3.newScheduledThreadPool 支持定时及周期性的任务执行，代码示例如下：

1. package test;  
2. import java.util.concurrent.Executors;  
3. import java.util.concurrent.ScheduledExecutorService;  
4. import java.util.concurrent.TimeUnit;  
5. public class ThreadPoolExecutorTest {  
6.  public static void main(String[] args) {  
7.   ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
8.   scheduledThreadPool.schedule(new Runnable() {  
9.    public void run() {  
10.     System.out.println("delay 3 seconds");  
11.    }  
12.   }, 3, TimeUnit.SECONDS);  
13.  }  
14. }  

4。 newSingleThreadExecutor 创建一个单线程的的线程池，只会用唯一的线程执行任务，所有的任务都按照顺序来执行。实例代码如下：

1. package test;  
2. import java.util.concurrent.ExecutorService;  
3. import java.util.concurrent.Executors;  
4. public class ThreadPoolExecutorTest {  
5.  public static void main(String[] args) {  
6.   ExecutorService singleThreadExecutor = Executors.newCachedThreadPool();  
7.   for (int i = 0; i < 100; i++) {  
8.    final int index = i;  
9.    singleThreadExecutor.execute(new Runnable() {  
10.     public void run() {  
11.      try {  
12.       while(true) {  
13.        System.out.println(index);  
14.        Thread.sleep(10 * 1000);  
15.       }  
16.      } catch (InterruptedException e) {  
17.       e.printStackTrace();  
18.      }  
19.     }  
20.    });  
21.    try {  
22.     Thread.sleep(500);  
23.    } catch (InterruptedException e) {  
24.     e.printStackTrace();  
25.    }  
26.   }  
27.  }  
28. }