java手写线程池,完善中
package com.test001.threadpool; import java.util.LinkedList; import java.util.List; import java.util.Random; import java.util.Vector; import java.util.concurrent.Callable; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicLong; public class ThreadPool <T>{ private int maxRunThreadNum; private int maxWaitTaskNum; private int minActiveThreadNum; private int addTaskTimeout; private Vector<Worker> workerList; private static ThreadPool threadPool; private LinkedBlockingQueue<Task<T>> taskBlockingDeque; private AtomicLong workingNum = new AtomicLong(); //初始化参数 private ThreadPool(){ maxRunThreadNum = 10; maxWaitTaskNum = 50; minActiveThreadNum = 5; addTaskTimeout = 5; workerList = new Vector<>(maxRunThreadNum); taskBlockingDeque = new LinkedBlockingQueue<>(maxWaitTaskNum); createWorker(minActiveThreadNum); } public synchronized static <T> ThreadPool<T> getThreadPool(){ if(threadPool==null){ threadPool = new ThreadPool<T>(); } return threadPool; } public synchronized void close(){ for (Worker worker:workerList){ worker.close(); worker.interrupt(); } } // 添加线程 private synchronized boolean createWorker(int num){ if(workerList.size()+num<maxRunThreadNum){ for (int i=0;i<num;i++) { Worker worker = new Worker(); workerList.add(worker); worker.start(); } return true; } return false; } public Future<T> addTask(Callable<T> callable) throws Exception { // TODO::考虑 计算当前启动的worker和最大worker之间的数量 以及当前正在运行的和启动的数量,启动更多worker System.out.println("add"); Task<T> task = new Task<>(callable); boolean flag = taskBlockingDeque.offer(task,addTaskTimeout, TimeUnit.SECONDS); if(!flag) return null; return task.getFuture(); } class Task<T>{ public Callable<T> getCallable() { return callable; } public void setCallable(Callable<T> callable) { this.callable = callable; } public Future<T> getFuture() { return future; } public void setFuture(Future<T> future) { this.future = future; } private Callable<T> callable; private Future<T> future; public Task(Callable<T> callable){ this.callable = callable; this.future = new Future<>(); } } class Worker extends Thread{ private boolean closeFlag = false; @Override public void run() { while(!closeFlag){ if(taskBlockingDeque.isEmpty()){ // TODO::新增信号量,等待唤醒 }else{ Task<T> task = taskBlockingDeque.poll(); if(task!=null){ Callable<T> callable = task.getCallable(); Future<T> future = task.getFuture(); try { workingNum.getAndDecrement(); T t = callable.call(); // System.out.println("get t="+t); future.set(t); workingNum.decrementAndGet(); } catch (Exception e) { e.printStackTrace(); } } } } } public void close(){ closeFlag = true; } } public static void main(String[] args) throws Exception { long startTime = System.currentTimeMillis(); //获取开始时间 ThreadPool<Integer> t = ThreadPool.getThreadPool(); List<Future<Integer>> futures = new LinkedList<>(); for (int i=1;i<=50;i++){ Integer data = i; Future<Integer> f = t.addTask(()->{ Random rd = new Random(); // int num = rd.nextInt(5)+1; int num = data; // System.out.println("start\tdata="+data+"\t thread="+Thread.currentThread().getName()+"\tsleep:"+num); Thread.sleep(num*1000); System.out.println("end\tdata="+data+"\tthread="+Thread.currentThread().getName()); return num; }); futures.add(f); } // Thread.sleep(25*1000); int i =0; for(Future<Integer> f :futures){ i++; System.out.println("get data\t"+i+"="+f.get()); } t.close(); long endTime = System.currentTimeMillis(); //获取结束时间 System.out.println("程序运行时间:" + (endTime - startTime) + "ms"); //输出程序运行时间 } } class Future<T>{ private volatile boolean hasResp = false; private T t; private Semaphore semaphore = new Semaphore(1); public Future(){ try { semaphore.acquire(); } catch (InterruptedException e) { e.printStackTrace(); } } public T get() throws InterruptedException { // 等待对应的信号量,然后到对应任务编号,取出对应的值 semaphore.acquire(); return t; } protected void set(T t){ this.t = t; semaphore.release(); } }