线程池介绍

1.线程执行的时间：
T=T1(线程创建的时间)+T2(run方法执行的时间)+T3(线程销毁的时间）

2.线程池执行解决的问题：
解决线程反复的创建和销毁，做到线程可以复用

3.线程测试

public class ThreadPoolTest {
    static ThreadPoolExecutor threadPoolExecutor;
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE_SECONDS = 30;
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);
    static {
        threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,//核心线程数，就是线程池里面的核心线程数量
                MAXIMUM_POOL_SIZE,//最大线程数，线程池中的最大线程数
                KEEP_ALIVE_SECONDS,//线程存活时间
                TimeUnit.SECONDS,//线程存活时间的单位
                sPoolWorkQueue,//线程队列
                new ThreadFactory() {//线程创建工厂,如果线程池需要创建线程就会调用newThread来创建
                    @Override
                    public Thread newThread(@NonNull Runnable r) {
                        Thread thread=new Thread(r,"自己创建的线程");
                        thread.setDaemon(false);//不是守护线程
                        return new Thread(r);
                    }
                });

    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            Runnable runnable=new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("下载图片显示完毕"+Thread.currentThread().getName());
                }
            };
            //加入到线程队列中,寻找合适的时机执行
            threadPoolExecutor.execute(runnable);
        }
    }
}

每一秒都只会执行4个线程

4.线程池可能出现的异常以及Queue 的参数的区别

• Queue 的几个常用的参数
  BlockingQueue: 先进先出的一个队列 (Rxjava所使用的)
  SynchronousQueue: 线程安全的队列，它里面是没有固定的缓存的（OKHttp所使用的，只有自己获得的时候才知道缓
  PriorityBlockingQueue: 无序的可以根据优先级进行排序 ，指定的对象要实现 Comparable 作比较

public class ThreadPoolException {

    // 线程队列是 4  ， 核心线程数也是 4 ，最大线程数是 10 ，目前加入的Runnable有 20 个
    // 20 个都要放到队列中 ，但是队列只有 4  还有 16 个是没法放，这个时候最大线程数 是 10 非核心线程是 6 ，
    // 那么会拿 6 个出来执行，这个时候会 从新创建 6 个线程，目前线程池就到达 10 个线程，
    // 但是还有 10 个没办法放就只能抛异常了，意味着那 10 个Runnable 没办法执行就会跑异常
    static ThreadPoolExecutor threadPoolExecutor;

    /*  private static final BlockingQueue<Runnable> sPoolWorkQueue =
              new LinkedBlockingQueue<>(4);*/
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new PriorityBlockingQueue<>(4);

    // Queue 的参数
    // BlockingQueue: 先进先出的一个队列 (Rxjava所使用的)
    // SynchronousQueue: 线程安全的队列，它里面是没有固定的缓存的（OKHttp所使用的，只有自己获得的时候才知道缓存的数据）
    // PriorityBlockingQueue: 无序的可以根据优先级进行排序 ，指定的对象要实现 Comparable 作比较
    static {
        threadPoolExecutor = new ThreadPoolExecutor(
                4,//核心线程数，就是线程池里面的核心线程数量
                10,//最大线程数，线程池中的最大线程数
                30,//线程存活时间
                TimeUnit.SECONDS,//线程存活时间的单位
                sPoolWorkQueue,//线程队列
                new ThreadFactory() {//线程创建工厂,如果线程池需要创建线程就会调用newThread来创建
                    @Override
                    public Thread newThread(@NonNull Runnable r) {
                        Thread thread = new Thread(r, "自己创建的线程");
                        thread.setDaemon(false);//不是守护线程
                        return new Thread(r);
                    }
                });

    }

    public static void main(String[] args) {

    /*    for (int i = 0; i < 20; i++) {
            Runnable runnable=new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("下载图片显示完毕"+Thread.currentThread().getName());
                }
            };*/
        //使用PriorityBlockingQueue队列
        Request request = new Request();
        //加入到线程队列中,寻找合适的时机执行
        threadPoolExecutor.execute(request);
    }
}

Request代码

public class Request implements Runnable,Comparable<Request> {
    @Override
    public int compareTo(@NonNull Request request) {
        return 0;
    }

    @Override
    public void run() {

    }
}