java实现手写一个简单版的线程池

有些人可能对线程池比较陌生，并且更不熟悉线程池的工作原理。所以他们在使用线程的时候，多数情况下都是new thread来实现多线程。但是，往往良好的多线程设计大多都是使用线程池来实现的。 为什么要使用线程 降低资源的消耗。降低线程创建和销毁的资源消耗。提高响应速度：线程的创建时间为t1，执行时间t2，销毁时间t3，免去t1和t3的时间提高线程的可管理性

下图所示为线程池的实现原理：调用方不断向线程池中提交任务；线程池中有一组线程，不断地从队列中取任务，这是一个典型的生产者-消费者模型。

要实现一个线程池，有几个问题需要考虑：

• 队列设置多长？如果是*的，调用方不断往队列中方任务，可能导致内存耗尽。如果是有界的，当队列满了之后，调用方如何处理？
• 线程池中的线程个数是固定的，还是动态变化的？
• 每次提交新任务，是放入队列？还是开新线程
• 当没有任务的时候，线程是睡眠一小段时间？还是进入阻塞？如果进入阻塞，如何唤醒？

针对问题4，有3种做法：

• 不使用阻塞队列，只使用一般的线程安全的队列，也无阻塞/唤醒机制。当队列为空时，线程池中的线程只能睡眠一会儿，然后醒来去看队列中有没有新任务到来，如此不断轮询。
• 不使用阻塞队列，但在队列外部，线程池内部实现了阻塞/唤醒机制
• 使用阻塞队列

很显然，做法3最完善，既避免了线程池内部自己实现阻塞/唤醒机制的麻烦，也避免了做法1的睡眠/轮询带来的资源消耗和延迟。
现在来带大家手写一个简单的线程池，让大家更加理解线程池的工作原理

实战：手写简易线程池

根据上图可以知道，实现线程池需要一个阻塞队列+存放线程的容器

/**
 * five在努力
 * 自定义线程池
 */
public class threadpool {

    /** 默认线程池中的线程的数量 */
    private static final int work_num = 5;

    /** 默认处理任务的数量 */
    private static final int task_num = 100;

    /** 存放任务 */
    private final blockingqueue<runnable> taskqueue;

    private final set<workthread> workthreads;//保存线程的集合

    private int worknumber;//线程数量

    private int tasknumber;//任务数量

    public threadpool(){
        this(work_num , task_num);
    }

    public threadpool(int worknumber , int tasknumber) {
        if (tasknumber<=0){
            tasknumber = task_num;
        }
        if (worknumber<=0){
            worknumber = work_num;
        }
        this.taskqueue = new arrayblockingqueue<runnable>(tasknumber);
        this.worknumber = worknumber;
        this.tasknumber = tasknumber;

        workthreads = new hashset<>();

        //工作线程准备好了
        //启动一定数量的线程数，从队列中获取任务处理
        for (int i=0;i<worknumber;i++) {
            workthread workthread = new workthread("thead_"+i);
            workthread.start();
            workthreads.add(workthread);
        }
    }

    /**
     * 线程池执行任务的方法，其实就是往blockingqueue中添加元素
     * @param task
     */
    public void execute(runnable task) {
        try {
            taskqueue.put(task);
        } catch (interruptedexception e) {
            // todo auto-generated catch block
            e.printstacktrace();
        }
    }


    /**
     * 销毁线程池
     */
    public void destroy(){
        system.out.println("ready close pool...");
        for (workthread workthread : workthreads) {
            workthread.stopworker();
            workthread = null;//help gc
        }
        workthreads.clear();
    }

    /** 内部类，工作线程的实现 */
    private class workthread extends thread{
        public workthread(string name){
            super();
            setname(name);
        }
        @override
        public void run() {
            while (!interrupted()) {
                try {
                    runnable runnable = taskqueue.take();//获取任务
                    if (runnable !=null) {
                        system.out.println(getname()+" ready execute:"+runnable.tostring());
                        runnable.run();//执行任务
                    }
                    runnable = null;//help gc
                } catch (exception e) {
                    interrupt();
                    e.printstacktrace();
                }
            }
        }

        public void stopworker(){
            interrupt();
        }
    }
}

上面代码定义了默认的线程数量和默认处理任务数量，同时用户也可以自定义线程数量和处理任务数量。用blockingqueue阻塞队列来存放任务。用set来存放工作线程，set的好处就不用多说了。懂的都懂

构造方法中new对象的时候，循环启动线程，并把线程放入set中。workthread实现thread，run方法实现也很简单，因为有一个stop方法，所以这里需要while判断，之后从taskqueue队列中，获取任务。如何获取不到就阻塞，获取到的话runnable.run();就执行任务，之后把任务变成null

销毁线程只需要遍历set，把每个线程停止，并且变为null就行了

执行线程任务execute，只需要从往阻塞队列中添加任务就行了

测试一下：

public class testmyselfthreadpool {

    private static final int task_num = 50;//任务的个数

    public static void main(string[] args) {
        threadpool mypool = new threadpool(3,50);
        for (int i=0;i<task_num;i++) {
            mypool.execute(new mytask("task_"+i));
        }

    }

    static class mytask implements runnable{

        private string name;
        public mytask(string name) {
            this.name = name;
        }

        public string getname() {
            return name;
        }

        public void setname(string name) {
            this.name = name;
        }


        @override
        public void run() {
            try {
                thread.sleep(1000);
            } catch (interruptedexception e) {
                // todo auto-generated catch block
                e.printstacktrace();
            }
            system.out.println("task :"+name+" end...");

        }

        @override
        public string tostring() {
            // todo auto-generated method stub
            return "name = "+name;
        }
    }
}

结果ok。没什么问题

到此这篇关于java实现手写一个简单版的线程池的文章就介绍到这了,更多相关java 手写线程池内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！