手写java线程池 java线程池使用方法

1、为什么会出现线程池这种概念和功能呢？

第一：一个线程的创建和销毁是需要消耗系统资源和时间的，一个线程执行任务的周期等于：线程创建的时间 + 线程执行任务的时间 + 线程销毁的时间；如果我们把线程的创建和销毁的时间去掉，那么这样就提高了线程的效率；

第二：如果每一个请求过来，都创建一个线程去处理它们，那么如果大量的请求一起过来时，会创建大量的线程，线程也是占用内存空间的，可能会导致内存溢出；就算内存没有溢出，大量的线程同时工作会导致CPU频繁的进行上下文切换，导致线程阻塞，反而影响了性能；

2、线程池有哪些部分组成？

第一：队列 它的主要作用是存放任务的，起到一个平衡的作用，消费线程如果忙不过来了，那么会将新的任务放到队列中；队列主要有以下属性

1、队列的容量：也就是队列最多存放的任务数量，如果队列里面的任务数量已经达到了最大的容量，那么新的任务就不能往里面添加了，增加任务的线程就需要进入等待状态，直到队列里面有空余的位置，这个时候唤醒处于等待状态的新增任务线程，让它继续新增任务到队列中

2、ReentrantLock锁对象，用于保证队列集合的线程安全

3、两个条件等待对象（休息室），一个用于新增任务线程的休息室，一个用于获取任务的休息室

第二：存放线程的集合，属性有

1、集合的大小：最多创建线程的数量，如果消费任务的线程已将达到了集合的最大值，那么新增的任务，就会被存放到队列中；

下面是代码的具体实现：

//队列对象
class Queue<T>{

    //任务队列
    private LinkedList list = new LinkedList();

    //锁
    private ReentrantLock lock = new ReentrantLock();

    //生产者线程休息室
    private Condition putWaitSet = lock.newCondition();

    //消费者线程休息室
    private Condition getWaitSet = lock.newCondition();

    //队列的容量
    public int queueSize;


    //将任务存放到队列中
    public void putTask(Object object){
        lock.lock();
        try{
            //如果队列已经满了，将当前线程暂停
           while (list.size() == queueSize){
               putWaitSet.await();
           }
           //将任务添加到队列最后面
            System.out.println("------- 新增任务："+object);
           list.addLast(object);
           //任务添加完成后，唤醒等待的消费者线程
            getWaitSet.signal();

        }catch (Exception e){

        }finally {
            lock.unlock();
        }

    }

    public Object get(){

        lock.lock();

        try{
            //如果队列里面没有任务，那么消费者线程就进行等待状态
            if (list.isEmpty()){
                getWaitSet.await();
            }
            //获取队列里面的第一任务，并删除
            Object obj = list.removeFirst();
            //获取任务后，唤醒新增任务休息室里面的线程
            putWaitSet.signal();
            return obj;

        }catch (Exception e){

        }finally {
            lock.unlock();
        }
        return null;
    }

public class ThreadPool {

    public static void main(String[] args) {

        ThreadPool threadPool = new ThreadPool();
        //设置线程池的最大线程数
        threadPool.coreSize = 2;
        //设置队列里面存放最大任务数
        threadPool.queue.queueSize = 2;


        threadPool.exec(new Object());
        threadPool.exec(new Object());
        threadPool.exec(new Object());
        threadPool.exec(new Object());
        threadPool.exec(new Object());
        threadPool.exec(new Object());
        threadPool.exec(new Object());
    }


    private Queue<Object> queue = new Queue<Object>();

    private HashSet<Work> set = new HashSet<Work>();




    private int coreSize;


    public void exec(Object object){

        if (set.size() < coreSize){
            Work work = new Work(object);
            set.add(work);
            work.start();
        }else {
            queue.putTask(object);
        }

    }

    class Work extends Thread{

        private Object object;

        public Work(Object object){
            this.object = object;
        }


        @Override
        public void run() {

            while (object != null || (object = queue.get()) != null){
                System.out.println(Thread.currentThread().getName()+":消费了对象："+object);
                object = null;
            }


        }
    }
}





}