50行代码手写线程池

hi wei

已于 2022-11-21 17:07:30 修改

阅读量3.1k

点赞数 2

分类专栏： # 并发编程文章标签： java

于 2021-09-29 14:38:17 首次发布

本文链接：https://blog.csdn.net/nianqrzhanghw/article/details/120205051

版权

并发编程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文探讨了使用线程池的原因，着重于减少内核态与用户态切换带来的性能损耗。通过实例讲解MyThreadPoolExecutor，揭示了线程池结构和创建目的。了解如何通过核心大小、任务队列和工作线程池来提升并发性能。

摘要由CSDN通过智能技术生成

为什么使用线程池？

JVM使用的线程模型是KLT（Kernel Level Thread）模型。KLT是内核级线程模型，线程的创建、阻塞、销毁等操作都是在内核空间进行的。所以在对线程进行操作的时候，要进行用户态和内核态的交换，这个交换是比较耗时。所以为了减少线程频繁创建销毁带来的开销，所以使用池化技术来解决这个问题。

线程池的结构

在这里插入图片描述

简易线程池实现

package org.example.thread;

import java.util.HashSet;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @Description:
 * @Author: zhanghaiwei
 * @CreateTime: 2022/11/21 17:01
 */
public class MyThreadPoolExecutor {
    /**
     * 任务队列
     */
    private final BlockingQueue<Runnable> queue;
    /**
     * 线程池
     */
    private final HashSet<Worker> pool = new HashSet<>();
    private final int coreSize;
    private volatile AtomicInteger aliveThread;

    private final Lock lock = new ReentrantLock();

    public MyThreadPoolExecutor(Integer poolSize, BlockingQueue<Runnable> queue){
        coreSize = poolSize;
        this.queue = queue;
    }

    public void execute(Runnable task){
        if(aliveThread.get()>=coreSize){
            try {
                queue.put(task);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            try{
                lock.lock();
                if(aliveThread.get()>=coreSize){
                    queue.put(task);
                }else{
                    Worker worker = new Worker();
                    pool.add(worker);
                    worker.setTask(task);
                    worker.thread.start();
                    aliveThread.getAndIncrement();
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }
    private class Worker implements Runnable{
        public void setTask(Runnable task) {
            this.task = task;
        }
        private Runnable task;
        public Thread thread;
        Worker(){
            thread = new Thread(this);
        }
        @Override
        public void run() {
            runTask();
        }
        private void runTask() {
            for(;;){
                if(task!=null){
                    task.run();
                }else{
                    try {
                        Runnable task = queue.take();
                        task.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                task=null;
            }
        }
    }
}