public class StarvingMode {
    // 是線程安全的
    // 類加載的時(shí)候執(zhí)行
    // JVM 保證了類加載的過程是線程安全的
    private static StarvingMode instance = new StarvingMode();
 
    public static StarvingMode getInstance() {
        return instance;
    }
 
    // 將構(gòu)造方法私有化，防止其他線程new
    private StarvingMode() {}
}

public class LazyModeV1 {
    private static LazyModeV1 instance = null;
 
    public static LazyModeV1 getInstance(){
        // 第一次調(diào)用這個(gè)方法時(shí)，說明我們應(yīng)該實(shí)例化對(duì)象了
        // 原子性
        if (instance == null) {
            instance = new LazyModeV1();    // 只在第一次的時(shí)候執(zhí)行
        }
        return instance;
    }
    // 將構(gòu)造方法私有化，防止其他線程new
    private LazyModeV1(){};
}

public class LazyModeV2 {
    private static LazyModeV2 instance = null;
 
    // 加synchronized鎖，但是這樣性能太低，所以有了mode3
    public synchronized static LazyModeV2 getInstance(){
        // 第一次調(diào)用這個(gè)方法時(shí)，說明我們應(yīng)該實(shí)例化對(duì)象了
        if (instance == null) {
            instance = new LazyModeV2();    // 只在第一次的時(shí)候執(zhí)行
        }
         return instance;
    }
 
    private LazyModeV2(){};
}

class LazyModeV3 {
    // volatile
    private volatile static LazyModeV3 instance = null;
 
    public static LazyModeV3 getInstance(){
        // 1. 第一次調(diào)用這個(gè)方法時(shí)，說明我們應(yīng)該實(shí)例化對(duì)象了
        if (instance == null) {
            // 在第一次instance 沒有初始化的時(shí)候
            // 沒有鎖保護(hù)，有多個(gè)線程可以走到這里 a, b, c, d
 
            // 2. **但是只有第一個(gè)線程a能加鎖，a 加鎖后并且實(shí)例化對(duì)象，
            //    **b, c, d 加鎖進(jìn)去后發(fā)現(xiàn)instance != null, 就不會(huì)再創(chuàng)建了
            synchronized (LazyModeV3.class) {
                // 3. 加鎖之后才能執(zhí)行
                // 第一個(gè)搶到鎖的線程看instance 是 null
                // 其他第一個(gè)搶到鎖的線程看instance 是 null
                // 保證instance 只實(shí)例化一次
                if (instance == null) {
                    instance = new LazyModeV3();    // 只在第一次的時(shí)候執(zhí)行
 
                    // 4. 但是還可能出問題，出現(xiàn)重排序，變成 1 -> 3 -> 2 其他線程掉instance就出現(xiàn)問題，
                    // 所以定義時(shí)就加上volatile，防止重排序;
                }
            }
        }
        return instance;
    }
 
    private LazyModeV3(){};
}

public class Main0 {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue b1 = new LinkedBlockingDeque();
        BlockingQueue<Integer> b2 = new ArrayBlockingQueue<>(3);
        b2.put(1);
        b2.put(2);
        b2.put(3);
        b2.put(4); // 插入第四個(gè)時(shí)就會(huì)阻塞
    }
}

public class MyArrayBlockingQueue {
    private long[] array;
    private int frontIndex;
    private int rearIndex;
    private int size;
 
    public MyArrayBlockingQueue (int capacity){
        array = new long[capacity];
        frontIndex = 0;
        rearIndex = 0;
        size = 0;
    }
 
    public synchronized void put (long val) throws InterruptedException {
        // while 防止假喚醒
        while(size == array.length){
            this.wait();
        }
 
        // 預(yù)期：隊(duì)列一定不是滿的
        array[rearIndex] = val;
        rearIndex++;
        if(rearIndex == array.length){
            rearIndex = 0;
        }
 
        // notify();
        // 在多生產(chǎn)者，多消費(fèi)者時(shí)用notifyAll()
        notifyAll();
    }
 
    public synchronized long take () throws InterruptedException {
        while(size == 0){
            wait();
        }
 
        long val = array[frontIndex];
        frontIndex++;
        if(frontIndex == array.length){
            frontIndex = 0;
        }
 
        // notify();
        // 在多生產(chǎn)者，多消費(fèi)者時(shí)用notifyAll()
        notifyAll();
        return val;
    }
}

public class UserTimer {
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                System.out.println("鬧鐘響了");
            }
        };
        //timer.schedule(task, 5000); // 5秒后執(zhí)行任務(wù)
        timer.schedule(task, 2000, 3000); // 2秒后執(zhí)行任務(wù)，并且之后每三秒執(zhí)行一次
        while (true){} // 主線程死循環(huán)，所以之后的輸出都不是主線程打印的
    }
}

import java.util.concurrent.PriorityBlockingQueue;
 
// 定義一個(gè)工作抽象類
abstract class MyTimerTask implements Comparable<MyTimerTask> {
    long runAt;     // 這個(gè)任務(wù)應(yīng)該在何時(shí)運(yùn)行（記錄為 ms 為單位的時(shí)間戳）
    abstract public void run();
 
    @Override
    public int compareTo(MyTimerTask o) {
        if (runAt < o.runAt) {
            return -1;
        } else if (runAt > o.runAt) {
            return 1;
        } else {
            return 0;
        }
    }
}
 
// 定時(shí)器
public class MyTimer {
    // 這里是普通屬性，不是靜態(tài)屬性
    // 優(yōu)先級(jí)隊(duì)列，要求元素具備比較能力
    private final PriorityBlockingQueue<MyTimerTask> queue = new PriorityBlockingQueue<>();
 
    private final Object newTaskComing = new Object();
 
    public MyTimer() {
        Worker worker = new Worker();
        worker.start();
    }
 
    // 不能使用靜態(tài)內(nèi)部類，否則看不到外部類的屬性
    class Worker extends Thread {
 
        @Override
        public void run() {
            while (true) {
                MyTimerTask task = null;
                try {
                    task = queue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // task 應(yīng)該有個(gè)應(yīng)該執(zhí)行的時(shí)刻（不能記錄 delay）
                long now = System.currentTimeMillis();
                long delay = task.runAt - now;
                if (delay <= 0) {
                    task.run();
                } else {
                    try {
                        // Thread.sleep(delay);    // 5s
 
                        // 應(yīng)該在兩種條件下醒來：
                        // 1. 有新的任務(wù)過來了（任務(wù)可能比當(dāng)前最小的任務(wù)更靠前）
                        // 2. 沒有新任務(wù)來，但到了該執(zhí)行該任務(wù)的時(shí)候了
                        synchronized (newTaskComing) {
                            newTaskComing.wait(delay); // 最多等待delay秒
                        }
 
                        // 如果當(dāng)前時(shí)間已經(jīng)在要執(zhí)行任務(wù)的時(shí)間之后了
                        // 說明任務(wù)的執(zhí)行時(shí)間已過，所以應(yīng)該去執(zhí)行任務(wù)了
                        // 否則，先把這個(gè)任務(wù)放回去（因?yàn)闀r(shí)間還沒到），再去取最小的任務(wù)
                        if (System.currentTimeMillis() >= task.runAt) {
                            task.run();
                        } else {
                            queue.put(task);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
 
    public void schedule(MyTimerTask task, long delay) {
        // 該方法非工作線程（主線程）調(diào)用
        task.runAt = System.currentTimeMillis() + delay;
        queue.put(task);
        synchronized (newTaskComing) {
            newTaskComing.notify();
        }
    }
}

import java.util.Scanner;
import java.util.concurrent.*;
 
public class Demo {
    public static void main(String[] args) {
        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(1);
        ExecutorService service = new ThreadPoolExecutor(
                3, // 正式員工 10
                9, // 臨時(shí)員工 20
                10, TimeUnit.SECONDS,
                queue,  // 阻塞隊(duì)列
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread t = new Thread(r, "飯店廚師");
                        return t;
                    }
                }, // 線程工廠
                new ThreadPoolExecutor.AbortPolicy() // 拒絕策略
        );
 
        // 定義任務(wù)
        Runnable task = new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.DAYS.sleep(365);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
 
        // 把任務(wù)提交給線程池對(duì)象（公司）
        Scanner s = new Scanner(System.in);
        for (int i = 1; i < 100; i++) {
            s.nextLine();
            service.execute(task);
            System.out.println(i);
        }
    }
}

public class Demo2 {
    public static void main(String[] args) {
        // 不太建議在實(shí)際生產(chǎn)項(xiàng)目下使用
        ExecutorService service = Executors.newFixedThreadPool(10);
        ExecutorService service1 = Executors.newSingleThreadExecutor();
        ExecutorService service2 = Executors.newCachedThreadPool();
 
        Runnable task = new Runnable() {
            @Override
            public void run() {
 
            }
        };
        service.execute(task);
    }
}

import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class Demo3 {
    static class CalcFib implements Runnable {
        private final int n;
        CalcFib(int n) {
            this.n = n;
        }
 
        @Override
        public void run() {
            long r = fib(n);
            System.out.printf("fib(%d) = %d\n", n, r);
        }
        private long fib(int n) {
            if (n == 0 || n == 1) {
                return 1;
            }
            return fib(n - 1) + fib(n - 2);
        }
    }
 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ExecutorService service = Executors.newFixedThreadPool(10);
        while (true) {
            System.out.print("提交數(shù)字: ");
            int n = scanner.nextInt();
            Runnable task = new CalcFib(n);
            service.execute(task);
        }
    }
}

import java.util.concurrent.*;
 
// 線程池類
public class MyThreadPoolExecutor implements Executor {
    private int currentCoreSize;      // 當(dāng)前正式員工的數(shù)量
 
    private final int corePoolSize;   // 正式員工的數(shù)量上限
 
    private int currentTemporarySize; // 當(dāng)前臨時(shí)員工的數(shù)量
 
    private final int temporaryPoolSize;      // 臨時(shí)員工的數(shù)量上限
 
    private final ThreadFactory threadFactory;// 創(chuàng)建線程的工廠對(duì)象
 
    // 臨時(shí)工摸魚的時(shí)間上限
    private final long keepAliveTime;
    private final TimeUnit unit;
 
    // 傳遞任務(wù)的阻塞隊(duì)列
    private final BlockingQueue<Runnable> workQueue;
 
    public MyThreadPoolExecutor(int corePoolSize,
                                int maximumPoolSize,
                                long keepAliveTime,
                                TimeUnit unit,
                                BlockingQueue<Runnable> workQueue,
                                ThreadFactory threadFactory,
                                RejectedExecutionHandler handler) {
        this.corePoolSize = corePoolSize;
        this.temporaryPoolSize = maximumPoolSize - corePoolSize;
        this.workQueue = workQueue;
        this.threadFactory = threadFactory;
        this.keepAliveTime = keepAliveTime;
        this.unit = unit;
    }
 
    // 向線程池中提交任務(wù)
    @Override
    public void execute(Runnable command) {
        // 1. 如果正式員工的數(shù)量還低于正式員工的數(shù)量上限，則優(yōu)先創(chuàng)建正式員工處理任務(wù)
        // 1.1 需要管理，當(dāng)前正式員工有多少，正式員工的數(shù)量上限有多少？
        if (currentCoreSize < corePoolSize) {
            // 優(yōu)先創(chuàng)建正式員工進(jìn)行處理
            // 創(chuàng)建一個(gè)線程，這個(gè)線程中的任務(wù)就是不斷地取任務(wù)-做任務(wù)，但是不需要考慮退出的問題
            CoreJob job = new CoreJob(workQueue, command);
//            Thread thread = new Thread(job);    // 不使用工廠創(chuàng)建的線程
            Thread thread = threadFactory.newThread(job);   // thread 代表的就是正式員工
            String name = String.format("正式員工-%d", currentCoreSize);
            thread.setName(name);
 
            thread.start();
 
            // 只是兩種不同的策略，沒有誰是正確的說法
            // 1. 把 command 放到隊(duì)列中；command 的執(zhí)行次序是在隊(duì)列已有的任務(wù)之后
            // 2. 創(chuàng)建正式員工的時(shí)候，就把 command 提交給正式員工，讓 command 優(yōu)先執(zhí)行
            // 我們這里采用第二種方案，主要原因就是 java 官方的就是使用的第二種策略
 
            currentCoreSize++;
            return;
        }
 
        // 走到這里，說明正式員工的數(shù)量 == 正式員工的上限了
        // 2. 優(yōu)先把任務(wù)放入隊(duì)列中，如果放入成功，execute 執(zhí)行結(jié)束，否則還需要繼續(xù)
        // 2.1 需要一個(gè)阻塞隊(duì)列
        // workQueue.put(command); // 帶阻塞的放入，是否滿足這里的需求？
        // 我們這里希望的是立即得到結(jié)果
        boolean success = workQueue.offer(command);
        if (success == true) {
            // 說明放入隊(duì)列成功
            return;
        }
 
        // 隊(duì)列也已經(jīng)放滿了
        // 3. 繼續(xù)判斷，臨時(shí)工的數(shù)量有沒有到上限，如果沒有到達(dá)，創(chuàng)建新的臨時(shí)工來處理
        if (currentTemporarySize < temporaryPoolSize) {
            // 創(chuàng)建臨時(shí)工進(jìn)行處理
            TemporaryJob job = new TemporaryJob(keepAliveTime, unit, workQueue, command);
            //Thread thread = new Thread(job);    // 不使用工廠創(chuàng)建的線程
            Thread thread = threadFactory.newThread(job);   // thread 代表的就是臨時(shí)員工
            String name = String.format("臨時(shí)員工-%d", currentTemporarySize);
            thread.setName(name);
 
            thread.start();
 
            currentTemporarySize++;
            return;
        }
 
        // 4. 執(zhí)行拒絕策略
        // 為了實(shí)現(xiàn)方便，暫時(shí)不考慮其他策略
        throw new RejectedExecutionException();
    }
 
    // 一個(gè)正式員工線程要完成的工作
    class CoreJob implements Runnable {
        // 需要阻塞隊(duì)列
        private final BlockingQueue<Runnable> workQueue;
        private Runnable firstCommand;
 
        CoreJob(BlockingQueue<Runnable> workQueue, Runnable firstCommand) {
            this.workQueue = workQueue;
            this.firstCommand = firstCommand;
        }
 
        @Override
        public void run() {
            try {
                firstCommand.run();     // 優(yōu)先先把剛提交的任務(wù)先做掉了
                firstCommand = null;    // 這里設(shè)置 null 的意思是，不影響 firstCommand 對(duì)象被 GC 時(shí)的回收
 
                while (!Thread.interrupted()) {
                    Runnable command = workQueue.take();
                    command.run();
                }
            } catch (InterruptedException ignored) {}
        }
    }
 
    // 一個(gè)臨時(shí)員工線程要完成的工作
    class TemporaryJob implements Runnable {
        // 需要阻塞隊(duì)列
        private final BlockingQueue<Runnable> workQueue;
        private final long keepAliveTime;
        private final TimeUnit unit;
        private Runnable firstCommand;
 
        TemporaryJob(long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, Runnable firstCommand) {
            this.keepAliveTime = keepAliveTime;
            this.unit = unit;
            this.workQueue = workQueue;
            this.firstCommand = firstCommand;
        }
 
        @Override
        public void run() {
            try {
                firstCommand.run();     // 優(yōu)先先把剛提交的任務(wù)先做掉了
                firstCommand = null;    // 這里設(shè)置 null 的意思是，不影響 firstCommand 對(duì)象被 GC 時(shí)的回收
 
                // 一旦超過一定時(shí)間沒有任務(wù)，臨時(shí)工是需要退出的
                // 1. keepAliveTime + unit 記錄起來
                // 2. 怎么就知道超過多久沒有任務(wù)了？如果一定時(shí)間內(nèi)都無法從隊(duì)列中取出來任務(wù)，則認(rèn)為摸魚時(shí)間夠了
                while (!Thread.interrupted()) {
//                Runnable command = workQueue.take();
                    Runnable command = workQueue.poll(keepAliveTime, unit);
                    if (command == null) {
                        // 說明，沒有取到任務(wù)
                        // 說明超時(shí)時(shí)間已到
                        // 說明該線程已經(jīng) keepAliveTime + unit 時(shí)間沒有工作了
                        // 所以，可以退出了
                        break;
                    }
                    command.run();
                }
            } catch (InterruptedException ignored) {}
        }
    }
}