單例模式：是一種常用的軟件設計模式，在它的核心結構中值包含一個被稱爲單例的特殊類。一個類只有一個實例，即一個類只有一個對象實例。
對於系統中的某些類來說，只有一個實例很重要，例如，一個系統中可以存在多個打印任務，但是只能有一個正在工作的任務；售票時，一共有100張票，可有有多個窗口同時售票，但需要保證不要超售（這裏的票數餘量就是單例，售票涉及到多線程）。如果不是用機制對窗口對象進行唯一化將彈出多個窗口，如果這些窗口顯示的都是相同的內容，重複創建就會浪費資源。
應用場景（來源：《大話設計模式》）：
需求：在前端創建工具箱窗口，工具箱要麼不出現，出現也只出現一個
遇到問題：每次點擊菜單都會重複創建“工具箱”窗口。
解決方案一：使用if語句，在每次創建對象的時候首先進行判斷是否爲null，如果爲null再創建對象。
需求：如果在5個地方需要實例出工具箱窗體
遇到問題：這個小bug需要改動5個地方，並且代碼重複，代碼利用率低
解決方案二：利用單例模式，保證一個類只有一個實例，並提供一個訪問它的全局訪問點。
通過以下幾種方式，我們會發現，所有的單例模式都是使用靜態方法進行創建的，所以單例對象在內存中靜態共享區中存儲。（可參考：https://zhidao.baidu.com/question/2206072272164938188.html）
單例模式可以分爲懶漢式和餓漢式：
懶漢式單例模式：在類加載時不初始化。
餓漢式單例模式：在類加載時就完成了初始化，所以類加載比較慢，但獲取對象的速度快。
第一種（懶漢，線程不安全）:
public class SingletonDemo1 {
private static SingletonDemo1 instance;
private SingletonDemo1(){}
public static SingletonDemo1 getInstance(){
if (instance == null) {
instance = new SingletonDemo1();
}
return instance;
}
}
這種寫法lazy loading很明顯，但是致命的是在多線程不能正常工作。
第二種（懶漢，線程安全）：
public class SingletonDemo2 {
private static SingletonDemo2 instance;
private SingletonDemo2(){}
public static synchronized SingletonDemo2 getInstance(){
if (instance == null) {
instance = new SingletonDemo2();
}
return instance;
}
}
這種寫法在getInstance()方法中加入了synchronized鎖。能夠在多線程中很好的工作，而且看起來它也具備很好的lazy loading，但是效率很低（因爲鎖），並且大多數情況下不需要同步。
第三種（餓漢）：
public class SingletonDemo3 {
private static SingletonDemo3 instance = new SingletonDemo3();
private SingletonDemo3(){}
public static SingletonDemo3 getInstance(){
return instance;
}
}
這種方式基於classloder機制避免了多線程的同步問題，不過，instance在類裝載時就實例化，這時候初始化instance顯然沒有達到lazy loading的效果。
第四種（餓漢，變種）：
public class SingletonDemo4 {
private static SingletonDemo4 instance = null;
static{
instance = new SingletonDemo4();
}
private SingletonDemo4(){}
public static SingletonDemo4 getInstance(){
return instance;
}
}
表面上看起來差別挺大，其實更第三種方式差不多，都是在類初始化即實例化instance
第五種（靜態內部類）：
public class SingletonDemo5 {
private static class SingletonHolder{
private static final SingletonDemo5 instance = new SingletonDemo5();
}
private SingletonDemo5(){}
public static final SingletonDemo5 getInsatance(){
return SingletonHolder.instance;
}
}
這種方式同樣利用了classloder的機制來保證初始化instance時只有一個線程，它跟第三種和第四種方式不同的是（很細微的差別）：第三種和第四種方式是隻要Singleton類被裝載了，那麼instance就會被實例化（沒有達到lazy loading效果），而這種方式是Singleton類被裝載了，instance不一定被初始化。因爲SingletonHolder類沒有被主動使用，只有顯示通過調用getInstance方法時，纔會顯示裝載SingletonHolder類，從而實例化instance。想象一下，如果實例化instance很消耗資源，我想讓他延遲加載，另外一方面，我不希望在Singleton類加載時就實例化，因爲我不能確保Singleton類還可能在其他的地方被主動使用從而被加載，那麼這個時候實例化instance顯然是不合適的。這個時候，這種方式相比第三和第四種方法就顯得更合理。
第六種（枚舉）：
public enum SingletonDemo6 {
instance;
public void whateverMethod(){
}
}
這種方式是Effective Java作者Josh Bloch 提倡的方式，它不僅能避免多線程同步問題，而且還能防止反序列化重新創建新的對象，可謂是很堅強的壁壘啊，不過，個人認爲由於1.5中才加入enum特性，用這種方式寫不免讓人感覺生疏，在實際工作中，我也很少看見有人這麼寫過。
第七種（雙重校驗鎖）：
public class SingletonDemo7 {
private volatile static SingletonDemo7 singletonDemo7;
private SingletonDemo7(){}
public static SingletonDemo7 getSingletonDemo7(){
if (singletonDemo7 == null) {
synchronized (SingletonDemo7.class) {
if (singletonDemo7 == null) {
singletonDemo7 = new SingletonDemo7();
}
}
}
return singletonDemo7;
}
}
這個是第二種方式的升級版，俗稱雙重檢查鎖定，在JDK1.5之後，雙重檢查鎖定才能夠正常達到單例效果。
多線程測試
餓漢模式又稱爲立即加載模式，含以上就是非常急
也就是在使用類的時候已經將對象創建完畢
package lock;
public class EhanSingleton {
/*餓漢加載模式/立即加載模式*/
//初始化構造函數
private EhanSingleton(){
}
private static EhanSingleton ehan = new EhanSingleton();
public static EhanSingleton getInstance(){
try {
Thread.sleep(3000); //方便多線程測試
} catch (InterruptedException e) {
e.printStackTrace();
}
return ehan ;
}
}
然後我們用簡單的多線程測試
package lock;
public class MyThread extends Thread{
@Override
public void run() {
System.out.println(EhanSingleton.getInstance().hashCode());
}
public static void main(String[] args) {
MyThread m1 = new MyThread();
MyThread m12 = new MyThread();
MyThread m13 = new MyThread();
m1.start();
m12.start();
m13.start();
}
}
126720696
126720696
126720696
算出來的結果每個對象的 hashcode的值是一樣的，說明這個模式是符合單例模式的，這個也就是立即加載型單例設計模式
第二種單例模式 懶漢模式/延遲加載
這個方式是隻有調用某個方法的時候才能調用這個實例
package lock;
public class LanHanSingleton {
/*懶漢模式/延遲加載*/
//私有化構造函數
private LanHanSingleton(){
}
private static LanHanSingleton lanHanSingleton ;
public static LanHanSingleton getInstance() {
if(lanHanSingleton == null){
try {
Thread.sleep(3000);
lanHanSingleton = new LanHanSingleton() ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return lanHanSingleton ;
}
}
我在用多線程去測試一下是否每個對象的HashCode的值是保持一致的
package lock;
public class MyThread extends Thread{
@Override
public void run() {
System.out.println(LanHanSingleton.getInstance().hashCode());
}
public static void main(String[] args) {
MyThread m1 = new MyThread();
MyThread m12 = new MyThread();
MyThread m13 = new MyThread();
m1.start();
m12.start();
m13.start();
}
}
126720696
137014984
1638443495
測試的結果發現 這個已經不符合單例模式，他們並不是同一個對象了，而是幾個不同的對象，所以這種懶漢模式在單線程中是符合單例模式的，不過在多線程環境中是不符合單例模式
想到這裏，大家肯定會想到了synchrinized關鍵字，我們在來看看效果
package lock;
public class LanHanSingleton {
/*懶漢模式/延遲加載*/
//私有化構造函數
private LanHanSingleton(){
}
private static LanHanSingleton lanHanSingleton ;
public synchronized static LanHanSingleton getInstance() {
if(lanHanSingleton == null){
try {
Thread.sleep(3000);
lanHanSingleton = new LanHanSingleton() ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return lanHanSingleton ;
}
}
運行結果：
1638443495
1638443495
1638443495
大家發現這樣的確可以解決多線程帶來的不同對象所導致的問題，但是這個方法並不好，這種方法效率非常低下，一定要等到上一個線程釋放鎖以後才能獲取對象
同步方法是對整個方法持有鎖，這個對於效率來說實在太慢，大家還會想到用同步塊，那麼我們在試一試
package lock;
public class LanHanSingleton {
/*懶漢模式/延遲加載*/
//私有化構造函數
private LanHanSingleton(){
}
private static LanHanSingleton lanHanSingleton ;
public static LanHanSingleton getInstance() {
try {
synchronized (LanHanSingleton.class) {
if(lanHanSingleton == null){
Thread.sleep(3000);
lanHanSingleton = new LanHanSingleton() ;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return lanHanSingleton ;
}
}
其實這個效果和上個效果差不多，效率都是比較慢的，和同步方法synchronized一樣是同步運行的
這裏最好的方式就是DCL雙檢查鎖機制
package lock;
public class LanHanSingleton {
/*懶漢模式/延遲加載*/
//私有化構造函數
private LanHanSingleton(){
}
private static LanHanSingleton lanHanSingleton ;
public static LanHanSingleton getInstance() {
try {
if(lanHanSingleton == null){
synchronized (LanHanSingleton.class) {
if(lanHanSingleton == null){
lanHanSingleton = new LanHanSingleton() ;
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return lanHanSingleton ;
}
}
還有一種的就是內部類的方式
package lock;
import java.io.ObjectStreamException;
import java.io.Serializable;
public class MyObject implements Serializable{
private MyObject(){
}
private static class MyObjectHander{
private static MyObject myObject = new MyObject();
}
public static MyObject getInstance(){
return MyObjectHander.myObject;
}
// public MyObject readResolve() throws ObjectStreamException {
// System.out.println("這個方法被調用了");
// return MyObjectHander.myObject;
// }
}
這個是內部類的方式，不過這個內部的方式還是有存在問題的肯能，這個雖然可以達到多線程單例模式的情況，不過如果遇到序列化的情況下就會違反單例模式的準則。。。。。
註釋的方法就是爲了序列化所提供的
package lock;
import java.io.ObjectStreamException;
import java.io.Serializable;
public class MyObject implements Serializable{
private static final long serialVersionUID = 1L;
private MyObject(){
}
private static class MyObjectHander{
private static final MyObject myObject = new MyObject();
}
public static MyObject getInstance(){
return MyObjectHander.myObject;
}
protected MyObject readResolve() throws ObjectStreamException {
System.out.println("這個方法被調用了");
return MyObjectHander.myObject;
}
}
package lock;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class CheckSingletonHashCode {
public static void main(String[] args) {
try {
MyObject myObject = MyObject.getInstance();
FileOutputStream os = new FileOutputStream(new File("D://lol.txt"));
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(myObject);
oos.close();
os.close();
System.out.println(myObject.hashCode());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
try {
FileInputStream is = new FileInputStream(new File("D://lol.txt"));
ObjectInputStream ois = new ObjectInputStream(is);
MyObject myObject = (MyObject) ois.readObject();
ois.close();
is.close();
System.out.println(myObject.hashCode());
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (ClassNotFoundException | IOException e) {
e.printStackTrace();
}
}
}