线程池相关学习_class workthread extends thread

线程池的创建方式？

Executors.newCachedThreadPool(); 可缓存线程池

Executors.newFixedThreadPool(); 可定长度  限制最大线程数

Executors.newScheduledThreadPool(); 可定时

Executors.newSingleThreadExecutors(); 单例

底层都是基于ThreadPoolExecutor构造函数封装

这以上四种方式都是在我们的jdk中已经封装好了的，但是在实际项目中我们不会去使用。

因为这四种方式存在着一个很大的缺陷，因为它的底层采用的是无界队列缓存我们的任务的，

那么就有可能会发生我们的线程池溢出的情况。

代码演示：

package com.atqiyu.threadpool;
 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
/**
 * @author 7575
 * @version 1.0
 * 我亦无他，唯手熟尔！
 */
public class Test05 {
    public static void main(String[] args) {
        /*ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0;i < 10;i++)  {
            final int finalI = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+","+ finalI);
                }
            });
        }*/
 
 
        /*ExecutorService executorService = Executors.newFixedThreadPool(2);
        for (int i = 0;i < 10;i++)  {
            final int finalI = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+","+ finalI);
                }
            });
        }*/
 
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0;i < 10;i++)  {
            final int finalI = i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+","+ finalI);
                }
            });
        }
 
 
 
 
    }
}

我们发现线程池并没有得到复用,通过阅读源码可以知道：

核心线程数：0

最大线程数：无限

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
   
}

线程池底层是如何实现复用的？

本质思想：创建一个线程，不会立马停止或者销毁而是一直实现复用。

1.提前创建固定大小的线程一直保持在运行状态；（可能会非常消耗cpu的资源）

2.当需要线程执行任务，将该任务提交缓存在并发队列中；如果缓存队列满了，则会执行拒绝策略；

3.正在运行的线程从并发队列中获取任务从而实现多线程复用问题；

 线程池的核心点：复用机制 --------

1、提前创建好固定的线程一直在运行状态--------死循环实现

package com.atqiyu.threadpool;
 
/**
 * @author 7575
 * @version 1.0
 * 我亦无他，唯手熟尔！
 */
public class Test04 {
    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                System.out.println("666666");
            }
        }).start();
    }
}

2、提交的线程任务缓存到一个并发队列集合中，交给我们正在运行的线程执行

3、正在运行的线程就从队列中获取该任务执行

java纯手写线程池：

package com.atqiyu.threadpool;
 
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
 
/**
 * @author 7575
 * @version 1.0
 * 我亦无他，唯手熟尔！
 *
 * 线程池核心点：复用机制 ------
 * 1.提前创建好固定的线程一直在运行状态------死循环实现
 * 2.提交的线程任务缓存到一个并发队列集合中，交给我们正在运行的线程执行
 * 3.正在运行的线程就从队列中获取该任务执行
 */
public class MyExecutors {
    private List<WorkThread> workThreads;
    // 缓存我们的线程任务
    private BlockingDeque<Runnable> runnableDeque;
    private boolean isRun = true;
 
    /**
     * 最大线程数
     * @param maxThreadCount
     */
    public MyExecutors(int maxThreadCount,int dequeSize) {
        //2.限制队列容量缓存大小
        runnableDeque = new LinkedBlockingDeque<>(dequeSize);
        //1.提前创建好固定的线程一直在运行状态------死循环实现
        workThreads = new ArrayList<>(maxThreadCount);
        for (int i=0;i < maxThreadCount;i++) {
//            new WorkThread().start();
            WorkThread workThread = new WorkThread();
            workThreads.add(workThread);
            workThread.start();
        }
 
 
    }
 
    /**
     * 工作线程
     */
    class WorkThread extends Thread {
        @Override
        public void run() {
            while (isRun||runnableDeque.size()>0) {
                Runnable runnable = runnableDeque.poll();
                if ( runnable != null) {
                    runnable.run();
                }
            }
        }
    }
 
    /**
     * 缓存线程任务
     * @param command
     * @return
     */
    public boolean execute(Runnable command) {
        return runnableDeque.offer(command);
    }
 
    public static void main(String[] args) {
        MyExecutors myExecutors = new MyExecutors(2, 20);
        for (int i = 0;i < 10;i++) {
            int finalI = i;
            myExecutors.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+ "," + finalI);
                }
            });
        }
        myExecutors.isRun = false;
    }
 
}