//類加載的時候創(chuàng)建對象，確保只能有一個實例對象
class Singleton {
    private static Singleton instance = new Singleton();
    //私有的構(gòu)造方法
    private Singleton() {}
    //只能通過getInstance（）方法獲取到同一個實例對象
    public static Singleton getInstance() {
        return instance;
    }
}

class Singleton {
    private static Singleton instance = null;
    private Singleton() {}
    public static Singleton getInstance() {
        //第一次使用時，創(chuàng)建實例
        if (instance == null) {
            instance = new Singleton();
        }
        //后面使用時，直接返回第一次創(chuàng)建的實例
        return instance;
    }
}

class Singleton {
    private static Singleton instance = null;
    private Singleton() {}
    //加鎖保證不會有多個線程同時訪問改代碼塊
    public synchronized static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

class Singleton {
    //使用volatile修飾變量
    private static volatile Singleton instance = null;
    private Singleton() {};
    public static Singleton getInstance() {
        if (instance == null) {
            //只給寫操作的相關(guān)代碼加鎖
            synchronized (Singleton.class) {
                //需要雙重if判斷，防止在多線程中加鎖前instance發(fā)生變化
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class BlockingQueue{
    //使用循環(huán)數(shù)組來實現(xiàn)阻塞隊列
    private int[] array;
    //隊列中已經(jīng)存放元素的個數(shù)
    private int size;
    //放入元素的下標(biāo)
    private int putIndex;
    //取元素的下標(biāo)
    private int takeIndex;
    //在構(gòu)造方法中指定隊列的大小
    public BlockingQueue(int capacity){
        array=new int[capacity];
    }
    /*放元素：需要保證線程安全，如果隊列滿了，線程進入等待*/
    public synchronized void put(int m) throws InterruptedException {
        //隊列滿，線程等待
        if(size==array.length){
            //需要注意的是，進行等待的是當(dāng)顯得實例對象，不是類對象
            this.wait();
        }
        //放元素，同時更新下標(biāo)
        array[putIndex]=m;
        putIndex=(putIndex+1)%array.length;
        size++;
        //通知等待的線程
        notifyAll();
    }
    /*取元素：保證線程安全。如果隊列為空，線程等待*/
    public synchronized int take() throws InterruptedException {
        //隊列為空，線程等待
        if(size==0){
            this.wait();
        }
        //取元素，同時更新下標(biāo)
        int ret=array[takeIndex];
        takeIndex=(takeIndex+1)%array.length;
        size--;
        //通知等待的線程
        notifyAll();
        return ret;
    }
}

        //使用ThreadPoolExecutor創(chuàng)建線程池
        ThreadPoolExecutor threadPool1=new ThreadPoolExecutor(
                5,
                10,
                3,
                //自由線程無任務(wù)時最大存活時間單位：分
                TimeUnit.MINUTES,
                //一般不使用無邊界的阻塞隊列，內(nèi)存有限
                new ArrayBlockingQueue<>(100),
                //規(guī)定創(chuàng)建線程的標(biāo)準(zhǔn)
                Executors.defaultThreadFactory(),
                //拒絕策略：一般最多使用CallerRunsPolicy(),或自己實現(xiàn)
                new ThreadPoolExecutor.CallerRunsPolicy()
        );

        //Executors的四種創(chuàng)建線程的方法
        //沒有臨時線程的線程池
        ExecutorService threadPool2= Executors.newFixedThreadPool(10);
        //線程數(shù)目動態(tài)增長的線程池
        ExecutorService threadPool3=Executors.newCachedThreadPool();
        //創(chuàng)建單個線程的線程池
        ExecutorService threadPool4=Executors.newSingleThreadExecutor();
        //計劃線程池
        ExecutorService threadPool5=Executors.newScheduledThreadPool(7);