详细介绍线程池的使用原理、参数介绍、优点、常见构造方法、使用案例、模拟实现

最新推荐文章于 2024-07-10 21:37:49 发布

Y君的进化史

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量1.2k

点赞数 12

分类专栏： java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_68700019/article/details/132059217

版权

java 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

前言

创建和销毁一个线程时，这点损耗是微不足道的，但是当需要频繁的创建和销毁多个线程时，这个成本是不可忽视的，于是就有大佬创建了线程池，借助线程池来减少其中的成本。

前言

一、线程池的使用原理

二、线程池的参数介绍

三、使用Executors 创建常见的线程池

一、线程池的使用原理

当有对象申请创建线程池时：

所以在使用线程池的线程的时候，线程已经提前被创建好了，并且用户不使用这个线程时，这个线程会被线程池回收，等待下一次调用。

二、线程池的参数介绍

有很多接口丰富的线程池类，本文这里只讲一个（讲解接口最丰富的类）

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler);

三、使用Executors 创建常见的线程池

Executors.newFixedThreadPool(int num);//创建一个固定线程数量的线程池

Executors.newCachedThreadPool();//创建出一个线程数目动态变化的线程池

Executors.newSingleThreadExecutor();//包含单个线程的线程池（比原生api更简单）

Executors.newScheduledThreadPool();//类似于定时器，可能由多个线程执行

都是依靠使用submit方法，将任务添加到线程中。

四、线程池的使用案例

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

public class Main {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(4);
        service.submit(new Runnable() {
            @Override
            public void run() {
               while(true){
                   System.out.println(Thread.currentThread().getName()+111);
               }
            }
        });
        service.submit(new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println(Thread.currentThread().getName()+222);
                }
            }
        });

    }
}

运行截图：

五、线程池的模拟实现

class MyExecutor{
    private int num;//线程数量
    MyExecutor(int num){
        this.num = num;
        MyTake myTake = new MyTake();
        myTake.start();
    }

    volatile BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
    static Object object = new Object();
    class MyTake extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < num; i++) {
                Thread thread = new Thread() {
                    @Override
                    public void run() {
                        synchronized (object) {
                            try {
                                //为了使线程池一直处于运行状态
                                while(true){
                                    //执行任务
                                    while (queue.isEmpty()) {
                                        object.wait();
                                    }
                                    Runnable runnable = queue.take();
                                    runnable.run();
                                }
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                };
                thread.start();
            }
        }
    }

    public void submit(Runnable runnable){
        synchronized (object){
            try {
                queue.put(runnable);
                object.notify();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}