設計模式介紹
設計模式（Design pattern） 是一套被反覆使用、經過分類編排、代碼設計經驗的總結。設計模式的本質是提高 軟件維護性，通用性和擴展性，並降低軟件開發的複雜度。
設計模式的類型
分爲三種：
創建型模式：對象實例化的模式，創建型模式用於解耦對象的實例化過程。
結構型模式：把類或對象結合在一起形成一個更大的結構。
行爲型模式： 類和對象如何交互，及劃分責任和算法。
單例模式
單例模式的定義就是確保某一個類只有一個實例，並且提供一個全局訪問點。單例模式具備典型的3個特點：1、只有一個實例。 2、自我實例化。 3、提供全局訪問點。 因此當系統中只需要一個實例對象或者系統中只允許一個公共訪問點，除了這個公共訪問點外，不能通過其他訪問點訪問該實例時，可以使用單例模式。
例如：Hibemate的SessionFactory,它充當數據存儲源的代理，並負責創建Session對象。SessionFactory並不是輕量級的，一般情況下，就只需要一個SessionFactory就夠了，這樣就使用了單例模式。
單例模式的八種設計方式
單例模式有八種方式：
餓漢式（靜態常量）
- 應用實例：
- 構造器私有化
- 類的內部創建對象
- 類提供一個獲取靜態實例的公有方法
代碼
public class SingletonTest01 {
public static void main(String[] args) {
//測試
Singleton instance = Singleton.getInstance()；
}
class Singleton{
//構造器私有化，外部不能new
private Singleton(){
}
//本類內部創建對象實例
private final static Singleton instance = new Singleton(;
//提供一個公有的靜態方法，返回實例對象
public static Singleton getInstance() {
return instance;
}
}
優缺點說明:
1)優點:這種寫法比較簡單，就是在類裝載的時候就完成實例化。避免了線程同步問題。
2)缺點:在類裝載的時候就完成實例化，沒有達到LazyLoading的效果。如果從始至終從未使用過這個實例，則
會造成內存的浪費
3)這種方式基於classloder機制避免了多線程的同步問題，不過，instance在類裝載時就實例化，在單例模式中大
多數都是調用getInstance方法，但是導致類裝載的原因有很多種，因此不能確定有其他的方式(或者其他的靜
態方法)導致類裝載，這時候初始化instance就沒有達到lazy loading的效果
4)結論: 這種單例模式可用，可能造成內存浪費
餓漢式（靜態代碼塊）
代碼：
public class SingletonTest01 {
public static void main(String[] args) {
//測試
Singleton instance = Singleton.getInstance()；
}
class Singleton{
//構造器私有化，外部不能new
private Singleton(){
}
//本類內部用代碼塊創建對象實例
private final static Singleton instance；
static{
instance = new Singleton();
}
//提供一個公有的靜態方法，返回實例對象
public static Singleton getInstance() {
return instance;
}
}
優缺點說明:
1)這種方式和上面的方式其實類似，只不過將類實例化的過程放在了靜態代碼塊中，也是在類裝載的時候，就執
行靜態代碼塊中的代碼，初始化類的實例。優缺點和上面是-樣的。
2)結論: 這種單例模式可用，但是可能造成內存浪費
懶漢式（線程不安全）
代碼:
public class SingletonTest01 {
public static void main(String[] args) {
//測試
Singleton instance = Singleton.getInstance()；
}
class Singleton{
//構造器私有化，外部不能new
private Singleton(){
}
//本類內部創建對象
private final static Singleton instance；
//提供一個公有的靜態方法，用到該對象才創建，返回實例對象，即懶漢式
public static Singleton getInstance() {
if(instance==null){
instance = new Singleton();
}
return instance;
}
}
優缺點說明:
- 起到了Lazy Loading的效果，但是只能在單線程下使用。
- 如果在多線程下，- -個線程進入了if (singleton == null)判斷語句塊，還未來得及往下執行，另一個線程也通過
了這個判斷語句，這時便會產生多個實例。所以在多線程環境下不可使用這種方式
3)結論:在實際開發中，不要使用這種方式.
懶漢式（線程安全，同步方法）
代碼：
public class SingletonTest01 {
public static void main(String[] args) {
//測試
Singleton instance = Singleton.getInstance()；
}
class Singleton{
//構造器私有化，外部不能new
private Singleton(){
}
//本類內部創建對象
private final static Singleton instance；
//提供一個公有的靜態方法，加鎖在方法上實現線程同步，返回實例對象，即懶漢式
public static synchronized Singleton getInstance() {
if(instance==null){
instance = new Singleton();
}
return instance;
}
}
優缺點說明:
- 解決了線程安全問題
2)效率太低了， 每個線程在想獲得類的實例時候，執行getlInstance()方法都要進行同步。而其實這個方法只執行
一次實例化代碼就夠了，後面的想獲得該類實例，直接return就行了。方法進行同步效率太低
3)結論:在實際開發中，不推薦使用這種方式
懶漢式（線程安全，同步代碼塊）
代碼：
public class SingletonTest01 {
public static void main(String[] args) {
//測試
Singleton instance = Singleton.getInstance()；
}
class Singleton{
//構造器私有化，外部不能new
private Singleton(){
}
//本類內部創建對象
private final static Singleton instance；
//提供一個公有的靜態方法，加鎖在代碼塊上實現線程同步，返回實例對象，即懶漢式
public static Singleton getInstance() {
if(instance==null){
synchronized(instance.class){
instance = new Singleton();
}
}
return instance;
}
}
優缺點：
在實際開發中，不推薦使用這種方式
雙重檢查
代碼:
public class SingletonTest01 {
public static void main(String[] args) {
//測試
Singleton instance = Singleton.getInstance()；
}
class Singleton{
//構造器私有化，外部不能new
private Singleton(){
}
//本類內部創建對象
private final static Singleton instance；
//提供一一個靜態的公有方法，加入雙重檢查代碼，解決線程安全問題，同時解決懶加載問題
//同時保證了效率,推薦使用
public static synchronized Singleton getInstance() {
if(instance= = null) {
synchronized (Singleton.class) {
if(instance== null) {
instance = new Singleton();
}
}
}
return instance;
}
}
優缺點說明:
- Double-Check 概念是多線程開發中常使用到的，如代碼中所示，我們進行了兩次if (singleton == null)檢查，這
樣就可以保證線程安全了。
2)這樣， 實例化代碼只用執行一次，後面再次訪問時，判斷if (singleton== = null)，直接return實例化對象，也避
免的反覆進行方法同步.
3)線程安全; 延遲加載;效率較高
4)結論: 在實際開發中，推薦使用這種單例設計模式
靜態內部類
代碼：
public class SingletonTest01 {
public static void main(String[] args) {
//測試
Singleton instance = Singleton.getInstance()；
}
class Singleton{
//構造器私有化，外部不能new
private Singleton(){
}
private static volatile Singleton instance;
//寫一個靜態內部類，該類中有一個靜態屬性Singleton
private static class SingletonInstance {
private static final Singleton INSTANCE = new Singleton();
}
//提供-一個靜態的公有方法，直接返回SingletonInstance .INSTANCE
public static synchronized Singleton getInstance( {
return SingletonInstance.INSTANCE;
}
}
優缺點說明:
1)這種方式採用了類裝載的機制來保證初始化實例時只有-一個線程。
2)靜態內部類方式在Singleton類被裝載時並不會立即實例化，而是在需要實例化時，調用getInstance方法，才
會裝載SingletonInstance類，從而完成Singleton的實例化。
3)類的靜態屬性只會在第一次加載類的時候初始化，所以在這裏，JVM幫助我們保證了線程的安全性，在類進行
初始化時，別的線程是無法進入的。
4)優點: 避免了線程不安全，利用靜態內部類特點實現延遲加載，效率高
5) 結論:推薦使用.
枚舉
代碼：
public class SingletonTest08 {
public static void main(String[] args) {
Singleton instance = Singleton.INSTANCE;
instance.sayOK0;
}
/使用枚舉，可以實現單例，推薦
enum Singleton {
INSTANCE; //屬性
public void sayOK( {
System.out.println("ok~");
}
}
優缺點說明:
1)這藉助JDK1.5中添加的枚舉來實現單例模式。不僅能避免多線程同步問題，而且還能防止反序列化重新創建
新的對象。
2) 這種方式是Effective Java作者Josh Bloch 提倡的方式
3)結論: 推薦使用
以上就是博主學習java設計模式的單例模式的一些資料整理，希望可以有所幫助。如果有理解不對的地方，請指正。