一、單例模式

單例模式是一種設計模式，針對一些特定的場景，研究出對應的解決方案，，有些物件在代碼中只應該有一個實體，單例模式就是強制某個類只能有一個實體，

單例模式的實作，主要依托于static關鍵字（被static 修飾的成員，靜態成員，把當前的成員變成類屬性而不是實體屬性~）每個類物件只有一份

單例模式實作有兩種，餓漢模式和懶漢模式

餓漢模式

餓漢模式實作：實體創建出現在“類加載”階段（第一次使用到這個類的時候，就會把這個類.class加載到記憶體里），執行緒安全

public class TestSinger {
    //實作單例模式
    static class Singleton{
        //創建一個成員，保存唯一的一個Singleton實體
        private static Singleton instance=new Singleton();
        //提供方法獲取實體
        public static Singleton getInstance(){
            return instance;
        }
        private Singleton(){

        }
    }
    public static void main(String[] args) {
        //獲取到一個實體 ，只能通過 getInstance 無法通過new 的方式來創建新的Singleton
        Singleton s=Singleton.getInstance();
    }
}

懶漢模式

第一次呼叫getInstance 方法創建實體 （執行緒不安全）

public class TestSingleton {
    //懶漢模式
    //創建實體的時機是第一次呼叫時創建，比餓漢模式更遲
    static class Singleton{
        private static Singleton instance=null;

        public static Singleton getInstance(){
            if(instance==null){
                instance=new Singleton();
            }
            return instance;
        }

        private Singleton(){

        }
    }

    public static void main(String[] args) {
        Singleton s=new Singleton();
    }
}

一般來說懶漢模式更好（但不絕對），懶漢模式更高效，但是餓漢模式是執行緒安全的，懶漢模式是存在執行緒不安全的狀況，因為懶漢模式有創建執行緒實體操作，此操作不是原子性，

  public static Singleton getInstance(){
            if(instance==null){
                instance=new Singleton();
            }
            return instance;
        }

懶漢模式這里操作先進行讀操作（LOAD）,之后進行比較CMP 之后NEW SAVE（寫入記憶體），如果這里有兩個執行緒執行，會發生搶占式,因為這里操作不是原子性的，所有會發生創建多個實體的情況，出現了BUG，

這里我們通過加鎖操作來使得操作變為原子性，使得懶漢模式變為執行緒安全的，可以把鎖加到方法上，這時候是針對CMP,NEW 和 SAVE 操作都進行了加鎖，三個操作都是串行的，但是這種效率太低了，我們應該把鎖作用范圍更小一點，針對CMP（判斷）和NEW 操作進行加鎖，SAVE 只是讀操作，并沒有修改，不需要加鎖，提高效率，

public static Singleton getInstance(){
       synchronized (Singleton.class){
           if(instance==null){
                instance=new Singleton();
             }
        }
     return instance;
	}

但是這樣的代碼，符出的代價太大了，因為每次呼叫都會進行加鎖，我們只是需要instance未初始化之前，才涉及到執行緒安全問題，后續已經初始化了，就每次要每次都執行加鎖，而是只是進行判斷就好了，所以又修改了代碼，改為雙if判斷

public static Singleton getInstance(){
           if(instance==null){
               synchronized (Singleton.class){
                   if(instance==null){
                       instance=new Singleton();
                   }
               }
           }
            return instance;
        }

但是這樣寫還是會有瑕疵，因為在多執行緒的情況下，可能多個執行緒進行讀操作，由于編譯器優化，可能在暫存器讀取，而這時候執行操作還沒有執行完，還是null的狀態，所以我們也要在獲取實體時候加上鎖

懶漢模式
保證執行緒安全：
1.加鎖，把if判斷和new操作加鎖
2.雙重if回圈
3.volatile 關鍵字

    //懶漢模式
    static class Singleton{
        volatile  private static Singleton instance=null;

        public static Singleton getInstance(){
           if(instance==null){
               synchronized (Singleton.class){
                   if(instance==null){
                       instance=new Singleton();
                   }
               }
           }
            return instance;
        }

        private Singleton(){

        }
    }

    public static void main(String[] args) {
        Singleton s=new Singleton();
    }

針對單例模式的執行緒安全要點：

1）加鎖（在合適的位置加鎖，CMP（判斷）和NEW（創建）時加鎖，同時加鎖的范圍也不能太大，避免降低效率）
2）雙重 判斷（保證需要加鎖時候才加鎖，一旦初始化完畢了，就不用創建實體，都為讀操作，就沒必要加鎖了）
3）volatile 保證外層 if 讀操作，讀到的數值都是最新的，不會出現一個正在創建實體，而讀取時是NULL 進入IF判斷的情況

二、堵塞佇列

堵塞佇列是什么？ 一種執行緒安全的佇列，

1.首先堵塞佇列是執行緒安全的（內部實作了加鎖控制），
2.當佇列滿的時候，此時就會堵塞，一直到堵塞佇列不滿的情況下才會完成插入，當佇列為空時，從佇列中取元素時，也會發生堵塞，

堵塞佇列的作用：
幫助我們完成“生產者消費者模型”，作用于服務器開發
生產者和消費者模型通過某種交易場所（某資料結構）來進行互動 ，堵塞佇列就是其中的一種資料結構，能夠很好的協調生產者和消費者之間的關系，
實際案例（服務器請求）：
一個服務器，同一時刻可能收到很多請求，但是服務器處理能力是有限的，如果同一時間服務器收到的請求太多了，服務器可能就掛了…，針對這樣的場景，使用生產者和消費者模式來進行“削峰”，削弱請求峰值對服務器的沖擊力，如果服務器面對請求太多了，實際上先把請求放入堵塞佇列中，應用程式按照固定的結構從堵塞佇列中取出，這些請求沖擊的是堵塞佇列本身，請求在這里耗著，不會消耗太多的CPU資源，緩解服務器壓力

訊息佇列，是堵塞佇列的上級
1.訊息佇列中資料是有型別的（topic），按照topic進行分類，把相同topic的資料放到不同的隊伍中，分別進行排隊，一個訊息佇列，可以支撐多個業務的多組資料~~
2.訊息佇列往往是單獨的服務器/服務器集群，通過網路通信的方式，進行生產者和消費者模型
3.還支持持久化存盤（資料存盤在磁盤上）
4.消費的時候支持多種消費模式
a)指定位置消費（不一定只是取出隊首元素）
b)鏡像模式消費（一個資料可以被取多次，不是取一次直接洗掉）

實作堵塞佇列：

public static void main(String[] args) {
        //BlockingDeque 本身是一個interface 不能去new
        BlockingDeque<String> blockingDeque=new LinkedBlockingDeque<>();
        try {
            //put 和 take 都有堵塞功能
            //堵塞佇列也有普通方法但是沒有堵塞功能，
            blockingDeque.put("hello");
            String elem=blockingDeque.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

實作一個生產者和消費者模型

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

public class Demo2 {
    //實作生產者和消費者模型
    public static void main(String[] args) {
        BlockingDeque<String> queue=new LinkedBlockingDeque();

        //創建生產者執行緒
        Thread producer=new Thread(){
            @Override
            public void run() {
                for(int i=0;i<10000;i++){
                    try {
                        System.out.println("producer 生成 str"+i);
                        queue.put("str "+i);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        producer.start();

        //消費者執行緒
        Thread customer=new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        String elem=queue.take();
                        System.out.println("customer 獲取到" + elem);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        customer.start();

        try {
            producer.join();
            customer.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

這里實作的是生產者每一秒生成一個，生產者比消費者慢

可以借助堵塞佇列的最大長度來設定一個生產者比消費者快的情況，將最大長度設為10，使用sleep 一秒消費一個，但是一直在生產，這樣就是生產者大于消費者，主要使用put（）和take（）方法來操作堵塞佇列

實作BlockingQueue

1）首先要實作一個佇列，可以用鏈表或者陣列實作佇列，這里使用陣列實作一個佇列（環形佇列），定義兩個變數head,tail來標記陣列頭部和尾部，插入元素時，插在tail位置，tail++,出佇列時取出head位置元素，head++，定義一個變數來標記長度，如果長度等于陣列長度，則要回到陣列的頭部，來實作環形陣列

public class ThreadDemo1 {
    //自己實作堵塞佇列，先通過陣列實作普通佇列
    static class BlockingQueue{

        private int[] array=new int[1000];

        private int head=0;//記錄頭部

        private int tail=0;//記錄尾部

        private int size=0;

        //實作入佇列
        public void put(int value){
            if(size==array.length){
                System.out.println("佇列滿了，不能插入");
                return ;
            }
            array[tail]=value;
            tail++;
            //解決環形陣列
            if(tail>=array.length){
                tail=0;
            }
            size++;
        }
        //實作出佇列
        public Integer take(){
            if(size==0){
                return null;
            }
            int ret=array[head];
            head++;
            if(head>=array.length){
                head=0;
            }
            size--;
            return ret;
        }
    }
}

2.為了保證執行緒安全給佇列進行加鎖操作，并且實作堵塞佇列
注意實作堵塞佇列，此時佇列是滿的，多個執行緒實作都是要等待，當一個執行緒取走一個元素，就會通知其他執行緒佇列不滿，多個執行緒就要競爭鎖，所以獲取到鎖操作后，還是要判斷佇列是否滿，可能這個執行緒沒有競爭到鎖，所以要用while()來進行等待

static class BlockingQueue{

        private int[] array=new int[1000];

        private int head=0;//記錄頭部

        private int tail=0;//記錄尾部
        //記錄佇列中元素長度
        private int size=0;
        //引入一個鎖物件
        private Object locker=new Object();

        //實作入佇列
        public void put(int value) throws InterruptedException {
            synchronized (locker){
                while(size==array.length){
                    locker.wait();
                }
                array[tail]=value;
                tail++;
                //解決環形陣列
                if(tail>=array.length){
                    tail=0;
                }
                size++;
                locker.notifyAll();
            }
        }
        //實作出佇列
        public Integer take() throws InterruptedException {
            int ret=0;
            synchronized (locker){
                while (size==0){
                    locker.wait();
                }
                ret=array[head];
                head++;
                if(head>=array.length){
                    head=0;
                }
                size--;
                locker.notifyAll();//喚醒操作，提醒等待元素，佇列有位置了
            }
            return ret;
        }
    }

創建一個生產者消費者模型來檢驗自己實作的堵塞佇列是否成功

public static void main(String[] args) throws InterruptedException {
        BlockingQueue queue=new BlockingQueue();

        Thread producer=new Thread(){
            @Override
            public void run() {
                for(int i=0;i<10000;i++){
                    try {
                        System.out.println("生產了元素："+ i);
                        queue.put(i);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        producer.start();

        Thread customer=new Thread(){
            @Override
            public void run() {
                try {
                    while(true){
                        int ret=queue.take();
                        System.out.println("消費了元素 "+ ret);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        customer.start();

        producer.join();
        customer.join();
    }

實作了一個簡單的堵塞佇列

三、定時器

定時器就是鬧鐘，給定時器設定一個任務，約定某個任務XXX時間后執行
目的：讓某個任務在某個時間點執行，不是立刻執行
使用Timer 提供的核心介面 schedule 指定一個任務交給定時器，再一定的時間之后執行這個任務

實作定時器
1）Timer 類中要包含一個Task類，每個Task類就表示一個具體的任務，Task里面包含一個時間戳（啥時候執行這個任務），還包含了一個Runnable 實體（用來表示具體任務是啥）
2）Timer里面通過一個帶優先級的堵塞佇列，來組織若干個task，根據時間先后來排優先級，快帶時間的任務優先級更高
3）Timer 中還需要一個專門的執行緒，讓這個執行緒不停掃描隊首元素，看看隊首元素是不是可以執行了，如果可以執行了，就執行這個任務，如果不能執行，就繼續在佇列中等待，

實作定時器:

import java.util.concurrent.PriorityBlockingQueue;

public class ThreadDemo2 {
    //實作一個簡單的定時器  task要放到一個優先佇列中，但是優先佇列中需要進行比較排序
    static class Task implements Comparable<Task>{
        //啥時候去執行
        private long time;
        //執行什么
        private Runnable command;

        //一般去設定定時器的時候，傳入的時間，一般都是時間間隔
        public Task(Runnable command,long time){
            this.command=command;
            //記錄絕對時間
            this.time=System.currentTimeMillis()+time;
        }
        public void run(){
            command.run();
        }
        @Override
        public int compareTo(Task o) {
        //時間較小的排在前面
            return (int)(this.time-o.time);
        }
    }
    static class Timer{
        //創建一個帶優先級的堵塞佇列
       private PriorityBlockingQueue<Task> queue=new PriorityBlockingQueue<>();

       //使用這個物件來實作執行緒之間的協調任務
        private Object mailBox=new Object();
        //schedule 方法的功能就是把一個Task 放到Timer中
        public void schedule(Runnable command,long after){
            Task task=new Task(command,after);
            queue.put(task);
            //當worker 執行緒中包含wait 機制的時候，在安排任務的時候就需要顯式的喚醒一下了
            synchronized (mailBox){
                mailBox.notify();

            }
        }
        public Timer(){
            //創建一個執行緒，讓這個執行緒去掃描佇列的隊首元素
            Thread worker=new Thread(){
                @Override
                public void run() {
                    while (true){
                        //取出隊首元素，判定一下這個元素能不能執行
                        try {
                            Task task=queue.take();
                            long currentTime=System.currentTimeMillis();
                            if(currentTime>=task.time){
                                //時間到了執行任務
                                task.run();
                            }else{
                                //時間沒到，繼續等待
                                queue.put(task);
                                synchronized (mailBox){
                                    mailBox.wait(task.time-currentTime);
                                }
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            worker.start();
        }
    }
}