java基础4

java基础4–池化技术

三大类型

源码分析：

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,//21亿
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

七大参数

七大参数

public ThreadPoolExecutor(	  int corePoolSize,//核心线程池大小
                              int maximumPoolSize,//最大核心线程池大小
                              long keepAliveTime,//超时每有调用就会被释放
                              TimeUnit unit,//超时单位
                              BlockingQueue<Runnable> workQueue,//阻塞队列
                              ThreadFactory threadFactory,//线程工厂
                              RejectedExecutionHandler handler) //拒绝策略
{
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

• 单个线程
• 创建一个固定大小的线程池
• 可伸缩创建线程池

import java.util.concurrent.*;

public class TestExe {
    public static void main(String[] args) {
        //单个线程执行
        ExecutorService threadPool= Executors.newSingleThreadExecutor();
        //创建一个固定大小的线程池
        ExecutorService threadPool1= Executors.newFixedThreadPool(6);
        //可伸缩创建大小
        ExecutorService threadPool2=Executors.newCachedThreadPool();
        try {
                    for (int i = 0; i < 100; i++) {
                    threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok");
                    }); }
                }catch (Exception e){
            e.printStackTrace();
        }
        finally {
                    threadPool.shutdownNow();
                }

        System.out.println("=====================");
        try {
            for (int i = 0; i < 100; i++) {
                threadPool1.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"结束！");
                }); }
        }finally {
            threadPool1.shutdownNow();
        }
        System.out.println("=====================");
        try {
            for (int i = 0; i < 100; i++) {
                threadPool2.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"线程创建完成！");
                }); }
        }finally {
            threadPool2.shutdownNow();
        }
    }

}

四大策略

四大策略处理

import java.util.concurrent.*;

public class Test02 {
    public static void main(String[] args) {
        ExecutorService threadPoll=new ThreadPoolExecutor(2,5,3,
                TimeUnit.SECONDS,new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());//超过最大线程数，就抛出异常
        try {
            for (int i = 0; i < 8; i++) {
                threadPoll.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPoll.shutdownNow();
        }

        ExecutorService threadPoll1=new ThreadPoolExecutor(2,5,3,
                TimeUnit.SECONDS,new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());//哪来的去哪里
        try {
            for (int i = 0; i < 10; i++) {
                threadPoll1.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok1111111111");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPoll1.shutdownNow();
        }

        ExecutorService threadPoll2=new ThreadPoolExecutor(2,5,3,
                TimeUnit.SECONDS,new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());//队列满了，丢掉任务，不会抛出异常！
        try {
            for (int i = 0; i < 10; i++) {
                threadPoll2.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok2222222222222222222");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPoll2.shutdownNow();
        }

        ExecutorService threadPoll3=new ThreadPoolExecutor(2,5,3,
                TimeUnit.SECONDS,new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());//队列满了，尝试去和最早的竞争，也不会抛出异常！
        try {
            for (int i = 0; i < 10; i++) {
                threadPoll3.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"ok333333333333333333333333333");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPoll3.shutdownNow();
        }
    }
}

小结和拓展

• CPU密集型

  找到最大的处理器核数

  Runnable.getRuntime().availableProcessors();
  

• IO密集型

  判断程序中十分耗io的线程，一般大于两倍的数量。