JAVA线程池

package com.thread;


public interface ThreadPool<Job extends Runnable> {
    //执行一个Job，Job必须实现Runnable接口
    void execute(Job job);
    //关闭线程池
    void shutdown();
    //添加工作者线程
    void addWorkers(int num);
    //减少工作者线程
    void removeWorkers(int num);
    //得到真在等待执行的任务的数量
    int getJobSize();
}

package com.thread;


import com.sun.tools.javac.comp.Annotate;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;

import com.thread.ThreadPool;

public class DefaultThreadPool<Job extends Runnable> implements ThreadPool<Job>{

    private static final int MAX_WORKER_NUMBER = 10;
    private static final int DEFAULT_WORKDER_NUMBER = 5;
    //线程池最小的数量
    private static final int MIN_WORKER_NUMBER = 1;
    private final LinkedList<Job> jobs = new LinkedList<Job>();

    private final List<Worker> workers = Collections.synchronizedList(new ArrayList<Worker>());

    private int workerNum = 5;

    private AtomicLong threadNum = new AtomicLong();

    public DefaultThreadPool() {
        initWorkers(DEFAULT_WORKDER_NUMBER);
    }

    public DefaultThreadPool(int num){
        workerNum = num > MAX_WORKER_NUMBER?MAX_WORKER_NUMBER:num < MIN_WORKER_NUMBER?MIN_WORKER_NUMBER:num;
        initWorkers(workerNum);
    }

    @Override
    public void execute(Job job) {
        if (job == null) {
            throw new NullPointerException();
        }
        synchronized (jobs) {
            jobs.addLast(job);
            jobs.notify();
        }
    }

    @Override
    public void addWorkers(int num) {
        synchronized (jobs) {
            if(num+this.workerNum>MAX_WORKER_NUMBER)
                num = MAX_WORKER_NUMBER - workerNum;
            initWorkers(num);
            workerNum+=num;
        }
    }

    @Override
    public void shutdown() {
        for (int i = 0; i < workers.size(); i++) {
            Worker worker = workers.get(i);
            worker.shutdown();
        }
    }

    @Override
    public void removeWorkers(int num) {
        synchronized (jobs) {
            if(num>=workerNum)
                throw new IllegalArgumentException("beyond worknum");
            //按照给定的数量关闭worker
            int count = 0;
            while(count<num){
                Worker worker = workers.get(count);
                if(workers.remove(worker)){
                    worker.shutdown();
                    count++;
                }
            }
            this.workerNum-=num;
        }
    }

    @Override
    public int getJobSize() {
        return this.workerNum;
    }

    //初始化线程工作者
    private void initWorkers(int num){
        for (int i = 0; i < num; i++) {
            Worker worker = new Worker();
            workers.add(worker);
            Thread thread = new Thread(worker, "ThreadPool-Worker-"+threadNum.getAndIncrement());
            thread.start();
        }
    }

    class Worker implements Runnable {

        private volatile boolean running = true;

        public void run() {
            while (running) {
                Job job = null;
                synchronized (jobs) {
                    while (jobs.isEmpty()) {
                        try  {
                            jobs.wait();
                        } catch (InterruptedException ex) {
                            Thread.currentThread().interrupt();
                            return;
                        }
                    }
                    job = jobs.removeFirst();
                }

                if (job != null) {
                    try {
                        job.run();
                    } catch (Exception ex) {

                    }
                }
            }
        }

        public void shutdown() {
            running = false;
        }
    }

}

package com.thread;

public class ThisTest {
    public static void main(String[] args) {

        ThreadPool<Runnable> pool = new DefaultThreadPool<>(2);
        for (int i = 0; i < 100; i++) {
            pool.execute(new countThread());
        }
    }

    static class countThread implements Runnable{
        private static volatile Integer count  = 0;
        private static Object object = new Object();

        @Override
        public void run() {
            synchronized(object){
                count++;
                 System.out.println(Thread.currentThread().getName() +  " " + count);
            }
        }

    }
}