Java中实现线程安全的单例模式、方式

• 饿汉模式（线程安全）

public class Single2 {
 
    private static Single2 instance = new Single2();
    
    private Single2(){
        System.out.println("Single2: " + System.nanoTime());
    }
    
    public static Single2 getInstance(){
        return instance;
    }
}

• 懒汉模式 （如果方法没有synchronized，则线程不安全）

public class Single3 {
 
    private static Single3 instance = null;
    
    private Single3(){
        System.out.println("Single3: " + System.nanoTime());
    }
    
    public static synchronized Single3 getInstance(){
        if(instance == null){
            instance = new Single3();
        }
        return instance;
    }
}

• 懒汉模式改良版（线程安全，使用了double-check，即check-加锁-check，目的是为了减少同步的开销）

public class Single4 {
 
    private volatile static Single4 instance = null;
    
    private Single4(){
        System.out.println("Single4: " + System.nanoTime());
    }
    
    public static Single4 getInstance(){
        if(instance == null){
            synchronized (Single4.class) {
                if(instance == null){
                    instance = new Single4();
                }
            }
        }
        return instance;
    }
}

• 利用私有的内部工厂类（线程安全，内部类也可以换成内部接口，不过工厂类变量的作用域要改为public了。）

 
public class Singleton {
    
    private Singleton(){
        System.out.println("Singleton: " + System.nanoTime());
    }
    
    public static Singleton getInstance(){
        return SingletonFactory.singletonInstance;
    }
    
    private static class SingletonFactory{
        private static Singleton singletonInstance = new Singleton();
    }
}

转载于：https://blog.csdn.net/weixin_33795743/article/details/92645612

 

线程安全实现的单例的方式：

1、枚举

2、静态内部类

3、双检锁模式

4、饿汉模式

优缺点：

1、饿汉模式（线程安全、调用效率高，但是不能延时加载）

2、枚举（线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用；这种方式不仅能解决多线程同步问题，而且能防止反序列化重新创建新的对象，不过由于jdk1.5中才加入enum特性，所以不常用）

3、双检锁模式（优点：线程安全，且确保了只有第一次调用单例时才会做同步，避免了每次都同步的性能损耗；
缺点：双重锁降低了程序响应速度和性能）

4、静态内部类（优点：利用了classloader机制来保证初始化instance时只有一个线程，线程安全且没有性能损耗）