1 线程池-手写线程池

置顶 已于 2022-09-06 20:06:38 修改
阅读量691 收藏 6
点赞数
分类专栏： 线程池 文章标签： 线程池
于 2022-09-05 17:14:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010652576/article/details/126609970
版权

线程池系列文章

1 手写线程池
2 ThreadPoolExecutor分析
3 线程池扩展

线程池原理

线程池的思想依据就是常见的：池化思想。即：线程的创建和销毁是重操作（内存分配和销毁），因此考虑通过池化技术，实现线程池的复用。

线程池运行流程图

在这里插入图片描述

手写线程池

创建线程

创建线程的常用方法有两种，第一种：继承Thread，重写run方法；第二种：创建线程时，指定Runnable接口作为构造参数。常用第二种方法。

new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程启动");
            }
        }).start();

如果Thread可以setRunable，并且多次start，这样从runnable队列取runnable，set，start，就可以实现一个线程执行多个runnable，这可以看做从Thread外部解决问题。但是不支持，那就要从Thread内部解决。

简单线程池

外部处理Thread无法实现一个线程执行多个Runnable，从线程内部考虑，因为线程最终执行的是run方法，那么可以考虑run方法中死循环，循环内部从队列中获取Runnable，这样也实现一个Thread，执行多个Runnable。示例：
Run方法中循环从任务列表中获取任务，并执行，就是一个非常简单的线程池，只不过比较特殊。

List<Runnable> TASKS = new ArrayList();
new Thread(new Runnable() {
            @Override
            public void run() {
            	//run方法循环调用任务列表，直到任务列表为空，这样也实现了线程的复用。
                while (true) {
                    //获取任务
                    Runnable runnable = TASKS.get(0);
                    if (runnable != null) {                  
                        //获取任务
                        Runnable runnable = TASKS.get(0);
                        runnable.run();                           
                    } else {
                    	System.out.printf("超出等待时间,线程退出：%s", System.currentTimeMillis());
                        return; 
                    	
                    }
                }
            }
        }).start();

上述就是简单的线程池，只有一个线程，并且从队列获取任务没有考虑先关的并发性等，后面一步步的优化。

添加阻塞队列

前面的简单线程池，未考虑多线程问题，主要场景有两种：

  1. 业务线程提交任务到队列。
  2. 多线程从任务队列中获取任务。
    为了解决多线程的问题，添加一个带锁的队列，例如：ArrayBloockingQueue，LinkedBloockingQueue等。
Queue<Runnable> TASKS=new ArrayBlockingQueue(100);
public void run() {
                while (true) {
                   	Runnable runnable = TASKS.take();
                    if (runnable != null) {                  
                        //获取任务
                        Runnable runnable = TASKS.get(0);
                        runnable.run();                           
                    } else {
                    	System.out.printf("超出等待时间,线程退出：%s", System.currentTimeMillis());
                        return; 
                    	
                    }
                }
            }

上述代码可以进行优化一下：
优化后：

public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
           		Runnable task;
                while ((task =getTask())!=null) {
                    task.run();                    
                }
                //task==null时，线程就会退出。
            }
        }).start();
    }

	//获取任务，一直阻塞直到获取任务，暂时没有解决线程退出问题
    private static Runnable getTask() {
        try {
            return TASKS.take();
        } catch (InterruptedException e) {
            return null;
        }
    }

getTask有个缺陷take会一直阻塞到获取任务，那么当线程池空闲时，线程没有机会退出。

多个线程

通过Set集合，存储创建的线程。此处就不展示代码。

线程退出

getTask是一直阻塞，直到获取任务，因此可以考虑等待一段时间，没有获取任务后，自动唤醒，这样解决了线程退出的问题，但是却导致了其他问题。具体见：线程约定退出。

private static Runnable getTask() {
        try {
            //设置了等待超时时间，这样线程就可以退出了
            return TASKS.poll(THREAD_WAIT_TIME_SECONDS, TimeUnit.MILLISECONDS);            
        } catch (InterruptedException e) {
            //被打断，也未获取到任务
            return null;
        }
    }

线程条件退出

上述的线程退出有个致命的缺陷，当任务队列为空，也没有新的任务提交，那么getTask超时未获取任务，返回null，线程就会退出；当没有任务时，所有的线程都退出了，与我们使用线程池的初衷又相违背了。因此即使没有获取任务，也不能全部退出，只有符合约定条件后，线程才允许退出。主要的条件如下：
1 线程池关闭。2 当前线程数大于最大线程数。3 当前线程数大于核心线程数，并且队列为空。

private Runnable getTask() {
        //防止未获取任务，线程全部都退出，通过for循环，未获取任务后，判断是否符合退出的约定条件
        for (; ; ) {
            int curState = state.get();
            //线程池已经暂停
            if (curState >= STOP) {
                //线程池已停止，任务退出，尝试扣除线程总数，利用for循环，实现cas操作
                if (tryDecrThread()) {
                    return null;
                }
                continue;
            }
            //当前线程数，超过最大线程数，可以退出
            //当前线程数，超过核心线程数，并且队列为空，可以退出。
            int curTotal = total.get();
            if (curTotal > maxThreadSize
                    || (curTotal > coreThreadSize && TASKS.isEmpty())) {
            	//尝试扣减线程数
                if (tryDecrThread()) {
                    return null;
                }
                continue;
            }
            try {
                Runnable task = TASKS.poll(THREAD_WAIT_TIME_SECONDS, TimeUnit.MILLISECONDS);      
                if (task == null)
                    //未获取任务，for循环判断退出条件是否满足
                    continue;
                return task;
            } catch (InterruptedException e) {
                //被打断，不返回null，for循环判断退出条件是否满足
            }

        }
    }

主要逻辑：

  1. 通过for循环，防止所有线程全部退出。
  2. 通过条件判断，如果允许退出，扣减线程数量成功后，返回null，让线程退出。
  3. 上述逻辑还可以优化，主要是队列为空的判断，TASKS.empty()涉及加锁等操作，task为null时continue，其实task为null就已经表明队列为空了。因此可以优化为：
private Runnable getTask() {
		//超时未获取任务
		boolean timeout=false;
        //防止未获取任务，线程全部都退出，通过for循环，未获取任务后，判断是否符合退出的约定条
        for (; ; ) {
            int curState = state.get();
            //线程池已经暂停
            if (curState >= STOP) {
                //线程池已停止，任务退出，尝试扣除线程总数，利用for循环，实现cas操作
                if (tryDecrThread()) {
                    return null;
                }
                continue;
            }
            //当前线程数，超过最大线程数，可以退出
            //当前线程数，超过核心线程数，并且队列为空，可以退出。
            int curTotal = total.get();
            if (curTotal > maxThreadSize
                    || (curTotal > coreThreadSize && timeout)) {
            	//尝试扣减线程数
                if (tryDecrThread()) {
                    return null;
                }
                continue;
            }
            try {
                Runnable task = TASKS.poll(THREAD_WAIT_TIME_SECONDS, TimeUnit.MILLISECONDS);      
                if (task != null)              
                	return task;
                //未获取任务，for循环判断退出条件是否满足
                timeout=true;   
            } catch (InterruptedException e) {
                //被打断，不返回null，for循环判断退出条件是否满足
                timeout=false;
            }

        }
    }
  1. 上述getTask还是由一定的问题，TASKS.poll(THREAD_WAIT_TIME_SECONDS, TimeUnit.MILLISECONDS); 当线程池空闲时，线程数量=核心线程数后，线程就会处于：阻塞（队列获取任务）->唤醒（等待超时）->判断退出条件（不成立）->阻塞（队列获取任务）->唤醒（等待超时）的循环中。因此当空闲时间，希望线程直接阻塞，而BlockingQueue中的take方法：阻塞直到获取任务。优化之后的代码
private Runnable getTask() {
       
        boolean timeout=false;
         //防止未获取任务，线程全部都退出，通过for循环，未获取任务后，判断是否符合退出的约定条件
        for (; ; ) {
            int curState = state.get();
            //线程池已经暂停
            if (curState >= STOP) {
                //线程池已停止，任务退出，尝试扣除线程总数，利用for循环，实现cas操作
                if (tryDecrThread()) {
                    return null;
                }
                continue;
            }
            //当前线程大于核心线程数，那么线程需要一个退出机会
            boolean needExitChance = curTotal > coreThreadSize;

            //当前线程数，超过最大线程数，可以退出
            //当前线程数，超过核心线程数，并且队列为空，可以退出。
            int curTotal = total.get();
            if (curTotal > maxThreadSize
                    || (needExitChance && timeout)) {
            	//尝试扣减线程数
                if (tryDecrThread()) {
                    return null;
                }
                continue;
            }
            try {
            	//needExit线程需要退出，那么就等待超时获取任务，超时未获取任务，给线程一个退出的机会。如果不需要退出，直接阻塞在take方法中。
                Runnable task = needExitChance ? 
                	TASKS.poll(THREAD_WAIT_TIME_SECONDS, TimeUnit.MILLISECONDS):
                	TASKS.take();
                if (task != null)              
                	return task;
                //未获取任务，for循环判断退出条件是否满足
                timeout=true;   
            } catch (InterruptedException e) {
                //被打断，不返回null，for循环判断退出条件是否满足
                timeout=false;
            }
        }
    }

核心线程退出

上述线程池的退出流程：
超过最大线程数->最大线程数->空闲了->核心线程数，最终只能存活核心线程，而核心线程是不能退出的，如果需要核心线程退出，那么需要修改getTask。

private Runnable getTask() {
       
        boolean timeout=false;
         //防止未获取任务，线程全部都退出，通过for循环，未获取任务后，判断是否符合退出的约定条件
        for (; ; ) {
            int curState = state.get();
            //线程池已经暂停
            if (curState >= STOP) {
                //线程池已停止，任务退出，尝试扣除线程总数，利用for循环，实现cas操作
                if (tryDecrThread()) {
                    return null;
                }
                continue;
            }
            //当前线程数，超过最大线程数，可以退出
            //当前线程数，超过核心线程数，并且队列为空，可以退出。
            //当前允许核心线程退出，并且队列为空，可以退出。因为核心线程可以退出，因此需要严格校验队列是否为空，防止timeout失效。
            //核心线程也可以退出，因此needExit添加多个选择。
            boolean needExitChance  = coreThreadCanExit || curTotal > coreThreadSize;
            int curTotal = total.get();
            if (curTotal > maxThreadSize
                    || (needExitChance  && timeout) 
                    || (coreThreadCanExit && TASKS.isEmpty())) {
            	//尝试扣减线程数
                if (tryDecrThread()) {
                    return null;
                }
                continue;
            }
            try {
            	//needExit线程需要退出，那么就等待超时获取任务，超时未获取任务，给线程一个退出的机会。如果不需要退出，直接阻塞在take方法中。
                Runnable task = needExitChance ? 
                	TASKS.poll(THREAD_WAIT_TIME_SECONDS, TimeUnit.MILLISECONDS):
                	TASKS.take();
                if (task != null)              
                	return task;
                //未获取任务，for循环判断退出条件是否满足
                timeout=true;   
            } catch (InterruptedException e) {
                //被打断，不返回null，for循环判断退出条件是否满足
                timeout=false;
            }
        }
    }

添加线程

无需分辨线程是否是核心线程，因为无论核心线程，还是普通线程，都没有进行特殊处理。

/**
     * 添加线程 区分核心线程还是普通线程
     *
     * @param runnable 优先执行的任务
     * @param isCore   是否是核心线程
     */
    private boolean addThread(Runnable runnable, boolean isCore) {
    	mainLock.lock();
    	try{
			//获取当前线程数量
	        if (isCore && (THREADS.size() > coreThreadSize)) {
	            //超过核心线程数
	            return false;
	        } else if (THREADS.size() > maxThreadSize) {
	            return false;
	        }
	        Thread t = new Thread(new Runnable() {
	            @Override
	            public void run() {
	           		Runnable task;
	                while ((task =getTask())!=null) {
	                    task.run();                    
	                }
	                //task==null时，线程就会退出。
	            }
	        });
	        t.start();
	        THREADS.add(t);
	        return true;
		}finally{
			mainLock.unlock();
		}        
    }

任务入队列

/**
     * 任务进入队列
     */
    private boolean offerQueue(Runnable task) {
        return TASKS.offer(task);
    }

拒绝策略

/**
     * 拒绝
     */
    private void reject(Runnable task) {
        System.out.println("任务被拒绝");
    }

添加任务

public void addTask(Runnable runnable) {
        if (!addThread(runnable, true)) {
            //添加核心线程未成功
            if (!offerQueue(runnable)) {
                //入队列未成功
                if (!addThread(runnable, false)) {
                    //添加普通线程未成功
                    reject(runnable);
                }
            }
        }
    }

经过上述步骤，一个简单的线程池已经初见雏形，但是还有一些问题，例如：线程池状态、线程是否工作中等。

线程池状态

可以通过AtomicInteger表明线程的状态。
添加了如下状态：

/**线程池状态：运行中，可以接收新的任务*/
    private final Integer running = 1;
    /**线程池状态：关闭，不再接收新的任务，已经入队列的任务，会继续执行*/
    private final Integer shutDown = 2;
    /**线程池状态：暂停，不再接收新的任务，已经入队列的任务，直接返回。*/
    private final Integer stop = 3;
    /**线程池状态：终止，不再接收新的任务，所有的任务都已经完成，所有的线程都已经销毁。*/
    private final Integer terminated=4;

添加状态对线程池的可能影响场景：

  1. 添加任务时，判断状态：必须要判断。
  2. 添加线程时，判断状态：可以不进行判断，因为添加线程发生在添加任务后，添加任务已经校验，添加线程可以忽略。
  3. 获取任务时，判断状态。因为线程池如果stop，那么所有等待的任务都要取消执行。

相关代码修改

  1. 添加任务：
public void addTask(Runnable runnable) {
        if (!isRunning()) {
            throw new IllegalStateException("线程池已经关闭");
        }
        //省略
    }
  1. 获取任务
private Runnable getTask() {
        if (!notStopped()) {
            //线程池已经stop，暂停后续任务的执行
            return null;
        }
        //忽略
    }

shutdown线程池

关闭线程池：修改线程池状态，拒绝新的任务，唤醒所有的阻塞线程。

/**
     * 关闭线程池
     */
    public void shutDown() {
        //添加锁
        mainLock.lock();
        try {
        	//循环cas操作，忽略
            changeState(SHUTDOWN);
            //唤醒所有因为getTask导致阻塞的线程
            for (Thread thread : THREADS) {
                thread.interrupt();
            }
        } finally {
            mainLock.unlock();
        }
    }

stop线程池

/**
     * 关闭线程池：修改线程池状态，并返回所有待执行的任务
     *
     * @return
     */
    public List<Runnable> stop() {
        mainLock.lock();
        try {
        	//循环cas操作，忽略
            changeState(SHUTDOWN);
            //唤醒所有因为getTask导致阻塞的线程
            for (Thread thread : THREADS) {
                thread.interrupt();
            }
            return Lists.newArrayList(TASKS);
        } finally {
            mainLock.unlock();
        }
    }

区分线程运行中和等待中

通过shutdown和stop方法，核心还是唤醒所有的等待线程，通过interrupt打断线程的阻塞，但是有个问题，有可能任务（Runnable的run方法）存在阻塞情况，如果线程在run方法中，因为网络请求阻塞，那么shutdown和stop中的interrupt会打断上述业务阻塞，因需要唤醒等待任务的线程，但是缺误伤业务自身的阻塞。因此shutdown和stop当前线程时，需要判断线程状态：运行中（执行任务的run方法）、等待任务中（getTask阻塞）。
因此需要对Thread进行包装，需要带有状态识别，通过状态识别，区分任务状态。有两种方案：1. 状态标识符：通过AtomictBoolean判断。2. 锁：通过tryLock进行判断。
采用状态标识符进行处理，因此需要对Thread进行包装，包装后进行如下修改。

public class MyThreadPool {
    //线程池的队列
    private BlockingQueue<Runnable> TASKS = new ArrayBlockingQueue<>(100);
    //线程等待超时退出的时间
    private Long WAIT_TIMES_SECONDS = 1000L;
    //worker合集
    private Set<Worker> WORKERS = new HashSet<>(10);
    /**
     * 核心线程数
     */
    private Integer coreThreadSize;

    /**
     * 最大线程数
     */
    private Integer maxThreadSize;

    /**
     * 核心线程允许退出
     */
    private boolean coreThreadCanExit;


    /**
     * 当前线程数
     */
    private AtomicInteger total;

    /**
     * 线程等待时间
     */
    private Integer threadWaitingTime;
    /**
     * 线程池状态
     */
    private AtomicInteger state;
    /**
     * 线程池状态：运行中，可以接收新的任务
     */
    private final Integer RUNNING = 1;
    /**
     * 线程池状态：关闭，不再接收新的任务，已经入队列的任务，会继续执行
     */
    private final Integer SHUTDOWN = 2;
    /**
     * 线程池状态：暂停，不再接收新的任务，已经入队列的任务，直接返回。
     */
    private final Integer STOP = 3;
    /**
     * 线程池状态：终止，不再接收新的任务，所有的任务都已经完成，所有的线程都已经销毁。
     */
    private final Integer TERMINATED = 4;

    /**
     * 全局锁
     */
    private final ReentrantLock mainLock = new ReentrantLock();

    private final Integer THREAD_WAITING_TIME_DEFAULT = 1000 * 60;

    public MyThreadPool(Integer coreThreadSize, Integer maxThreadSize, Integer threadWaitingTime) {
        this(coreThreadSize, maxThreadSize, threadWaitingTime, false, new LinkedBlockingDeque());
    }

    public MyThreadPool(Integer coreThreadSize, Integer maxThreadSize, Integer threadWaitingTime, Boolean coreThreadCanExit, BlockingQueue queue) {
        this.coreThreadSize = coreThreadSize;
        this.maxThreadSize = maxThreadSize;
        this.threadWaitingTime = threadWaitingTime;
        this.coreThreadCanExit = coreThreadCanExit;
        this.TASKS = queue;
    }

    /**
     * 修改最大线程数
     */
    public boolean setMaxThreadSize(Integer maxThreadSize) {
        Integer temp = this.maxThreadSize;
        this.maxThreadSize = maxThreadSize;
        if (temp > this.maxThreadSize) {
            //降低线程数，需要处理等待中的线程
            interrupt();
        }
        return true;
    }

    public boolean setCoreThreadSize(Integer coreThreadSize) {
        Integer temp = this.coreThreadSize;
        this.coreThreadSize = coreThreadSize;
        if (temp > this.coreThreadSize) {
            //降低线程数，需要处理等待中的线程
            interrupt();
        }
        return true;
    }

    public void addTask(Runnable runnable) {
        if (!isRunning()) {
            throw new IllegalStateException("线程池已经关闭");
        }
        if (!addWorker(runnable, true)) {
            //添加核心线程未成功
            if (!offerQueue(runnable)) {
                //入队列未成功
                if (!addWorker(runnable, false)) {
                    //添加普通线程未成功
                    reject(runnable);
                }
            }
        }
    }


    /**
     * 关闭线程池：修改线程池状态，并返回所有待执行的任务
     *
     * @return
     */
    public List<Runnable> stop() {
        mainLock.lock();
        try {
            changeState(SHUTDOWN);
            //唤醒所有因为getTask导致阻塞的线程
            interrupt();
            return Lists.newArrayList(TASKS);
        } finally {
            mainLock.unlock();
        }
    }


    /**
     * 关闭线程池
     */
    public void shutDown() {
        //添加锁
        mainLock.lock();
        try {
            changeState(SHUTDOWN);
            //唤醒所有因为获取任务处于等待的线程
            interrupt();
        } finally {
            mainLock.unlock();
        }
    }

    private Runnable getTask() {

        boolean timeout=false;
        //防止未获取任务，线程全部都退出，通过for循环，未获取任务后，判断是否符合退出的约定条件
        for (; ; ) {
            int curState = state.get();
            //线程池已经暂停
            if (curState >= STOP) {
                //线程池已停止，任务退出，尝试扣除线程总数，利用for循环，实现cas操作
                if (tryDecrThread()) {
                    return null;
                }
                continue;
            }
            int curTotal = total.get();
            //当前线程数，超过最大线程数，可以退出
            //当前线程数，超过核心线程数，并且队列为空，可以退出。
            //当前允许核心线程退出，并且队列为空，可以退出。因为核心线程可以退出，因此需要严格校验队列是否为空，防止timeout失效。
            //核心线程也可以退出，因此needExit添加多个选择。
            boolean needExitChance = coreThreadCanExit || curTotal > coreThreadSize;
            if (curTotal > maxThreadSize
                    || (needExitChance && timeout)
                    || (coreThreadCanExit && TASKS.isEmpty())) {
                //尝试扣减线程数
                if (tryDecrThread()) {
                    return null;
                }
                continue;
            }
            try {
                //needExit线程需要退出，那么就等待超时获取任务，超时未获取任务，给线程一个退出的机会。如果不需要退出，直接阻塞在take方法中。
                Runnable task = needExitChance ?
                        TASKS.poll(threadWaitingTime, TimeUnit.MILLISECONDS):
                        TASKS.take();
                if (task != null)
                    return task;
                //未获取任务，for循环判断退出条件是否满足
                timeout=true;
            } catch (InterruptedException e) {
                //被打断，不返回null，for循环判断退出条件是否满足
                timeout=false;
            }
        }
    }


    private void changeState(Integer target) {
        //循环修改状态
        for (; ; ) {
            int currentState = state.get();
            if (currentState < target) {
                state.compareAndSet(currentState, SHUTDOWN);
                break;
            } else if (currentState == target) {
                break;
            }
        }
    }


    /**
     * 唤醒所有等待任务的worker
     */
    private void interrupt() {
        for (Worker work : WORKERS) {
            if (work.tryWait()) {
                work.interrupt();
            }
        }
    }

    /**
     * 添加线程 区分核心线程还是普通线程
     *
     * @param runnable 优先执行的任务
     * @param isCore   是否是核心线程
     */
    private boolean addWorker(Runnable runnable, boolean isCore) {
        mainLock.lock();
        try {
            //获取当前线程数量
            if (isCore && (WORKERS.size() > coreThreadSize)) {
                //超过核心线程数
                return false;
            } else if (WORKERS.size() > maxThreadSize) {
                return false;
            }
            Worker worker = new Worker(runnable);
            int totalNum;
            do {
                totalNum = total.get();
            } while (total.compareAndSet(totalNum, totalNum + 1));
            WORKERS.add(worker);
            try {
                worker.start();
                return true;
            } catch (Exception e) {
                removeWork(worker);
                return false;
            }
        } finally {
            mainLock.unlock();
        }
    }

    private void removeWork(Worker worker) {
        int curTotal;
        do {
            curTotal = total.get();
        } while (total.compareAndSet(curTotal, curTotal - 1));
        WORKERS.remove(worker);
    }


    /**
     * 任务进入队列
     */
    private boolean offerQueue(Runnable task) {
        return TASKS.offer(task);
    }

    /**
     * 拒绝
     */
    private void reject(Runnable task) {
        System.out.println("任务被拒绝");
    }


    private boolean isRunning() {
        return RUNNING.equals(state.get());
    }

    /**
     *
     */
    private boolean lessThanShutdown() {
        return RUNNING.equals(state.get());
    }

    /**
     * 未暂停
     */
    private boolean notStopped() {
        return state.get() > SHUTDOWN;
    }

    public boolean tryDecrThread() {
        int curTotal = total.get();
        return total.compareAndSet(curTotal, curTotal - 1);
    }

    private class Worker implements Runnable {
        //对线程进行包装
        private Thread thread;
        //第一个任务，如果不为空，先执行该任务
        private Runnable firstTask;
        //线程运行状态
        private AtomicBoolean workerState;
        //线程运行中
        private final Boolean WORKER_RUNNING = true;
        private final Boolean WORKER_WAITING = false;

        public Worker(Runnable firstTask) {
            workerState.set(WORKER_WAITING);
            firstTask = firstTask;
            Thread t = new Thread(this);
        }

        public Worker() {
            new Worker(null);
        }


        @Override
        public void run() {
            Runnable task = firstTask;
            while (task != null || (task = getTask()) != null) {
                //工作中
                working();
                try {
                    task.run();
                } catch (RuntimeException runtimeException) {
                    throw runtimeException;
                } catch (Exception exception) {
                    throw exception;
                } catch (Throwable throwable) {
                    throw throwable;
                } finally {
                    //完成工作
                    waiting();
                }
            }
        }

        public boolean isWorking() {
            return Boolean.TRUE.equals(workerState.get());
        }

        public boolean working() {
            for (; ; ) {
                if (WORKER_WAITING.equals(workerState.get())) {
                    workerState.compareAndSet(WORKER_WAITING, WORKER_RUNNING);
                } else {
                    return true;
                }
            }
        }


        public boolean waiting() {
            for (; ; ) {
                if (WORKER_RUNNING.equals(workerState.get())) {
                    workerState.compareAndSet(WORKER_RUNNING, WORKER_WAITING);
                } else {
                    return true;
                }
            }
        }

        public boolean tryWait() {
            return workerState.compareAndSet(WORKER_RUNNING, WORKER_WAITING);
        }

        public void interrupt() {
            thread.interrupt();
        }

        public void start() {
            thread.start();
        }
    }

}

上述代码主要修改：

  1. Thread包装为Worker。
  2. Worker添加的FirstTas为构造函数。
  3. Worker执行Runnable的run时，添加了状态的变动。
  4. 线程池关闭、暂停时，唤醒线程时，添加了worker状态的判断。

修改coreThreadSize和maxThreadSize

因为coreThreadSize和maxThreadSize都是参数，因此可以提供set方法进行修改，这样可以调整运行时的线程池。

/**
     * 修改最大线程数
     */
    public boolean setMaxThreadSize(Integer maxThreadSize) {
        Integer temp = this.maxThreadSize;
        this.maxThreadSize = maxThreadSize;
        if (temp > this.maxThreadSize) {
            //降低线程数，需要处理等待中的线程
            interrupt();
        }
        return true;
    }

    public boolean setCoreThreadSize(Integer coreThreadSize) {
        Integer temp = this.coreThreadSize;
        this.coreThreadSize = coreThreadSize;
        if (temp > this.coreThreadSize) {
            //降低线程数，需要处理等待中的线程
            interrupt();
        }
        return true;
    }

需要注意：当降低线程数时，有可能存在部分线程阻塞在getTask方法中，需要打断，这样才能唤醒线程，判断是否需要退出。

总结自定义线程池

  1. 首先Thread包装成Worker，带有是否工作中的标识，这样在interrupt时，防止打断业务内容的阻塞情况。
  2. 通过线程内部的while循环，实现一个线程执行多个Runnable信息，当Runnable==null时，线程退出。
  3. getTask内容的for循环，防止线程全部退出，同时如果获取的任务为null，然后条件判断，只有符合退出条件，线程才允许退出。
  4. getTask设置线程退出的场景，主要有：1 线程数超过最大线程。2 线程数超过核心线程数，并且队列为空；3 配置核心线程允许退出，并且队列为空。
jkf3333
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++ 手写一个线程池
余识-
07-08 1576
本章要介绍的是线程的进阶版本：线程池。如果你使用过线程，就会知道，每当你想要启用一个任务时，就必须手动去启动一个线程来执行指定的任务。这是很自然的想法，并且也并没有什么不对。当问题就出在，电脑CPU可以同时执行的线程数量并不是无限多的，比如我目前电脑CPU是4核8线程的，意思就是同时最多也只能执行8个线程。如果超过了这个数量，那么CPU就需要不断切换线程，调动资源，让其它线程也能进来运行一会。这个过程相当损耗性能。为了解决这个问题，就有了线程池的概念。
Java手写线程池的实现方法
08-27
Java手写线程池的实现方法 Java手写线程池的实现方法是指通过编写 Java 代码来实现一个线程池，线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台...
C++多线程编程-手写线程池
xiaoyou137的博客
02-14 574
需要使用支持C++17的编译器编译。
手写JAVA线程池
做笔记\记录遇到的程序bug
07-12 1320
手写JAVA线程池
Java手写线程池
qq_32486597的博客
03-10 5069
Java 手写线程池
手写线程池
weixin_55166254的博客
10-28 359
这里我是根据 低并发编程 公众号的文章思路代码实现的，详情可以看这里： https://mp.weixin.qq.com/s?__biz=Mzk0MjE3NDE0Ng==&mid=2247491549&idx=1&sn=1d5728754e8c06a621bbdca336d85452&chksm=c2c66570f5b1ec66df623e5300084257bd943b134d34e16abaacdb58834702dbbc4599868b89&scene=178&cur_album_id=1703494
手写windows下c++线程池
01-12
1、工作线程：不断的从任务队列里读取任务并且执行 2、管理线程：三秒中查询一次，根据任务和线程数量的比较来杀死线程或者生成线程 然后在需要调用线程池的地方往任务队列里添加函数就可以了。
线程池 C 语言 RTOS 版本
07-26
手写线程池，C语言版本，运行RTOS环境，既其他已经收集的资源
c++11编写的线程池
07-03
1. `std::thread`：这是一个类，用于创建新线程。你可以通过传递一个函数对象或成员函数以及它的参数来启动新线程。例如： ```cpp void func(); int main() { std::thread t(func); // 创建并启动新线程执行func() ...
手写RPC需求文档基于Bio+线程池
05-19
手写rpc需求文档
手写线程文档
03-21
大师教你手写线程池pdf ， 希望您早日成为架构师。
手写线程池（简易版）
m0_48480302的博客
03-30 141
线程池有哪些作用？ 核心点：复用机制 提前创建好固定的线程一直在运行状态 实现复用 限制线程创建数量。
一个简单的线程池实现
m3221456的专栏
10-27 379
一个linux下简单的线程池实现 实现了大部分逻辑，有部分逻辑未实现，只是提供一个思路
java—Tomcat高性能调优方案详解
u011277123的博客
10-09 1676
java飞虎队 2017-10-06 10:04 一丶原理 概要 Tomcat大致分为两个部分，Connector组件及Container组件。Connector组件负责控制入口连接，并关联着一个Executor。Container负责Servlet容器的实现，Executor负责具体的业务逻辑，如Servlet的执行。一个请求到达服务器后，经过以下关键几步，参见图1： 图一
java面试系列---线程池
喜羊羊love红太狼
04-01 127
目录 线程池的优势 ThreadPoorExecutor参数含义 线程池的工作原理： 四大拒绝策略 工作中怎么创建线程池： 合理配置线程池线程数？ 线程池的优势 特点：线程复用，控制最大并发数，管理线程。 ThreadPoorExecutor参数含义 coreThreadSize:核心线程池，线程池中固定线程数。 maxmumThreadSize:线程池中能够创建的最大线程数。 workQueue:阻塞队列，当任务数量大于核心线程数时，任务会放到阻塞队列中。 keepAliv.
理解ThreadPoolExecutor源码(一)线程池的corePoolSize、maximumPoolSize和poolSize
热门推荐
aty
09-13 5万+
我们知道，受限于硬件、内存和性能，我们不可能无限制的创建任意数量的线程，因为每一台机器允许的最大线程是一个有界值。也就是说ThreadPoolExecutor管理的线程数量是有界的。线程池就是用这些有限个数的线程，去执行提交的任务。然而对于多用户、高并发的应用来说，提交的任务数量非常巨大，一定会比允许的最大线程数多很多。为了解决这个问题，必须要引入排队机制，或者是在内存中，或者是在硬盘等容量很大的
手写实现线程池，思路与ExecutorService一致
攻城狮
07-25 5199
主要定义一个线程池应该具备的基本操作和方法 public interface ThreadPool { /** * 提交任务到线程池 * * @param runnable */ void execute(Runnable runnable); /** * 关闭线程池 */ void shutdo...
如何设计并实现一个db连接池？
weixin_34109408的博客
05-26 436
连接池的使命！ 无论是线程池还是db连接池，他们都有一个共同的特性：资源复用，在普通的场景中，我们使用一个连接，它的生命周期可能是这样的： 一个连接，从创建完毕到销毁，期间只被使用了一次（这里的一次是指在单个作用域内的使用），当周期结束，另外一个调用者仍然需要这个连接去做事，就要重复去经历这种生命周期。因为创建和销毁都是需要对应的服务消耗时间以及系统资源去处理的，这样不仅浪费了大量的系统资源，而...
线程池
sinat_26781639的博客
03-12 97
线程池 1、为什么要用线程池。 在多线程的情况下，系统频繁开启关闭线程会造成大量的资源浪费，成本很高，同时有导致系统崩溃的风险。 线程池理解为一个池子里面有一堆线程，用的时候拿一个，用完放回去。这样就避免了不断地开启关闭。。 2、线程池分类。 总共有四种比较常见的线程池 newCachedThreadPool ,newFixedThreadPool,newScheduledThreadPool,n...
线程池优化 手写java 线程池
最新发布
09-08
当手写一个简单的Java线程池时，你可以按照以下步骤进行: 1. 首先，你需要创建一个实现了Runnable接口的任务类。这个任务类将代表线程池中的每个任务。 ```java public class Task implements Runnable { @Override public void run() { // 任务执行的逻辑代码 } } ``` 2. 接下来，你需要创建一个线程池类，并初始化线程池的大小和其他相关参数。 ```java public class ThreadPool { private final int poolSize; private final List<Thread> threads; private final BlockingQueue<Runnable> taskQueue; public ThreadPool(int poolSize) { this.poolSize = poolSize; this.threads = new ArrayList<>(); this.taskQueue = new LinkedBlockingQueue<>(); } public void submit(Runnable task) { taskQueue.offer(task); } public void start() { for (int i = 0; i < poolSize; i++) { Thread thread = new Thread(() -> { while (true) { try { Runnable task = taskQueue.take(); task.run(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }); threads.add(thread); thread.start(); } } public void shutdown() { for (Thread thread : threads) { thread.interrupt(); } } } ``` 3. 最后，你可以使用线程池类来提交任务并启动线程池。 ```java public class Main { public static void main(String[] args) { ThreadPool threadPool = new ThreadPool(5); threadPool.start(); for (int i = 0; i < 10; i++) { threadPool.submit(new Task()); } // 关闭线程池 threadPool.shutdown(); } } ``` 这是一个简单的手写Java线程池的示例，但请注意，这个线程池的实现只是一个基本的框架，你可以根据自己的需求进行更复杂的优化和扩展。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值