面试手撕代码-手写线程池（优雅打断版本）

手写线程池（优雅打断版本）

package com.study.handcode;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class 手写简单线程池_优雅打断版本 {
    public static void main(String[] args) throws InterruptedException {
        HandleWriteSimpleThreadPool pool = new HandleWriteSimpleThreadPool(5);
        for (int i = 0; i < 10; i++) {
            final int a = i;
            pool.execute(() -> {
                System.out.println("任务：" + a);
                try {
                    Thread.sleep(1000);
                    System.out.println("任务：" + a + "执行完毕");
                } catch (InterruptedException e) {
//                    e.printStackTrace();
                    Thread.currentThread().interrupt();  // Thread会清除打断标记，重新标记上
                }
            });
        }
        Thread.sleep(1500);
        pool.close();
    }

    public static class HandleWriteSimpleThreadPool{
        private int size;
        private BlockingQueue<Runnable> queue;
        private List<Thread> threads = new ArrayList<>();

        public HandleWriteSimpleThreadPool(int size){
            this.size = size;
            this.queue = new ArrayBlockingQueue<>(size);
            this.start();
        }

        public void execute(Runnable task){
            if (!queue.offer(task))
                reject();
        }

        private void reject() {
            System.out.println("线程池已满");
        }

        // 创建线程，并执行任务
        private void start() {
            for (int i = 0; i < size; i++){
                Thread thread = new Thread(() -> {
                    Thread currentThread = Thread.currentThread();
                    while (true) {   // 判断是否被打断
                        try {
                            if (currentThread.isInterrupted()){
                                System.out.println("被打断，料理后事");
                                break;
                            }
                            Runnable take = queue.take();
                            take.run();
                        } catch (InterruptedException e) {
                            System.out.println("被打断");
                            Thread.currentThread().interrupt(); // 重新标记为被打断状态
                        }
                    }
                });
                threads.add(thread);
                thread.start();

            }
        }

        public void close(){
            threads.forEach(Thread::interrupt);  // 利用interrupt进行打断
        }
     }
}