JDK提供的四种线程池代码详解

一.线程池什么时候使用,会给我们带来什么好处?

如果很多用户去访问服务器,用户访问服务器的时间是非常短暂的,那么有可能在创建线程和销毁线程上花费的时间会远远大于访问所消耗的时间,如果采用线程池会使线程重复使用大大的提高效率.

在JDK1.5之前就有了线程池的概念,不过需要我们手动的去实现ThreadPool,在API中并没有叫"线程池"这个名字,而是叫做"执行程序".

根据CPU的情况 初始化 固定线程个数的线程池.

获取CPU上有多少个核....int processors = Runtime.getRunntime().availableProcessors()  ;

JDK1.5之后提供了4中线程池.

第一种线程池:固定个数的线程池

① fixedThreadPool:固定个数的线程池  一般会根据当前计算机的硬件情况来设置具体的最大线程数

Executors.newFixedThreadPool(5); 

第二种线程池:缓存的线程池

②cachedThreadPool:缓存线程池,无上限.如果并发访问量比较小,就可以使用这个不用考虑太多的问题,如果并发量很大,使用这个线程池会对服务器产生一定的压力

Executors.newCachedThreadPool();

第三种线程池:单一线程池

③singleThreadPool:单一线程池中永远会有一条线程,如果这条线程出现异常了会新创建一条线程完成其他任务.

Executors.newSingleThreadExecutor();

第四种线程池:固定个数的线程池，相比于第一个固定个数的线程池强大在  ①可以执行延时任务，②也可以执行带有返回值的任务。

④scheduledThreadPool:固定个数的线程池,可以执行延时任务,也可以执行带有返回值的任务.

Executors.newScheduledThreadPool(5);

以上四种具体看代码:(注释和笔记更加详细)

如果上面的四个都不满足你的要求 可以自定义线程池....要实现ThreadFactory接口.....

 ThreadPoolDemo.java

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolDemo {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        int processors = Runtime.getRuntime().availableProcessors();// 获得计算机有几个内核
        // System.out.println("pro : " + processors);

        //第一种线程池:固定个数的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(processors * 100);// 固定线程个数的线程池  让一个CPU核绑定100个线程,这种方式经常使用.
        // System.out.println(fixedThreadPool);
        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());// pool-1-thread-1
                }
            });
        }

        fixedThreadPool.shutdown();// 将线程池关闭  在做项目的时候一般是不会将线程池关闭的.

//=======================================================================================================
        //第二种线程池:缓存的线程池  空闲的线程会被循环的利用,线程池中30条线程也许可以处理100个并发
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();// 缓存线程池，无上限

        for (int i = 0; i < 100; i++) {
            cachedThreadPool.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        cachedThreadPool.shutdown();

//======================================================================================================
        //第三种线程池:单一线程池  当你想确保你的机器中只有一个线程运行,即使这个线程即使死了,也能原地满血复活,再有一个线程.
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();// 单一线程池,永远会维护存在一条线程

        for (int i = 0; i < 10; i++) {
            final int j = i;
            singleThreadPool.execute(new Runnable() {

                @Override
                public void run() {
                    /*
                     * if(j == 3) throw new RuntimeException("出异常了...");
                     */
                    System.out.println(Thread.currentThread().getName() + ":"
                            + j);
                }
            });
        }
        singleThreadPool.shutdown();
//=========================================================================================================
        //第四种线程池:固定个数的线程池，相比于第一个固定个数的线程池 强大在   ①可以执行延时任务，②也可以执行带有返回值的任务。
        //scheduledThreadPool.submit(); 执行带有返回值的任务
        //scheduledThreadPool.schedule()  用来执行延时任务.
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);//固定个数的线程池，可以执行延时任务，也可以执行带有返回值的任务。

        FutureTask<String> ft = new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("hello");
                return Thread.currentThread().getName();
            }
        });
        scheduledThreadPool.submit(ft);
        String result = ft.get();//通过FutureTask对象获得返回值.
        System.out.println("result : "+result);
        
        
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" : bobm!");
            }
        }, 3, TimeUnit.SECONDS);
    }
}