單例模式之懶漢的併發問題，只需要新增一個 synchronized 就可以解決了

阿新 • • 發佈：2019-01-09

復現併發問題：

package review.bank;

/**
 * Created by kodulf on 2017/2/26.
 */
public class SingleInstanceLazyMan {

    private SingleInstanceLazyMan(){

    }

    static SingleInstanceLazyMan singleInstanceLazyMan ;

    //synchronized 如果不新增，那麼會出現三個程序一起排程的情況
    public static SingleInstanceLazyMan getInstance(){
        if(singleInstanceLazyMan==null){
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());

            singleInstanceLazyMan = new SingleInstanceLazyMan();

            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());

        }

        return singleInstanceLazyMan;
    }

}

新建三個程序去呼叫這個單例的getInstance方法

    public static  void testSingleInstance(){
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                SingleInstanceLazyMan.getInstance();
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                SingleInstanceLazyMan.getInstance();
            }
        });
        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                SingleInstanceLazyMan.getInstance();
            }
        });

        thread1.start();
        thread2.start();
        thread3.start();
    }

執行結果：會發現都呼叫了if == null的那個判斷了，就是執行了裡面的程式了

before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-0
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-1
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
before new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-1
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2
after new Thread-2

Process finished with exit code 0

要解決這個問題：

只需要新增一個單詞，synchronized 就可以了

package review.bank;

/**
 * Created by zhangyinshan on 2017/2/26.
 */
public class SingleInstanceLazyMan {

    private SingleInstanceLazyMan(){

    }

    static SingleInstanceLazyMan singleInstanceLazyMan ;

    //synchronized 如果不新增，那麼會出現三個程序一起排程的情況
    public static synchronized SingleInstanceLazyMan getInstance(){
        if(singleInstanceLazyMan==null){
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());
            System.out.println("before new "+Thread.currentThread().getName());

            singleInstanceLazyMan = new SingleInstanceLazyMan();

            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());
            System.out.println("after new "+Thread.currentThread().getName());

        }

        return singleInstanceLazyMan;
    }

}

執行結果：只調用了一次，這個就是我們想要的

before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
before new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0
after new Thread-0

Process finished with exit code 0

單例模式之懶漢的併發問題，只需要新增一個 synchronized 就可以解決了

復現併發問題： package review.bank; /** * Created by kodulf on 2017/2/26. */ public class SingleInstanceLazyMan { private SingleInstance

單例模式之懶漢的併發問題

餓漢模式： class Single{ 　　private staitc final Single s= new Single(); 　　private Single(){} 　　public static Single getSingle(){ 　　　　retu

單例模式之懶漢單例（延遲初始化）多執行緒再解析

單例模式之懶漢單例（延遲初始化）多執行緒再解析 1、多執行緒下的懶漢單例： public class Lazysingleton { private static Lazysingleton m_instance = null; // 私有預設構造方法

Java單例模式之懶漢模式及餓漢模式

單例模式單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。這種模式涉及到一個單一的類，該類負責建立自己的物件，同時確保只有單個物件被建立。這個類提供了一種訪問其唯一

單例模式之懶漢模式（延遲載入）

什麼是延遲載入？延遲載入就是在呼叫get()方法時候建立，常見的方法就是在 get()中例項化。看實現程式碼： package test; public class MyObject { private static MyObject myObject; pri

c++、設計模式之單例模式（餓漢，懶漢，執行緒安全）

單例模式：單例模式，是一種常用的軟體設計模式。在它的核心結構中只包含一個被稱為單例的特殊類。通過單例模式可以保證系統中，應用該模式的類一個類只有一個例項。即一個類只有一個物件例項。如何保證一個類只有一個例項並且這個例項易於被訪問呢？定義一個全域性變數可以確保物件隨時都可以被訪

Java面試題之在多線程情況下，單例模式中懶漢和餓漢會有什麽問題呢？

餓漢模式問題之間 static 代碼 clas ava public 餓漢懶漢模式和餓漢模式： public class Demo { //private static Single single = new Single();//餓漢模式

單例模式（懶漢，餓漢）

ati turn 還需 sin 有用只需要對象 clas main Java中的單例模式一般分為懶漢模式和餓漢模式，懶漢模式只有用得到的時候對象才初始化，餓漢模式無論用得到與否，都先初始化。懶漢模式在運行的時候獲取對象比較慢（因為類加載時並沒有創建對象實例），但是加載

設計模式之單例模式 (C++ 懶漢經典實現 & DCL實現 & 餓漢經典實現)

顧名思義：單例模式，指的是僅有一個(類)例項。即：在應用程式的整個生命週期中，任何時刻，某個類(單例類)僅存在唯一一個例項。同時僅提供一個全域性訪問點。單例的實現一般要求滿足： (1) 類建構函式私有 (2) 提供一個全域性訪問點一般是靜態的共有方法一、單

java 單例模式之執行緒安全的餓漢模式和懶漢模式

單例模式解決的問題:保證一個類在記憶體中的物件唯一性. 比如：多程式讀取一個配置檔案時，建議配置檔案封裝成物件。會方便操作其中資料，又要保證多個程式讀到的是同一個配置檔案物件，就需要該配置檔案物件在記憶體中是唯一的。如何保證物件唯一性呢？思想： 1，不讓其他程式建立

Java實現單例模式之餓漢式、懶漢式、列舉式，帶測試。

Java實現單例的3種普遍的模式，餓漢式、懶漢式、列舉式。具體程式碼如下： package com.lcx.mode; /** * * 餓漢式單例，不管以後用不用這個物件，我們一開始就建立這個物件的例項， * 需要的時候就返回已建立好的例項物件，所以比較飢餓，

單例模式之新的想法

dsi 配置 trac 單例對象 ack bool 感覺曾經 Circul 前幾天被問到了單例模式對構造函數有什麽要求嗎？答曰：沒什麽要求吧？回來查了下詳細的資料才發現，原來單例模式的實現private 的一個構造函數，目的是不讓這個單例的類可以new一個對象出來。

單例模式之懶漢式

sta pre code sin -m 安全 rac content file ?? //單例模式之懶漢式 class Singleton{ private static Singleton instance = null; private Single

Java基礎單例模式之懶漢式

懶漢私有珍惜 src pac auth 如果 x64 version 禮悟：好好學習多思考，尊師重道存感恩。葉見尋根三返一，活水清源藏於零。虛懷若谷良心主，皓月當空自在王。願給最苦行無悔，誠勸且行且珍惜。 os ：

多線程單例模式之立即加載(餓漢模式)

run tel ext 相同 turn nbsp 加載一個 nis package com.wz.thread.immediately;/** * 立即加載/餓漢模式單例設計模式 * @author Administrator * */public class MyOb

php單例模式之“三私一公”

外部特點概念失去 spa get ins 應用而且單例模式的概念單例模式是指整個應用中某個類只有一個對象實例的設計模式。具體來說，作為對象的創建方式，單例模式確保某一個類只有一個實例，而且自行實例化並向整個系統全局的提供這個實例。它不會創建實例副本，而是會向單

單例模式之餓漢式

print bsp ati turn 線程安全問題 spa clas pub col class HungryMan { //設計模式之餓漢式，因為是static修飾的，所以是類成員， //在類被加載時就初始化對象了，不存在線程安全問題 stati

單例模式、懶漢模式以及餓漢模式的區別及應用

1.單例模式單例模式就是系統執行期間，有且僅有一個例項。它有三個必須滿足的關鍵點：（1）一個類只有一個例項。這是滿足單例模式最基本的要求，若滿足這個關鍵點，只能提供私有的構造器，即保證不能隨意建立該類的例項。示例如下： //讀取配置檔案的工具類—單例模式 public class Con

設計模式：單例模式（懶漢）

/** * 單例模式。 * @author Bright Lee */ public class LazySingleton { private static volatile LazySingleton instance; private LazySingleton() {

單例模式之二

單例模式分為兩種一種是繼承mono的一種是不繼承mono的不繼承mono的常用於資料的管理不繼承mono: using System.Collections; using System.Collections.Generic; using UnityEngine; namesp

單例模式之懶漢的併發問題，只需要新增一個 synchronized 就可以解決了

相關推薦