不變模式

定義

• 一個對象一旦被創(chuàng)建，則它的內(nèi)部狀態(tài)將永遠(yuǎn)不會發(fā)生改變。

特點

• 因為不變模式的對象他的內(nèi)部狀態(tài)（數(shù)據(jù)）永遠(yuǎn)不會變化，所以其天生就是對多線程友好。
• 沒有一個線程可以修改其內(nèi)部狀態(tài)和數(shù)據(jù)，同時其內(nèi)部狀態(tài)也絕不會自行發(fā)生改變。

基于這些特性，對不變對象的多線程操作不需要進行同步控制。

在多線程中的優(yōu)勢

• 節(jié)省了多線程之間同步數(shù)據(jù)對于系統(tǒng)性能的消耗。
• 依靠對象的不變性，可以確保其在沒有同步操作的多線程環(huán)境中依然始終保持內(nèi)部狀態(tài)的一致性和正確性。

不變模式和只讀屬性

• 不變模式是比只讀屬性具有更強的一致性和不變性。
• 對只讀屬性的對象而言，對象本身不能被其他線程修改，但是對象的自身狀態(tài)卻可能自行修改。

使用場景

• 當(dāng)對象創(chuàng)建后，其內(nèi)部狀態(tài)和數(shù)據(jù)不再發(fā)生任何變化。
• 對象需要被共享，被多線程頻繁訪問。

不變模式的實現(xiàn)

• 去除setter方法以及所有修改自身屬性的方法。
• 將所有屬性設(shè)置為私有，并用final標(biāo)記，確保其不可修改。
• 確保沒有子類可以重載修改它的行為。
• 有一個可以創(chuàng)建完整對象的構(gòu)造函數(shù)。

例子

public final class Product {                            //確保無子類
    private final String no;                            //私有屬性，不會被其他對象獲取
    ic final class Product {                            //確保無子類
    private final String no;                            //私有屬性，不會被其他對象獲取
    private final String name;                          //final保證屬性不會被2次賦值
    private final double price;

    public Product(String no, String name, double price) {    //在創(chuàng)建對象時，必須指定數(shù)據(jù)
        super();                                        //因為創(chuàng)建之后，無法進行修改
        this.no = no;
        this.name = name;
        this.price = price;
    }

    public String getNo() {
        return no;
    }
    public String getName() {
        return name;
    }
    public double getPrice() {
        return price;
    }
}

? 在不變模式的實現(xiàn)中，final關(guān)鍵字起到了重要的作用。對屬性的final定義確保所有數(shù)據(jù)只能在對象被構(gòu)造時賦值1次。之后，就永遠(yuǎn)不再發(fā)生改變。而對class的final確保了類不會有子類。根據(jù)里氏代換原則，子類可以完全的替代父類。如果父類是不變的，那么子類也必須是不變的，但實際上我們并無法約束這點，為了防止子類做出一些意外的行為，這里就干脆把子類都禁用了。

JDK中的不變模式

所有的元數(shù)據(jù)類包裝類，都是使用不變模式實現(xiàn)的。主要的不變模式類型如下：

• java.lang.String
• java.lang.Boolean
• java.lang.Byte
• java.lang.Character
• java.lang.Double
• java.lang.Float
• java.lang.Integer
• java.lang. Long
• java.lang.Short

由于基本數(shù)據(jù)類型和String類型在實際的軟件開發(fā)中應(yīng)用極其廣泛，使用不變模式后，所有實例的方法均不需要進行同步操作，保證了它們在多線程環(huán)境下的性能。

注意：

<font color=red>不變模式通過回避問題而不是解決問題的態(tài)度來處理多線程并發(fā)訪問控制</font>。

不變對象是不需要進行同步操作的。

由于并發(fā)同步會對性能產(chǎn)生不良的影響，因此，在需求允許的情況下，不變模式可以提高系統(tǒng)的并發(fā)性能和并發(fā)量。

生產(chǎn)者-消費者模式

? 生產(chǎn)者-消費者模式是一個經(jīng)典的多線程設(shè)計模式，它為多線程間的協(xié)作提供了良好的解決方案。在生產(chǎn)者-消費者模式中，通常有兩類線程，即若干個生產(chǎn)者線程和若干個消費者線程。生產(chǎn)者線程負(fù)責(zé)提交用戶請求，消費者線程則負(fù)責(zé)具體處理生產(chǎn)者提交的任務(wù)。生產(chǎn)者和消費者之間則通過共享內(nèi)存緩沖區(qū)進行通信。

共享內(nèi)存緩沖區(qū)

? 生產(chǎn)者-消費者模式的核心組件是共享內(nèi)存緩存區(qū)，它作為生產(chǎn)者和消費者間的通信橋梁，避免了生產(chǎn)者和消費者的直接通信，從而將生產(chǎn)者和消費者進行解耦。生產(chǎn)者不需要知道消費者的存在，消費者也不需要知道生產(chǎn)者的存在。
? 同時，由于內(nèi)存緩沖區(qū)的存在，允許生產(chǎn)者和消費者在執(zhí)行速度上存在時間差，無論是生產(chǎn)者在某一局部時間內(nèi)速度高于消費者，還是消費者在局部時間內(nèi)高于生產(chǎn)者，都可以通過共享內(nèi)存緩沖區(qū)得到緩解，確保系統(tǒng)正常運行。

功能

• 生產(chǎn)者-消費者模式中的內(nèi)存緩存區(qū)的主要功能是數(shù)據(jù)在多線程間的共享。

• 通過該緩沖區(qū)，可以緩解生產(chǎn)者和消費者間的性能差。

生產(chǎn)者-消費者角色模式

例子

首先，生產(chǎn)者線程的實現(xiàn)如下，它構(gòu)建PCData對象，并放入BlockingQueue隊列中

public class Producer implements Runnable {
    private volatile boolean isRunning = true;
    private BlockingQueue＜PCData＞ queue;                       //內(nèi)存緩沖區(qū)
    private static AtomicInteger count = new AtomicInteger();    //總數(shù)，原子操作
    private static final int SLEEPTIME = 1000;

    public Producer(BlockingQueue＜PCData＞ queue) {
        this.queue = queue;
    }

    public void run() {
        PCData data = null;
        Random r = new Random();

        System.out.println("start producer id="+Thread.currentThread().getId());
        try {
            while (isRunning) {
                Thread.sleep(r.nextInt(SLEEPTIME));
                data = new PCData(count.incrementAndGet());      //構(gòu)造任務(wù)數(shù)據(jù)
                System.out.println(data+" is put into queue");
                if (!queue.offer(data, 2, TimeUnit.SECONDS)) {   //提交數(shù)據(jù)到緩沖區(qū)中
                    System.err.println("failed to put data：" + data);
                }
            }
        } catch (InterruptedException e) {
                    e.printStackTrace();
            Thread.currentThread().interrupt();
        }
    }
    public void stop() {
        isRunning = false;
    }
}

對應(yīng)的消費者的實現(xiàn)如下。它從BlockingQueue隊列中取出PCData對象，并進行相應(yīng)的計算。

public class Consumer implements Runnable {
    private BlockingQueue＜PCData＞ queue;                     //緩沖區(qū)
    private static final int SLEEPTIME = 1000;

    public Consumer(BlockingQueue＜PCData＞ queue) {
        this.queue = queue;
    }

    public void run() {
        System.out.println("start Consumer id="
                + Thread.currentThread().getId());
        Random r = new Random();                          //隨機等待時間

        try {
            while(true){
                PCData data = queue.take();               //提取任務(wù)
                if (null != data) {
                    int re = data.getData() * data.getData();    //計算平方
                    System.out.println(MessageFormat.format("{0}*{1}={2}",
                            data.getData(), data.getData(), re));
                    Thread.sleep(r.nextInt(SLEEPTIME));
                }
                                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }
    }
}

PCData作為生產(chǎn)者和消費者之間的共享數(shù)據(jù)模型，定義如下：

public final class PCData {                              //任務(wù)相關(guān)的數(shù)據(jù)
    private  final int intData;                            //數(shù)據(jù)
    public PCData(int d){
        intData=d;
    }
    public PCData(String d){
        intData=Integer.valueOf(d);
    }
    public int getData(){
        return intData;
    }
    @Override
    public String toString(){
        return "data:"+intData;
    }
}

在主函數(shù)中，創(chuàng)建三個生產(chǎn)者和三個消費者，并讓它們協(xié)作運行。在主函數(shù)的實現(xiàn)中，定義LinkedBlockingQueue作為BlockingQueue的實現(xiàn)類。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        //建立緩沖區(qū)
        BlockingQueue＜PCData＞ queue = new LinkedBlockingQueue＜PCData＞(10);
        Producer producer1 = new Producer(queue);                  //建立生產(chǎn)者
        Producer producer2 = new Producer(queue);
        Producer producer3 = new Producer(queue);
        Consumer consumer1 = new Consumer(queue);                  //建立消費者
        Consumer consumer2 = new Consumer(queue);
        Consumer consumer3 = new Consumer(queue);
        ExecutorService service = Executors.newCachedThreadPool();     //建立線程池
        service.execute(producer1);                                //運行生產(chǎn)者
        service.execute(producer2);
        service.execute(producer3);
        service.execute(consumer1);                                //運行消費者
        service.execute(consumer2);
        service.execute(consumer3);
        Thread.sleep(10 * 1000);
        producer1.stop();                                          //停止生產(chǎn)者
        producer2.stop();
        producer3.stop();
        Thread.sleep(3000);
        service.shutdown();
    }

注意：

生產(chǎn)者-消費者模式很好地對生產(chǎn)者線程和消費者線程進行解耦，優(yōu)化了系統(tǒng)整體結(jié)構(gòu)。

同時，由于緩沖區(qū)的作用，允許生產(chǎn)者線程和消費者線程存在執(zhí)行上的性能差異，從<font color=red>一定程度</font>上緩解了性能瓶頸對系統(tǒng)性能的影響。