import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class Demo01 {
 
  public static void main(String[] args) {
    ExecutorService pool = Executors.newFixedThreadPool(5);
    for (int i = 0; i < 100; i++) {
      pool.execute(new Runnable() {
        @Override
        public void run() {
          for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " print " + i);
          }
        }
      });
    }
  }
}

while (true) {
  Runnable runnable = taskQueue.take(); // 從任務隊列當中取出任務
  runnable.run(); // 執(zhí)行任務
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
 
public class QueueTest {
 
  public static void main(String[] args) throws InterruptedException {
    ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(5); // 隊列的容量為5
    Thread thread = new Thread(() -> {
      for (int i = 0; i < 10; i++) {
        try {
          queue.put(i);
          System.out.println("數(shù)據(jù) " + i + "被加入到隊列當中");
        } catch (InterruptedException e) {
          System.out.println("出現(xiàn)了中斷異常");
          // 如果出現(xiàn)中斷異常 則退出 線程就不會一直在 put 方法被掛起了
          return;
        }finally {
        }
      }
    });
    thread.start();
    TimeUnit.SECONDS.sleep(1);
    thread.interrupt();
  }
}

import java.util.concurrent.ArrayBlockingQueue;
 
public class Worker implements Runnable {
 
  // 用于保存任務的隊列
  private ArrayBlockingQueue<Runnable> tasks;
  // 線程的狀態(tài) 是否終止
  private volatile boolean isStopped;
 
  // 保存執(zhí)行 run 方法的線程
  private volatile Thread thisThread;
 
  public Worker(ArrayBlockingQueue<Runnable> tasks) {
    // 這個參數(shù)是線程池當中傳入的
    this.tasks = tasks;
  }
 
  @Override
  public void run() {
    thisThread = Thread.currentThread();
    while (!isStopped) {
      try {
        Runnable task = tasks.take();
        task.run();
      } catch (InterruptedException e) {
        // do nothing
      }
    }
  }
    // 注意是其他線程調(diào)用這個方法 同時需要注意是 thisThread 這個線程在執(zhí)行上面的 run 方法
  // 其他線程調(diào)用 thisThread 的 interrupt 方法之后 thisThread 會出現(xiàn)異常 然后就不會一直阻塞了
  // 會判斷 isStopped 是否為 true 如果為 true 的話就可以退出 while 循環(huán)了
  public void stop() {
    isStopped = true;
    thisThread.interrupt(); // 中斷線程 thisThread
  }
 
  public boolean isStopped(){
    return isStopped;
  }
}

import java.util.ArrayList;
import java.util.concurrent.ArrayBlockingQueue;
 
public class MyFixedThreadPool {
  // 用于存儲任務的阻塞隊列
  private ArrayBlockingQueue<Runnable> taskQueue;
 
  // 保存線程池當中所有的線程
  private ArrayList<Worker> threadLists;
 
  // 線程池是否關(guān)閉
  private boolean isShutDown;
 
  // 線程池當中的線程數(shù)目
  private int numThread;
 
  public MyFixedThreadPool(int i) {
    this(Runtime.getRuntime().availableProcessors() + 1, 1024);
  }
 
  public MyFixedThreadPool(int numThread, int maxTaskNumber) {
    this.numThread = numThread;
    taskQueue = new ArrayBlockingQueue<>(maxTaskNumber); // 創(chuàng)建阻塞隊列
    threadLists = new ArrayList<>();
    // 將所有的 worker 都保存下來
    for (int i = 0; i < numThread; i++) {
      Worker worker = new Worker(taskQueue);
      threadLists.add(worker);
    }
    for (int i = 0; i < threadLists.size(); i++) {
      new Thread(threadLists.get(i),
              "ThreadPool-Thread-" + i).start(); // 讓worker開始工作
    }
  }
    
  // 停止所有的 worker 這個只在線程池要關(guān)閉的時候才會調(diào)用
  private void stopAllThread() {
    for (Worker worker : threadLists) {
      worker.stop(); // 調(diào)用 worker 的 stop 方法 讓正在執(zhí)行 worker 當中 run 方法的線程停止執(zhí)行
    }
  }
 
  public void shutDown() {
    // 等待任務隊列當中的任務執(zhí)行完成
    while (taskQueue.size() != 0) {
      // 如果隊列當中還有任務 則讓出 CPU 的使用權(quán)
      Thread.yield();
    }
    // 在所有的任務都被執(zhí)行完成之后 停止所有線程的執(zhí)行
    stopAllThread();
  }
 
  public void submit(Runnable runnable) {
    try {
      taskQueue.put(runnable); // 如果任務隊列滿了， 調(diào)用這個方法的線程會被阻塞
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

public class Test {
 
  public static void main(String[] args) {
    MyFixedThreadPool pool = new MyFixedThreadPool(5, 1024); // 開啟5個線程 任務隊列當中最多只能存1024個任務
    for (int i = 0; i < 1000000; i++) {
      pool.submit(() -> {
        System.out.println(Thread.currentThread().getName()); // 提交的任務就是打印線程自己的名字
      });
    }
    pool.shutDown();
  }
}