Java四种线程池示例

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool：缓存线程池，大小不受限
newFixedThreadPool：指定大小线程池，能够控制最大并发数
newScheduledThreadPool：定长线程池，支持定时及周期性执行任务
newSingleThreadExecutor：线程池数量为1的线程池，单线程串行执行所有任务

代码示例：

package thread;



import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;



/**

 * 线程池测试

 * @author <u>sunlh</u>

 *

 */

public class ThreadPoolTest {



     public static void main(String[] args) {

           // 固定大小的线程池

           ThreadPoolTest.newFixedThreadPool();

           // 可缓存线程池

           ThreadPoolTest.newCachedThreadPool();

           // 单线程线程池

           ThreadPoolTest.newSingleThreadExecutor();

           // 定长线程池

           ThreadPoolTest.newScheduledThreadPool();

           

     }

     

     /**

      * 定长线程池，支持定时及周期性任务执行

      * 示例：5秒后开始执行，每隔2秒执行一次

      */

     public static void newScheduledThreadPool() {

           ScheduledExecutorService service = 
Executors.newScheduledThreadPool(4);

           service.scheduleAtFixedRate(new Runnable() {

                

                @Override

                public void run() {

                      System.out.println(Thread.currentThread().getName());

                }

           }, 5, 2, TimeUnit.SECONDS);

     }

     

     /**

      * 单线程化的线程池，等价于 Executors.newFixedThreadPool(1);

      * 线程池中只有一条工作线程，保证所有任务按照指定顺序执行，也就是单线程串行执行所有任务

      */

     public static void newSingleThreadExecutor() {

           ExecutorService service = 
Executors.newSingleThreadExecutor();

           for (int i = 0; i < 10; i++) {

                service.execute(new Runnable() {

                      

                      @Override

                      public void run() {

                           try {

                                 System.out.println(Thread.currentThread().getName());

                                 Thread.sleep(1000);

                           } catch (InterruptedException e) {

                                 e.printStackTrace();

                           }

                      }

                });

           }

     }

     

     /**

      * 可缓存线程池，创建线程数量没有限制

      * 如果长时间没有在线程池中提交任务，则该工作线程自动终止，

      * 终止后如果又有了新的任务，则重新创建线程进行执行，

      * 提交任务后，若有空闲线程，会使用已存在的空闲线程进行执行

      * *一定要注意控制并发数量，若大量线程同时运行，很会可能造成系统崩溃

      * 

      */

     public static void newCachedThreadPool() {

           ExecutorService service = 
Executors.newCachedThreadPool();

           for (int i = 0; i < 15; i++) {

                service.execute(new Runnable() {

                      

                      @Override

                      public void run() {

                           try {

                                 System.out.println(Thread.currentThread().getName());

                                 Thread.sleep(1000);

                           } catch (InterruptedException e) {

                                 e.printStackTrace();

                           }

                      }

                });

           }

     }

     

     /**

      * 固定大小线程池，可控制线程最大并发数，超出的线程会在队列中等待

      * 建议根据系统资源进行设置Runtime.getRuntime().availableProcessors()

      * 如果线程池中某一线程因为异常而结束，那么线程池会补充一个新线程

      */

     public static void newFixedThreadPool() {

           ExecutorService service = 
Executors.newFixedThreadPool(3);

           for (int i = 0; i < 10; i++) {

                

                service.execute(new Runnable() {

                      

                      @Override

                      public void run() {

                           try {

                                 System.out.println(Thread.currentThread().getName());

                                 Thread.sleep(1000);

                           } catch (InterruptedException e) {

                                 e.printStackTrace();

                           }

                      }

                });

           }

     }

}