Java手动版线程池实现

线程池是我们常用的对象主要用于在开发中减少频繁创建对象减少cpu 等资源的性能损耗

下面简单的实现一个线程池的实现

继承关系

 ThreadPoolExecutor 继承 AbstractExecutorServie 继承 ExecutorService接口 继承 顶级接口Executor 

定义一个线程池的实现类MyThreadPool 具体代码如下：

public class MyThreadPool {

    //默认初始化线程数

    private static int WORK_NUM = 5;

    //默认队列任务数

    private static int TASK_COUNT = 100;

    // 工作线程组

    private MyThreadPool.WorkThread[] workThreads;

    //定义一个任务队列

    private final BlockingQueuetaskQueue;

    //创建一个线程池用于用户希望启动线程数

    private final int woker_num;

    public MyThreadPool() {

        this (WORK_NUM, TASK_COUNT);

    }

    //构造方法

    public  MyThreadPool (int woker_num, int task_count) {

        if (woker_num <=0) woker_num = WORK_NUM;

        if (task_count <=0) task_count = TASK_COUNT;

        this.woker_num = woker_num;

        taskQueue  =  new ArrayBlockingQueue<>(task_count);

        workThreads = new WorkThread[woker_num];

        for (int i =0; i < woker_num; i++) {

            workThreads[i] =new WorkThread();

            //线程运行

            workThreads[i].start();

        }

        Runtime.getRuntime().availableProcessors();

    }

//执行任务 将任务放入到队列中去 执行有线程池决定

    public void execute(Runnable task) {

    try {

        taskQueue.put(task);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

}

   @Override

    public StringtoString() {

        return " workerThread number:" +woker_num +

        "wait task number:" +woker_num;

    }

  //销毁线程等所有的线程数执行完之后才执行

    public void destory() {

        System.out.println("ready close pool...");

        for (int i = 0 ; i < workThreads.length; i++) {

            workThreads[i].stopWorker();

            workThreads[i] =null; //help gc

        }

        taskQueue.clear();//清空任务队列

    }

    //线程工作内部类

    private class WorkThreadextends Thread {

        @Override

        public void run() {

            Runnable r =null;

            while (!isInterrupted()) {

            try {

                    r = taskQueue.take();

               } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            if (r!=null) {

                    System.out.println(getId()+" ready exec :"+r);

                    r.run();

                }

                r =null;//help gc;

            }

}

public void stopWorker() {

            interrupt();

        }

    }

}

定义一个测试类

public class TestMyThread {

    public static void main(String[] args) throws InterruptedException {

        MyThreadPool t =new MyThreadPool(3, 0);

        t.execute(new Task("testA"));

        t.execute(new Task("testB"));

        t.execute(new Task("testC"));

        t.execute(new Task("testD"));

        t.execute(new Task("testE"));

        System.out.println(t);

        Thread.sleep(10000);

        t.destory();//销毁线程池

        System.out.println(t);

    }

static class Taskimplements  Runnable {

        private Stringname;

        private Randomr =new Random();

        public Task(String name) {

        this.name = name;

        }

    public String    getName() {

            return name;

        }

        @Override

        public void run() {

            try {

                Thread.sleep(r.nextInt(1000)+2000);

            } catch (InterruptedException e) {

                        System.out.println(Thread.currentThread().getId()+" sleep InterruptedException:"

                        +Thread.currentThread().isInterrupted());

            }

                    System.out.println("任务" +name +"完成");

        }

    }

}