答:会出现线程安全问题。
首先,在Java中创建单例实例的方式有:饿汉式、懒汉式、静态内部类、枚举等方式;
饿汉模式是天生线程安全的,饿汉模式在类创建的同时,就创建好了一个静态对象,又因为静态变量只会在类创建时执行一次,所以创建好的实例不会再改变,因此是线程安全的。
懒汉式不是线程安全的,当多并发情形下,可能会多个线程都创建实例,不能保证单例模式,可以改成双重校验锁,既保证了调用效率,又保证了线程安全。
静态内部类的方式相比于懒汉模式的优势是可以延迟加载,因为只有在静态内部类被调用时,JVM才会加载它,同时保证了线程安全和调用效率。
以上三种的创建方式都不能解决,反射、反序列化产生的线程安全问题;
使用枚举天然的防止反射和反序列化,既保证了线程安全,又保证了调用效率,但是不能延时加载;
单例模式是 Java 中常用的设计模式之一,属于设计模式三大类中的创建型模式。在运行期间,保证某个类仅有一个实例,并提供一个访问它的全局访问点。单例模式所属类的构造方法是私有的,所以单例类是不能被继承的。实现线程安全的单例模式有以下几种方式有:饿汉式、懒汉式、懒汉式改良版(双重同步锁),内部静态类、枚举;
天生是线程安全的 !(但是无法应对反射、序列化的形式)
饿汉式在类创建的同时,就已经创建好了一个静态的对象供系统使用,以后不在改变;
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() { // 私有的构造方法
}
public static Singleton getInstance() {
return instance;
}
}
这是实现一个安全的单例模式的最简单粗暴的写法,所以称之为饿汉式;
因为肚子饿了,想要马上吃到东西,不想等待生产时间。在类被加载的时候就把 Singleton 实例给创建出来,以后不在改变。
饿汉式的优点和缺点:
public class Singleton {
private static Singleton instance=null;
private Singleton() {};
public static Singleton getInstance(){
if(instance==null){
//可能会有多个线程进入代码块,造成实例化多个对象
instance=new Singleton();
}
return instance;
}
}
public class Singleton {
private static Singleton instance=null;
private Singleton() {};
public static synchronized Singleton getInstance(){
if(instance==null){
instance=new Singleton();
}
return instance;
}
}
但是这种方式并不推荐,因为效率想对较低,每个线程在执行 getInstance 的时候都要进行同步。而如果 instance 已经实例化了可以直接返回,还需要进行改造;
public class Singleton {
private static Singleton instance=null;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
}
这种方式是线程不安全的,假如 A,B 两个线程同时进入到了 if(instance == null)
的代码块, A 线程拿到了锁进入 synchronized
代码块,对 instance 进行实例化,结束并释放锁,B 线程便拿到锁,依然会进入到 synchronized
代码块对 instance 进行实例化。那么这就对 instance 进行了两次实例化。出现了线程安全的问题。
这种代码书写方式也称为 双重同步锁
public class Singleton {
private static volatile Singleton instance=null;
private Singleton(){}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
//在(3.3)的基础上多了一次判断,避免了线程安全问题
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
使用了double-check
即check-加锁-check,减少了同步的开销;
在创建第一个对象时候,可能会有线程1,线程2两个线程进入getInstance()方法,这时对象还未被创建,所以都通过第一层check。接下来的synchronized锁只有一个线程可以进入,假设线程1进入,线程2等待。线程1进入后,由于对象还未被创建,所以通过第二层check并创建好对象,由于对象singleton是被volatile修饰的,所以在对singleton修改后会立即将singleton的值从其工作内存刷回到主内存以保证其它线程的可见性。线程1结束后线程2进入synchronized代码块,由于线程1已经创建好对象并将对象值刷回到主内存,所以这时线程2看到的singleton对象不再为空,因此通过第二层check,最后获取到对象。这里volatile的作用是保证可见性,同时也禁止指令重排序,因为上述代码中存在控制依赖,多线程中对控制依赖进行指令重排序会导致线程不安全。
优点:线程安全,可以延时加载,调用效率比锁加在方法上高。
另外,需要注意 instance采用 volatile 关键字修饰也是很有必要。
但是由于 JVM 具有指令重排的特性,执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出现问题,但是在多线程环境下会导致一个线程获得还没有初始化的实例。
使用 volatile 可以禁止 JVM 的指令重排,保证在多线程环境下也能正常运行。
相比于饿汉式,懒汉式显得没那么 “饿”,在真正需要的时候在去创建实例。
懒汉式的优点和缺点:
public class Singleton {
private Singleton() {
}
public static Singleton getInstance() {
return SingletonFactory.instance;
}
private static class SingletonFactory {
private static Singleton instance = new Singleton();
}
}
静态内部类只有被主动调用的时候,JVM才会去加载这个静态内部类。外部类初次加载,会初始化静态变量、静态代码块、静态方法,但不会加载内部类和静态内部类。
优点:线程安全,调用效率高,可以延时加载。
似乎静态内部类看起来已经是最完美的方法了,其实不是,可以还存在反射攻击和反序列化攻击。
public class Singleton {
private Singleton() {
}
public static Singleton getInstance() {
return SingletonFactory.instance;
}
private static class SingletonFactory {
private static Singleton instance = new Singleton();
}
public static void main(String[] args) throws Exception {
Singleton singleton = Singleton.getInstance();
Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
Singleton newSingleton = constructor.newInstance();
System.out.println(singleton == newSingleton);
}
}
运行结果:false
通过结果看,这两个实例不是同一个,违背了单例模式的原则;
<dependency>
<groupId>org.apache.commonsgroupId>
<artifactId>commons-lang3artifactId>
<version>3.8.1version>
dependency>
这个依赖提供了序列化和反序列化工具类。
Singleton 类实现了 java.io.Serializable
接口。
public class Singleton implements Serializable {
private static class SingletonHolder {
private static Singleton instance = new Singleton();
}
private Singleton() {
}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
public static void main(String[] args) {
Singleton instance = Singleton.getInstance();
byte[] serialize = SerializationUtils.serialize(instance); // 序列化为一个数组
Singleton newInstance = SerializationUtils.deserialize(serialize); // 通过刚才序列化的数组,进行反序列化
System.out.println(instance == newInstance);
}
}
输出结果:false
,表示不是一个实例;
如果要解决 Singleton 类的实力在序列化和反序列化过程中仍然是唯一的,需要添加一个readResolve()
方法到 Singleton 类中,以便在反序列化是返回相同的实例。如:
private Object readResolve() throws ObjectStreamException {
return getInstance();
}
在 Java 中,readResolve()
方法是一个特殊的方法,用于在对象反序列化过程中控制返回的实例。它主要用于解决单例模式在反序列化时可能出现的问题。
最佳的单例实现模式就是枚举模式。写法简单,线程安全,调用效率高,可以天然的防止反射和反序列化调用,不能延时加载。
public enum Singleton {
INSTANCE;
public void doSomething() {
System.out.println("doSomething");
}
}
调用方法:
public class Main {
public static void main(String[] args) {
Singleton.INSTANCE.doSomething();
}
}
直接通过Singleton.INSTANCE.doSomething()的方式调用即可。
枚举如何实现线程安全?反编译后可以发现,会通过一个类去继承该枚举,然后通过静态代码块的方式在类加载时实例化对象,与饿汉类似。https://blog.csdn.net/wufaliang003/article/details/81395411
如何做到防止反序列化调用?每一个枚举类型及其定义的枚举变量在JVM中都是唯一的,Java做了特殊的规定,枚举类型序列化和反序列化出来的是同一个对象。
除此之外,枚举还可以防止反射调用。
综上,线程安全的几种单例模式比较来看:
枚举(无锁,调用效率高,可以防止反射和反序列化调用,不能延时加载)> 静态内部类(无锁,调用效率高,可以延时加载)> 双重同步锁(有锁,调用效率高于懒汉式,可以延时加载)> 懒汉式(有锁,调用效率不高,可以延时加载)~= 饿汉式(无锁,调用效率高,不能延时加载)
注:只有枚举类型能防止反射和反序列化;