单例模式

定义

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

使用场景

1. 当一个类只有一个实例，并且第三方可以从一个公共的访问点访问它时。
2. 当一个唯一一个的实例可以通过子类化来扩展，而且第三方再不需要改代码的情况下就能使用一个扩展实例
3. 当是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。

实现方式

1. 懒汉式（在getInstance方法上加同步）

public static synchronized Singleton getInstance() {  
     if (single == null) {    
         single = new Singleton();  
     }    
     return single;  
 } 

1. 懒汉式（双重检查锁定）

 public static Singleton getInstance() {  
    if (singleton == null) {    
        synchronized (Singleton.class) {    
             if (singleton == null) {    
                  singleton = new Singleton();   
              }    
         }    
     }    
     return singleton;   
 } 

1. 懒汉式（静态内部类）

public class Singleton {    
    private static class LazyHolder {    
        private static final Singleton INSTANCE = new Singleton();    
    }    
    private Singleton (){}    
    public static final Singleton getInstance() {    
        return LazyHolder.INSTANCE;    
    }    
} 

1. 饿汉式

public class Singleton {
    private Singleton() {}
    private static final Singleton single = new Singleton();

    public static Singleton getInstance() {  
        return single;  
    }  
}

扩展与思考

单例模式是在一个JVM中，保持唯一一个实例。可以类似扩展到一个线程中保持唯一一个实例。

public class SingleInThread {
    
    private static ThreadLocal<SingleInThread> threadLocal = new ThreadLocal<>();
    
    private SingleInThread() {}
    
    public static SingleInThread getThreadInstance() {
        SingleInThread instance = threadLocal.get();
        if(instance == null) {
            threadLocal.set(new SingleInThread());
        }       
        return instance;        
    }
    
    /**
     * 注意掌握好时机，清除，避免内存泄漏
     */
    public static void clear() {
        threadLocal.remove();
    }
}

转载于:https://www.cnblogs.com/fzsyw/p/11274896.html