多线程（3）：

哈喽大家好，多线程（3）来啦！！

上一篇文章介绍到了多线程的调度和同步、锁，有了锁之后就可以让数据共享变的更安全。这一篇文章先来介绍一下线程池：

1、线程池：

什么是线程池？

咱们也不看长篇大论，通俗的来讲，线程池就是装线程的容器，当需要用的时候去池里面取出来，不用的时候放回去或者销毁。这样一个线程就可以反复的利用，通过线程的这种反复利用机制，可以有效地避免直接创建线程所带来的坏处。

线程池有什么好处？

降低了资源的消耗（CPU）
提高任务执行的响应速度
提高线程的可管理性

线程池创建流程图：
在这里插入图片描述
其实通过这个图就可以看到线程池的处理过程：

有新任务进来，判断核心线程池是否满了，是：进入排，否：创建任务
在等待队列判断是否排满了，是：进入线程池，否：任务加入队列
判断线程池是否满了，是：拒绝执行任务，否：创建线程执行

2、创建线程池：

先看一下官网给出的创建方法（部分）：
在这里插入图片描述
完整的可以参考官方文档：

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/Executors.html

这里介绍四种常用的创建类型：

newCacheThreadPool（创建一个可缓存的线程池，有任务时才会创建新的线程）
newSingleThreadExecutor（创建一个单线程池，线程池中只有一个线程）
newFixedThreadPool(int a) （创建固定线程数量的线程池，输入参数：int类型）
newScheduledTreadPool （创建一个固定长度的线程池，并且以延时或定时的方式来执行线程）

1、newCacheThreadPool：

创建可缓存的线程对象，意思是这个任务需要几个线程来处理，就会创建几个线程：

线程需要执行的类：

public class MyRunnable implements Runnable{
    
    

    int num;

    public MyRunnable(int num) {
    
    
        this.num = num;
    }

    @Override
    public void run() {
    
    
        
        System.out.println(Thread.currentThread().getName()+"执行了："+num);
    }
}

测试类：

public class Test {
    
    
    public static void main(String[] args) {
    
    

        //创建单个线程池对象，里面线程只有一个
        ExecutorService cachedService = Executors.newCachedThreadPool();

        //执行5个任务
        for (int i = 1; i<= 5; i++) {
    
    
            cachedService.execute(new MyRunnable(i));
        }
    }
}

来看看结果：
在这里插入图片描述
OK，上述代码线程池用了5个线程来处理，那么如果我们在每次运行前加一次线程休眠会怎么样？
在每次执行后需要休眠0.5秒（500毫秒）：

public class Test {
    
    
    public static void main(String[] args) {
    
    
    
        //创建一个缓存的线程池对象
       
        ExecutorService cachedService = Executors.newCachedThreadPool();
        
        for (int i = 1; i<= 5; i++) {
    
    
                cachedService.execute(new MyRunnable(i));
                //线程休眠：
                try{
    
    
                    Thread.sleep(500);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
        }
    }
}

看看结果：
在这里插入图片描述
小结：

如果没有加线程休眠，线程池默认会创建多个线程池对象来帮你完成任务，执行更快完成并且销毁内存，释放资源。
如果添加了线程休眠，线程池会认为同少量的线程对象就可以完成这个任务，就不会帮你创建多个线程对象（因为时间足够，就没必要再创建）

2、newSingleThreadExecutor：

这个方法是创建只有一个线程的线程池，不管怎么样，多只有一个线程来帮你执行任务：

public class Test {
    
    
    public static void main(String[] args) {
    
    

        //创建单个线程池对象，里面线程只有一个
        ExecutorService singleService = Executors.newSingleThreadExecutor();

        //执行一百万次任务
        for (int i = 1; i<= 1000000; i++) {
    
    
            singleService.execute(new MyRunnable(i));
        }
    }
}

看看结果：
在这里插入图片描述
对吧，执行了1000000次也是一个线程在执行，因为这个线程池里面只有一个线程呀。

3、newFixedThreadPool(int a)：

这个方法就是创建固定线程数的线程池，比如我要一个这个池里面有10个线程，在后面输入参数即可：

public class Test {
    
    
    public static void main(String[] args) {
    
    

        //线程池创建固定数量的线程对象来执行任务，这里创建10个线程对象，由线程池管理生命周期
        ExecutorService singleService = Executors.newFixedThreadPool(10);
        //执行10个任务
        for (int i = 1; i<= 100; i++) {
    
    
            singleService.execute(new MyRunnable(i));
        }
    }
}

看看结果：
在这里插入图片描述
4、newScheduledTreadPool ：

创建一个固定长度的线程池，并且以延时或定时的方式来执行线程，也就是说使用这个方法创建的线程池可以自定义每次执行的时间：
Demo：

public class MyRunnable implements Runnable{
    
    

    @Override
    public void run() {
    
    
        System.out.println(Thread.currentThread().getName()+"延迟5秒执行，并且每2秒执行一次该任务：");
    }
}

测试类：

public class Test {
    
    
    public static void main(String[] args) {
    
    

        //线程池创建一个定时任务的线程对象
        ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
        /**
         *定时器执行的任务，并且按周期执行
         * 参数1：线程任务
         * 参数2:5秒之后开始执行
         * 参数3：执行后每2秒为一个周期去循环执行
         * 参数4：时间单位。枚举类型，我这指定秒（可以参考API）
         */
        service.scheduleAtFixedRate(new MyRunnable(),5,1, TimeUnit.SECONDS);
    }
}

看看结果：
在这里插入图片描述

3、线程池创建自定义线程：

当以上四种线程池满不足业务需求的时候，咱们也可以自定义线程池：
先来一个线程执行类：

public class MyRunnable implements Runnable{
    
    

    int num;

    public MyRunnable(int i) {
    
    

        this.num = num;
    }

    @Override
    public void run() {
    
    
        System.out.println(Thread.currentThread().getName()+"执行了"+num);
    }
}

测试类：

public class Test {
    
    
    public static void main(String[] args) {
    
    

        /**
         * 参数1：线程池有5个固定的线程对象
         * 参数2:当线程池的线程忙不过来的时候，最大线程数为7，也就是说线程对象就可以增加到7个（其中2个是临时线程）
         * 参数3：当临时线程对象超出300毫秒的时候还没有接到新任务，线程池就自动 销毁临时的线程对象
         * 参数4：时间单位。这指定秒，具体参考TimeUnit的枚举类型
         * 参数5：等待执行的任务序列4个（其中有4个任务序列等待线程池对象来执行任务）
         */

        ThreadPoolExecutor executor = new ThreadPoolExecutor(5,7,300, 
        					TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(4));

        for (int i = 0; i < 6; i++) {
    
    
            executor.execute(new MyRunnable(i));
            showInfo(executor);
        }
    }

	//获取线程的一些信息
    private static void showInfo(ThreadPoolExecutor executor) {
    
    
        System.out.println("线程池的总数量："+executor.getPoolSize());
        System.out.println("队列中等待执行的任务数："+executor.getQueue().size());
        System.out.println("已经执行完毕的任务数："+executor.getCompletedTaskCount());
        System.out.println("---------");
    }
}

4、Runnable和Callable的区别：

Runnable是不返还值的，而Callable可以返回值，具体可以看这篇博客（其实主要我也没深入学习这个哈哈）：
Runnable和Callable的区别

5、线程池总结：

通过这个文章，咱们对线程池有了基础的了解，如何去创建和使用，但这仅仅是最简单的，线程是一个复杂的东西，大家也可以参考其他技术博客来深入学习和研究，在创建线程池的时候，根据场景，合理设置线程池的各个参数，包括线程池数量、队列、线程工厂和拒绝策略，让资源更好的利用起来，这也是优化性能的关键。

在这里插入图片描述

Java真的不难（二十三）多线程（3）

多线程（3）：

1、线程池：

2、创建线程池：

3、线程池创建自定义线程：

4、Runnable和Callable的区别：

5、线程池总结：

猜你喜欢