自定义线程池

线程池

1.自定义线程池

• 自定义拒绝策略接口

  @FunctionalInterface
  public interface RejectPolicy<T> {
      /**
       * 自定义拒绝策略方法
       *
       * @param queue 阻塞队列
       * @param task 线程任务
       */
      void reject(BlockingQueue<T> queue, T task);
  }
  

• 自定义任务队列

  public class BlockingQueue<T> {
  
      // 1.任务队列
      private Deque<T> queue = new ArrayDeque<>();
  
      // 2.锁
      private ReentrantLock lock = new ReentrantLock();
  
      // 3.生产者条件变量
      private Condition fullWaitSet = lock.newCondition();
  
      // 4.消费者条件变量
      private Condition emptyWaitSet = lock.newCondition();
  
      //5.容量
      private int capcity;
  
      public BlockingQueue(int capcity) {
          if(capcity >= Integer.MAX_VALUE) {
              this.capcity = Integer.MAX_VALUE;
          }
          this.capcity = capcity;
      }
  
      /**
       * 最多阻塞 unit 时间单位后，返回线程任务
       *
       * @param timeout 等待时间
       * @param unit 时间单位
       * @return 线程
       */
      public T poll(long timeout, TimeUnit unit) {
          lock.lock();
  
          try {
              // 将 timeout 统一转换为 纳秒
              long nanos = unit.toNanos(timeout);
  
              while (queue.isEmpty()) {
  
                  try {
                      // 返回值是剩余时间
                      if(nanos <= 0) {
                          return null;
                      }
                      // 返回还需要阻塞多少时间
                      nanos = emptyWaitSet.awaitNanos(nanos);
                  }catch (InterruptedException e) {
                      e.printStackTrace();
                  }
  
              }
              // 队列不为空 有空闲线程可以使用
              T t = queue.removeFirst();
  
              fullWaitSet.signal();
  
              return t;
          } finally {
              lock.unlock();
          }
      }
  
  
      /**
       * 阻塞获取
       *
       * @return 线程
       */
      public T take() {
          lock.lock();
  
          try {
              while (queue.isEmpty()) {
                  try {
                      emptyWaitSet.await();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
              T t = queue.removeFirst();
              fullWaitSet.signal();
              return t;
          }finally {
              lock.unlock();
          }
      }
  
      /**
       * 加入阻塞队列
       *
       * @param task
       */
      public void put(T task) {
  
          lock.lock();
  
          try {
              while (queue.size() == capcity) {
                  try {
                      System.out.println("等待加入任务队列：" + task);
                      fullWaitSet.await();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
              System.out.println("加入任务队列：" + task);
              queue.addLast(task);
              emptyWaitSet.signal();
          }finally {
              lock.unlock();
          }
  
      }
  
  
      public int size() {
          lock.lock();
          try {
              return queue.size();
          }finally {
              lock.unlock();
          }
      }
  
      public void tryPut(RejectPolicy<T> rejectPolicy, T task) {
          lock.lock();
  
          try {
              // 判断队列是否满
              if(queue.size() == capcity) {
                  rejectPolicy.reject(this, task);
              }else {
                  System.out.println("加入任务队列：" + task);
                  queue.addLast(task);
                  emptyWaitSet.signal();
              }
          }finally {
              lock.unlock();
          }
      }
  
  }
  

• 自定义线程池

  public class DefaultRejectPolicy implements RejectPolicy<Runnable> {
  
      @Override
      public void reject(BlockingQueue<Runnable> queue, Runnable task) {
          // 默认拒绝策略为 让调用者自己执行任务
  
          task.run();
  
          // 1. 死等
          // queue.put(task);
  
          // 2. 带超时等待
          //
  
          // 3. 让调用者放弃任务执行
          // System.out.println("放弃： " + task);
  
          // 4. 让调用者抛出异常
          // throw new RuntimeException("任务执行失败: " + task);
  
  
      }
  }
  

  public class ThreadPool {
  
      // 任务队列
      private BlockingQueue<Runnable> taskQueue;
  
      // 任务线程集合
      private final HashSet<Worker> workers = new HashSet<>();
  
      // 核心线程数
      private int coreSize;
  
      // 拒绝策略
      private RejectPolicy<Runnable> rejectPolicy;
  
      // 获取任务的超时时间 (默认为 1 秒)
       private long timeout = 1;
  
       // 设置默认为
       private TimeUnit timeUnit = TimeUnit.SECONDS;
  
  
      public ThreadPool(int coreSize, RejectPolicy<Runnable> rejectPolicy, int queueCapcity) {
          this.coreSize = coreSize;
          this.rejectPolicy = rejectPolicy;
          this.taskQueue = new BlockingQueue<>(queueCapcity);
      }
  
      public ThreadPool(int coreSize, int queueCapcity, RejectPolicy<Runnable> rejectPolicy,
                        long timeout, TimeUnit timeUnit) {
  
          this.coreSize = coreSize;
          this.rejectPolicy = rejectPolicy;
          this.timeout = timeout;
          this.timeUnit = timeUnit;
          taskQueue = new BlockingQueue<>(queueCapcity);
      }
  
      /**
       * 执行任务
       *
       * @param task 任务
       */
      public void execute(Runnable task) {
          // 当任务数没有超过 coreSize 时， 直接交给 worker 对象执行
          // 如果任务数超过 coreSize 时，加入任务队列暂存
          synchronized (workers) {
              if(workers.size() < coreSize) {
                  Worker worker = new Worker(task);
                  System.out.println("新增 worker 执行 task: " + worker + task);
                  workers.add(worker);
                  worker.start();
              }else {
                  // 1) 死等
                  // 2）带超市等待
                  // 3）让调用者放弃任务执行
                  // 4）让调用者抛出异常
                  // 5）让调用者自己执行任务
                  taskQueue.tryPut(rejectPolicy, task);
              }
          }
      }
  
  
      private class Worker extends Thread {
  
          private Runnable task;
  
          public Worker(Runnable task) {
              this.task = task;
          }
  
          @Override
          public void run() {
              // 执行任务
              // 1）当 task 不为空，执行任务
              // 2）当 task 执行完毕，再接着从任务队列获取任务并执行
              while (task != null || (task = taskQueue.poll(timeout, timeUnit)) != null) {
                  try {
                      System.out.println("正在执行： " + task);
                      task.run();
                  }catch (Exception e) {
                      System.out.println("出现异常！");
                  }finally {
                      task = null;
                  }
              }
  
              synchronized (workers) {
                  System.out.println("worker 被移除： " + this);
                  workers.remove(this);
              }
  
          }
  
          @Override
          public int hashCode() {
              return super.hashCode();
          }
  
          @Override
          public boolean equals(Object obj) {
              return super.equals(obj);
          }
  
          @Override
          public String toString() {
              return super.toString();
          }
      }
  
  
      public static void main(String[] args) {
  
          ThreadPool pool = new ThreadPool(1, new DefaultRejectPolicy(), 1);
  
          for (int i = 0; i < 4; i++) {
              int j = i;
  
              pool.execute(() -> {
                  try {
                      Thread.sleep(1000L);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              });
          }
  
      }
  }