java线程池练习

java线程池练习

引用自：http://blog.csdn.net/u011531613/article/details/61921473

　　如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。
　　那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？

为什么要用线程池？

• 减少线程创建及销毁所花的时间
• 避免过多的线程消耗系统内存

newFixedThreadPool： 创建一个指定线程数量的线程池，如果线程的个数超过线程池允许的最大数量，超出的线程会被存到队列中等待。

newCachedThreadPool： 创建一个可缓存线程池，线程的数量没有限制。如果工作线程空闲了指定时间，则该线程自动终止。

newScheduledThreadPool： 创建一个定长线程池，支持定时以及周期性的任务执行，类似Timer。

newSingleThreadExecutor： 创建一个单线程化的线程池。只创建一个线程来执行任务，并保证顺序地执行任务。如果它异常结束，也会有其他线程替代它。

代码参考自：http://cuisuqiang.iteye.com/blog/2019372

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ExecutorService;

/**
 * 线程池的练习
 * @author lijialin
 *
 */

public class ThreadPoolTest {

    public static void fixedThreadPoolTest() {
        int nThreads = 3; // 线程池的数量规定为3
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(nThreads);
        for(int i = 0; i < 10; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {// 每3秒输出3个
                public void run() {
                    try {
                        System.out.println(index);
                        Thread.sleep(3000); 
                    }catch(InterruptedException  e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    } 

    public static void cachedThreadPoolTest() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for(int i = 0; i < 10; i++) {
            final int index = i;
            try {
                Thread.sleep(index * 1000); // 确保每个线程都能执行完任务
            }catch(InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable(){
                public void run() {
                    System.out.println(index);
                }
            });
        }   
    }

    public static void scheduledThreadPool() {
        int corePoolSize = 3; // 线程池大小为3
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(corePoolSize);
        scheduledThreadPool.scheduleAtFixedRate(new Runnable(){ // 执行周期性的任务
            public void run() {
                System.out.println("delay 3 seconds"); 
            }
        }, 1, 3,TimeUnit.SECONDS); // 延迟1s后，每3s执行一次
    }

    public static void singleThreadExecutor() {
        // 创建唯一的线程
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for(int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable(){ // 按顺序执行
                public void run() {
                    try{
                        System.out.println(index);
                        Thread.sleep(2000);
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        fixedThreadPoolTest();
        cachedThreadPoolTest();
        scheduledThreadPool();
        singleThreadExecutor();
    }

}