單例模式簡介：
單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。這種類型的設計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式。
這種模式涉及到一個單一的類，該類負責創(chuàng)建自己的對象，同時確保只有單個對象被創(chuàng)建。這個類提供了一種訪問其唯一的對象的方式，可以直接訪問，不需要實例化該類的對象。
比如Hibernate的SessionFactory，它充當數(shù)據(jù)存儲源的代理，并負責創(chuàng)建Session對象。SessionFactory并不是輕量級的，一般情況下，一個項目通常只需要一個SessionFactory就夠，這是就會使用到單例模式。
單例模式優(yōu)點:
- 由于其在內(nèi)存中只有一個對象實例，則節(jié)省內(nèi)存空間
- 能避免頻繁地創(chuàng)建和銷毀對象，提高性能
- 避免對共享資源的多重占用，簡化訪問操作，如在進行寫文件時，由于只有一個實例對象，能避免對同一資源的同時寫操作
- 為整個系統(tǒng)提供一個全局訪問點，優(yōu)化和共享資源訪問。
應用場景：
單例模式其核心在于在整個系統(tǒng)中只創(chuàng)建唯一一個實例，其應用場景主要如下：
- 1.創(chuàng)建對象時耗時過多或者耗資源過多，但又經(jīng)常用到的對象。
- 2.需要頻繁實例化然后銷毀的對象。如多線程的線程池、網(wǎng)絡連接池等。
- 3.當對象需要被共享的場合。由于單例模式只允許創(chuàng)建一個對象，共享該對象可以節(jié)省內(nèi)存，并加快對象訪問速度。如 Web 中的配置對象、數(shù)據(jù)庫的連接池等。
- 4.需要頻繁創(chuàng)建的一些類，使用單例可以降低系統(tǒng)的內(nèi)存壓力，減少 GC。
- 5.網(wǎng)站的計數(shù)器（否則難以同步）
- 6.Windows的任務管理器和回收站。
單例設計模式的八種方式:
1、餓漢式（靜態(tài)常量）
應用實例：
- 1.構造器私有化（防止new）
- 2.類的內(nèi)部創(chuàng)建對象
- 3.向外暴露一個靜態(tài)的公共方法：getInstance
- 4.代碼實現(xiàn)
public class SingletonTest01 {
public static void main(String[] args) {
//測試
Singleton instance1 = Singleton.getInstance();
Singleton instance2 = Singleton.getInstance();
System.out.println(instance1=instance1); //true
System.out.println("instance1.hsashCode="+instance1.hashCode());
System.out.println("instance2.hsashCode="+instance2.hashCode());
}
}
//餓漢式顧名思義是饑餓的，因此應該開始就創(chuàng)建對象
class Singleton{
// 1.構造器私有化,外部不能new
private Singleton(){
}
// 2.本類內(nèi)部創(chuàng)建對象實例
private final static Singleton instance=new Singleton();
// 3.提供一個公有的靜態(tài)方法，返回實例對象
public static Singleton getInstance(){
return instance;
}
}
運行結果：
優(yōu)缺點說明:
- 1、優(yōu)點:這種寫法比較簡單，就是在類裝載的時候就完成實例化。避免了線程同步問題。
- 2、缺點:在類裝載的時候就完成實例化，沒有達到Lazy Loading 的效果。如果從始至終從未使用過這個實例，則會造成內(nèi)存的浪費
- 3、這種方式基于classloder機制避免了多線程的同步問題，不過，instance在類裝載時就實例化，在單例模式中大多數(shù)都是調(diào)用getInstance方法，但是導致類裝載的原因有很多種，因此不能確定有其他的方式(或者其他的靜態(tài)方法）導致類裝載，這時候初始化instance就沒有達到lazy loading 的效果
結論:這種單例模式可用，但是可能造成內(nèi)存浪費
2、餓漢式（靜態(tài)代碼塊）
class Singleton01{
// 1.構造器私有化,外部不能new
private Singleton01(){
}
// 2.本類內(nèi)部創(chuàng)建對象實例
private static Singleton01 instance;
static { //在靜態(tài)代碼塊中，創(chuàng)建單例對象
instance=new Singleton01();
}
// 3.提供一個公有的靜態(tài)方法，返回實例對象
public static Singleton01 getInstance(){
return instance;
}
}
優(yōu)缺點說明：和上面一樣這種方式和上面的方式其實類似，只不過將類實例化的過程放在了靜態(tài)代碼塊中，也就是在類裝載的時候，就執(zhí)行靜態(tài)代碼塊中的代碼，初始化類的實例。
3、懶漢式（線程不安全）
public class SingletonTest03 {
public static void main(String[] args) {
//測試
System.out.println("懶漢式，線程不安全~");
Singleton03 instance1 = Singleton03.getInstance();
Singleton03 instance2 = Singleton03.getInstance();
System.out.println(instance1==instance2); //true
System.out.println("instance1.hsashCode="+instance1.hashCode());
System.out.println("instance2.hsashCode="+instance2.hashCode());
}
}
//懶漢式顧名思義就是懶，不會跟餓漢式一樣上來就創(chuàng)建對象，而是在需要的時候才會創(chuàng)建，而且是僅創(chuàng)建一次
class Singleton03{
// 1.構造器私有化,外部不能new
private Singleton03(){
}
// 2.本類內(nèi)部創(chuàng)建對象實例
private static Singleton03 instance;
// 3.提供一個公有的靜態(tài)方法，當使用到該方法時，才會去創(chuàng)建instance
//即懶漢式
public static Singleton03 getInstance(){
if(instance==null){
instance=new Singleton03();
}
return instance;
}
}
運行結果：
優(yōu)缺點說明:
- 1、起到了Lazy Loading的效果，但是只能在單線程下使用。
- 2、如果在多線程下，一個線程進入了if (singleton == mull)判斷語句塊，還未來得及往下執(zhí)行，另一個線程也通過了這個判斷語句，這時便會產(chǎn)生多個實例。所以在多線程環(huán)境下不可使用這種方式
- 3、結論:在實際開發(fā)中，不要使用這種方式.
4、懶漢式（線程安全，同步方法）
class Singleton04{
// 1.構造器私有化,外部不能new
private Singleton04(){
}
// 2.本類內(nèi)部創(chuàng)建對象實例
private static Singleton04 instance;
// 3.提供一個公有的靜態(tài)方法，加入同步處理的代碼，解決線程安全問題
//即懶漢式
public static synchronized Singleton04 getInstance(){
if(instance==null){
instance=new Singleton04();
}
return instance;
}
}
運行結果：
優(yōu)缺點說明:
- 1、解決了線程安全問題
- 2、效率太低了，每個線程在想獲得類的實例時候，執(zhí)行getInstance()方法都要進行同步。而其實這個方法只執(zhí)行一次實例化代碼就夠了，后面的想獲得該類實例，直接return就行了。方法進行同步效率太低
- 3、結論:在實際開發(fā)中，不推薦使用這種方式
5、懶漢式（線程安全，同步代碼塊）
class Singleton05{
// 1.構造器私有化,外部不能new
private Singleton05(){
}
// 2.本類內(nèi)部創(chuàng)建對象實例
private static Singleton05 instance;
// 3.提供一個公有的靜態(tài)方法，加入同步代碼塊
public static Singleton05 getInstance(){
if(instance==null){
synchronized (Singleton05.class){
instance=new Singleton05();
}
}
return instance;
}
}
優(yōu)缺點說明：
- 1、這種方式，本意是想對第四種實現(xiàn)方式的改進，因為前面同步方法效率太低，改為同步產(chǎn)生實例化的的代碼塊
- 2、但是這種同步并不能起到線程同步的作用。跟第3種實現(xiàn)方式遇到的情形一致，假如一個線程進入了if (singleton == nul)判斷語句塊，還未來得及往下執(zhí)行，另一個線程也通過了這個判斷語句，這時便會產(chǎn)生多個實例
結論:在實際開發(fā)中，不能使用這種方式
6、雙重檢查（推薦使用）
//雙重檢查
class Singleton06{
// 1.構造器私有化,外部不能new
private Singleton06(){
}
// 2.本類內(nèi)部創(chuàng)建對象實例
private static volatile Singleton06 instance;
// 3.提供一個公有的靜態(tài)方法，加入雙重檢查代碼,解決線程安全問題，同時解決懶加載問題
public static synchronized Singleton06 getInstance(){
if(instance==null){
synchronized (Singleton06.class){
if(instance==null){
instance=new Singleton06();
}
}
}
return instance;
}
}
運行結果：
優(yōu)缺點說明：
- 1、Double-Check 概念是多線程開發(fā)中常使用到的，如代碼中所示，我們進行了兩次if (singleton==- null)檢查，這樣就可以保證線程安全了。
- 2、這樣，實例化代碼只用執(zhí)行一次，后面再次訪問時，判斷if (singleton ==null)，直接return實例化對象，也避免的反復進行方法同步.
- 3、線程安全;延遲加載;效率較高
- 4、結論:在實際開發(fā)中，推薦使用這種單例設計模式
為什么一定使用volatile?
在java內(nèi)存模型中，volatile 關鍵字作用是：
- 保證不同線程對變量操作的內(nèi)存可見性
- 禁止指令重排序
7、靜態(tài)內(nèi)部類(推薦使用)
//靜態(tài)內(nèi)部類完成，推薦使用
class Singleton07{
// 1.構造器私有化
private Singleton07(){
}
// 2.本類內(nèi)部創(chuàng)建對象實例
private static volatile Singleton07 instance;
//寫一個內(nèi)部靜態(tài)類，該類中有一個靜態(tài)的屬性
private static class SingletonInstance{
private static final Singleton07 INSTANCE=new Singleton07();
}
// 3.提供一個公有的靜態(tài)方法，直接返回SingletonInstance.INSTANCE
public static synchronized Singleton07 getInstance(){
return SingletonInstance.INSTANCE;
}
}
運行結果：
優(yōu)缺點說明:
- 1、這種方式采用了類裝載的機制來保證初始化實例時只有一個線程。
- 2、靜態(tài)內(nèi)部類方式在Singleton類被裝載時并不會立即實例化，而是在需要實例化時，調(diào)用getInstance方法，才會裝載SingletonInstance類，從而完成Singleton的實例化。
- 3、類的靜態(tài)屬性只會在第一次加載類的時候初始化，所以在這里，JVM幫助我們保證了線程的安全性，在類進行初始化時，別的線程是無法進入的。
- 4、優(yōu)點:避免了線程不安全，利用靜態(tài)內(nèi)部類特點實現(xiàn)延遲加載，效率高
8、枚舉（推薦使用）
public class SingletonTest08 {
public static void main(String[] args) {
Singleton08 instance = Singleton08.INSTANCE;
Singleton08 instance2 = Singleton08.INSTANCE;
System.out.println(instance==instance2);
System.out.println(instance.hashCode());
System.out.println(instance2.hashCode());
instance.sayOk();
}
}
//使用枚舉，可以實現(xiàn)單例，推薦
enum Singleton08{
INSTANCE;//屬性
public void sayOk(){
System.out.println("ok~");
}
}
運行結果：
優(yōu)缺點：
- 1、這借助JDK1.5中添加的枚舉來實現(xiàn)單例模式。不僅能避免多線程同步問題，而且還能防止反序列化重新創(chuàng)建新的對象。
- 2、這種方式是Effective Java作者Josh Bloch提倡的
- 3、方式結論:推薦使用
單例模式在JDK應用的源碼分析
在我們JDK中，java.lang.Runtime就是經(jīng)典的單例模式(餓漢式)
從以下源碼可以看出：
單例模式注意事項和細節(jié)說明
- 1、單例模式保證了系統(tǒng)內(nèi)存中該類只存在一個對象，節(jié)省了系統(tǒng)資源，對于一些需要頻繁創(chuàng)建銷毀的對象，使用單例模式可以提高系統(tǒng)性能
- 2、當想實例化一個單例類的時候，必須要記住使用相應的獲取對象的方法，而不是使用new
- 3、建議不要使用反射進行設計單例模式，因為反射可以暴力破壞單例模式
到此這篇關于JAVA設計模式零基礎解析之單例模式的八種方式的文章就介紹到這了,更多相關Java 設計模式內(nèi)容請搜索服務器之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持服務器之家！
原文鏈接：https://blog.csdn.net/weixin_48838340/article/details/120769535
