设计模式-单例模式

模式定义

确保一个类最多只有一个实例，并提供一个全局访问点。

单例模式分为饿汉式和懒汉式。

懒汉式单例模式：在类加载时不初始化。

饿汉式单例模式：在类加载时就完成了初始化，所以类加载比较慢，但获取对象的速度快。

饿汉式-线程安全

 1 /**
 2  * 饿汉式单例模式(线程安全)
 3  */
 4 public class Singleton {
 5     //static单例变量
 6     private static Singleton singleton = new Singleton();
 7 
 8     //私有的构造方法
 9     private Singleton() {
10 
11     }
12 
13     //静态方法为调用者提供单例对象
14     public static Singleton getInstance() {
15         return singleton;
16     }
17 }

懒汉式-线程不安全

 1 /**
 2  * 懒汉式(线程不安全)
 3  */
 4 public class Singleton2 {
 5     private static Singleton2 instance = null;
 6 
 7     private Singleton2() {
 8 
 9     }
10 
11     public static Singleton2 getInstance() {
12         if (instance == null) {
13             instance = new Singleton2();
14         }
15         return instance;
16     }
17 }

 

懒汉式-线程安全

 1 /**
 2  * 懒汉式(线程安全)
 3  */
 4 public class Singleton3 {
 5     private static Singleton3 instance = null;
 6 
 7     private Singleton3() {
 8 
 9     }
10 
11     public static synchronized Singleton3 getInstance() {
12         if (instance == null) {
13             instance = new Singleton3();
14         }
15         return instance;
16     }
17 }

 

双重校验锁-线程安全

 1 /**
 2  * 双重校验锁(线程安全)
 3  */
 4 public class Singleton4 {
 5     private volatile static Singleton4 instance = null;
 6 
 7     private Singleton4() {
 8 
 9     }
10 
11     /**
12      * 当第一次调用getInstance()方法时，instance为空，同步操作，保证多线程实例唯一
13      * 当第一次后调用getInstance()方法时，instance不为空，不进入同步代码块，减少了不必要的同步
14      */
15     public static Singleton4 getInstance() {
16         if (instance == null) {
17             synchronized (Singleton4.class) {
18                 if (instance == null) {
19                     instance = new Singleton4();
20                 }
21             }
22         }
23         return instance;
24     }
25 }

 

静态内部类-线程安全

 1 /**
 2  * 静态内部类(线程安全)
 3  */
 4 public class Singleton5 {
 5     /**
 6      * 静态内部类
 7      */
 8     private static class SingleHolder {
 9         public static Singleton5 instance = new Singleton5();
10     }
11 
12     //第一次调用getInstance方法时，才会去加载SingleHolder类，继而实例化instance
13     public static Singleton5 getInstance() {
14         return SingleHolder.instance;
15     }
16 
17     private Singleton5() {
18 
19     }
20 }

 

静态代码块-线程安全

/**
 * 静态代码块(线程安全)
 */
public class Singleton6 {

    private Singleton6() {
    }

    private static Singleton6 instance = null;

    // 静态代码块
    static {
        instance = new Singleton6();
    }

    public static Singleton6 getInstance() {
        return instance;
    }
}

 

枚举-线程安全

1 /**
2  * 枚举(线程安全)
3  */
4 public enum Singleton7 {
5     //枚举实例的创建是线程安全的，任何情况下都是单例（包括反序列化）
6     INSTANCE;
7 }

 

java.lang.Runtime中的单例模式（饿汉式-线程安全）

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }

    private Runtime() {
    }
}