线程池的使用

ExecutorService pool = Executors.newFixedThreadPool(3);
pool.submit(new Runnable() {
  @Override
  public void run() {
    System.out.println("hello");
}
});

3.1、系统自带的线程池种类

//1、用来处理大量短时间工作任务的线程池，如果池中没有可用的线程将创建新的线程，如果线程空闲60秒将收回并移出缓存
ExecutorService cachedThreadPool= Executors.newCachedThreadPool();
//2、创建一个无界队列(没有大小限制)且固定大小的线程池
ExecutorService fixedThreadPool=Executors.newFixedThreadPool(3);
//3、创建一个操作无界队列且只有一个工作线程的线程池
ExecutorService singleThreadExecutor=Executors.newSingleThreadExecutor();
//4、创建一个单线程执行器，可以给定时间后执行或定期执行
ScheduledExecutorService singleThreadScheduleExecutor=Executors.newSingleThreadScheduledExecutor();
//5、创建一个指定大小的线程池，可以给定时间后执行或定期执行
ScheduledExecutorService scheduledThreadPool=Executors.newScheduledThreadPool(3);
//6、创建一个指定大小（不传入参数，为当前机器CPU核心数）的线程池，并行的处理任务，不保证处理顺序
Executors.newWorkStealingPool();

3.2、演示系统自带的线程池


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

/**
 * 演示系统自带的线程池
 */
public class Exe_01 {
    public static void main(String[] args) {
        //创建一个有三个线程的固定线程池
        ExecutorService newFixedThreadPool= Executors.newFixedThreadPool(3);
        //往线程池中添加任务
        newFixedThreadPool.submit(()->{
            System.out.println("全明星制作人们大家好!");
        });
        newFixedThreadPool.submit(()->{
            System.out.println("我是练习时长两年半的个人练习生");
        });
        newFixedThreadPool.submit(()->{
            System.out.println("咯咯");
        });
        newFixedThreadPool.submit(()->{
            System.out.println("你干嘛，哎呦");
        });
        //添加了多个任务，提交到线程池就执行了
        Thread thread=new Thread(() ->{
            for (int i = 0; i < 100; i++) {
                int task=i;
                newFixedThreadPool.submit(()->{
                    System.out.println("执行任务："+task+"...");
                });
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
    }
}

四、自定义实现线程池

1、管理任务的一个队列，可以用阻塞队列去实现。使用阻塞队列的好处是，当线程去取任务时，如果队列为空那么就阻塞等待，不会造成过多的CPU资源消耗.

2、提供一个往队列中添加任务的方法.

3、创建多个线程，扫描这个任务队列，如果有任务就拿出来执行.


import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 实现一个线程池
 */
public class MyThreadPool {
    //定义一个阻塞队列来管理任务
    BlockingQueue<Runnable> queue=new LinkedBlockingQueue<>();
    //定义一个往队列添加任务的方法
    public void submit(Runnable runnable) throws InterruptedException {
        //把任务加入队列
        queue.put(runnable);
    }
    //提供一个创建线程数量的构造方法
    public MyThreadPool(int num){
        if(num<=0){
            throw new RuntimeException("线程数量不能小于0");
        }
        //创建线程
        for (int i = 0; i < num; i++) {
            Thread thread=new Thread(() ->{
                while(true){
                    try {
                        //从队列中获取任务
                        Runnable task = queue.take();
                        //执行任务
                        task.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            //启动线程
            thread.start();
        }
    }
}


public class Exe_03 {
    public static void main(String[] args) {
        MyThreadPool ThreadPool=new MyThreadPool(3);
        //提交任务
        for (int i = 0; i < 100; i++) {
            int task=i;
            try {
                ThreadPool.submit(()->{
                    System.out.println("执行任务："+task+"...");
                });
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

往线程池中添加任务就会自动执行

五、线程池的七个参数

1、下午想去吃个烧烤，最近有个”Ikun火锅店“非常火爆，去晚了要去排队。

2、烧烤店里面有五张桌子(核心线程数)，去了早了，店里没有人直接上桌就行。

3、越到饭店的时候人越来越多，这时五张桌子已经坐满了，那么就需要在外面抽个号排个队，最多可以排到20号(相当于阻塞队列，20是队列的大小) 。

4、排队的也越来越多，于是老板为了赚钱，就在外面加了10张桌子(临时线程)。

5、排号的人就可以在外面吃烧烤。

6、随着时间越来越晚，吃饭的人走的差不多了，外面的桌子也就空了出来，排队的人也没有了，再等30分钟(临时线程存活时间，和时间单位)没人就把桌子收起来。

7、等了一会，老板一看没有人了，外面的桌子也没有人坐了，就把外面的桌子收起来。

8、店里的那5张桌子(最后回归核心线程数)就可以满足上客的需求。

9、中途如果排号20号排满了，10张临时桌子也满了，老板就暂时不接待新客人了(相当于是拒绝策略)。

5.1、线程池的工作流程

5.2、拒绝策略

Java提供了四种拒绝策略

直接拒绝是系统默认策略

比如说，烧烤客满了，老板见到新的客人上门时，直接拒绝。

烧烤客满了，客人上门来，老板对客人说，你看见有空了你自己就找地方坐下，也就是说谁提交的任务就把这个任务退给谁，保证这个任务有线程执行就行。

最早进入阻塞队列的任务被无情抛弃。

新提交的任务全部抛弃掉，不理会。

抛弃的任务就没有拥有者，也就是抛弃了之后就再也找不回来了。

5.3、演示拒绝策略


import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 演示拒绝策略
 */
public class Exe_05 {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor poolExecutor=new ThreadPoolExecutor(
                3,//核心线程数
                10,//最大线程数
                1,//临时线程的存活时间
                TimeUnit.SECONDS,//临时线程的存活单位
                new LinkedBlockingQueue<>(20),//阻塞队列的类型和大小
                new ThreadPoolExecutor.AbortPolicy());//直接拒绝策略
        for (int i = 0; i < 100; i++) {
            int task=i;
            poolExecutor.submit(()->{
                System.out.println("执行了任务"+task+",当前线程:"+Thread.currentThread());
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

运行结果：

我们在使用线程池的时候，尽量不要使用JDK提供的线程池，而在使用的时候通过ThreadPoolExecutor去创建，并指定参数类型和大小

六、线程的优点总结

1、创建一个新线程的代价要比创建一个进程的代价要小的多。

2、与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多。

3、线程占用的资源要比进程少很多。

4、能充分的利用多处理器的可并行数量。

5、在等待I/O操作结束的同时，程序可执行其它的计算任务。

6、计算密集型应用，为了能在多处理器系统上运行，将计算机分解到多个线程中实现。

7、I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/o操作。