Java 单例模式原理_Java单例模式8种方式 详解

Singleton

所谓单例，指的就是单实例，有且仅有一个类实例。

运用场景很多，例如网站的在线人数，window系统的任务管理器，网站计数器等等，这些都是单例模式的运用。单例模式有常见的8种形式，如下：

1.Lazy1【不可用】

public class Singleton_Lazy1 {

private Singleton_Lazy1() {

};

private static Singleton_Lazy1 instance = null;

public static Singleton_Lazy1 getInstance() {

if (instance == null) { instance = new Singleton_Lazy1();

}

return instance;

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

懒汉式1：

线程不稳定

延迟初始化

多线程不安全

是最基本的实现方式，不支持多线程，因为没有synchronized加锁，多线程不能工作。

实现图

多线程则会出现，当Singleton_Lazy1类刚刚被初始化，instance对象还是空，这时候两个线程同时访问到getInstance方法，因为Instance是空，所以A\B两个线程都通过了instance为空的判断，则A\B两个线程都会实例化对象，单例失败。

不加同步的懒汉式是线程不安全的，如下示例：

2.Lazy2(同步方法)【不建议使用】

public class Singleton_Lazy2 {

private Singleton_Lazy2() {

};

private static Singleton_Lazy2 instance = null;

public static synchronized Singleton_Lazy2 getInstance() {

if (instance == null) { instance = new Singleton_Lazy2();

}

return instance;

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

懒汉式2：

线程稳定

延迟初始化

多线程安全

优点：调用才初始化，避免内存浪费。

缺点：必须加锁synchronized才能保证单例，但每次调用都要加锁会影响效率。

实现图

利用synchronized关键字对getInstance方法加锁使得多线程安全且稳定但效率不高。

多线程实现方法，如下图所示：

3.DCL1(同步代码块)【不可用】

public class Singleton_DCL1 {

private Singleton_DCL1() {

};

private static Singleton_DCL1 singleton;

public static Singleton_DCL1 getInstance() {

if (singleton == null) { synchronized (Singleton_DCL1.class) { singleton = new Singleton_DCL1(); }

}

return singleton;

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

双重检测机制：

延迟初始化

多线程不安全

线程稳定

1.为了防止new Singleton被执行多次，因此在new操作之前加上Synchronized 同步锁，锁住整个类(注意，这里不能使用对象锁)。

2.进入Synchronized 临界区以后，还要再做一次判空。因为当两个线程同时访问的时候，线程A构建完对象，线程B也已经通过了最初的判空验证，不做第二次判空的话，线程B还是会再次构建instance对象。这种同步并不能起到线程同步的作用

但是这样的双重检测机制仍然不是绝对线程安全！这里涉及到JVM编译器的指令重排。

一般创建一个对象的时候会有三个步骤： instance = new Singleton

Value =allocate(); //1：分配对象的内存空间

ctorInstance(Value); //2：初始化对象

instance =Value; //3：设置instance指向刚分配的内存地址1

2

3

4

但这三步并不是固定不变的，有可能会经过JVM和CPU的优化，指令将会重排为： instance = new Singleton

Value =allocate(); //1：分配对象的内存空间

instance =Value; //3：设置instance指向刚分配的内存地址

ctorInstance(Value); //2：初始化对象1

2

3

4

当线程A执行完1、3时，instance对象还未完成初始化，但是已经不指向null。这个时候如果B线程进入CPU，则会抢先执行if(instance == null)的判断结果为false，这个时候getInstance方法则会返回一个没有初始化完成的instance对象，结果如下图：

4.DCLPro【推荐使用】

public class Singleton_DCLPro {

private Singleton_DCLPro() {

};

private volatile static Singleton_DCLPro singleton;

public static Singleton_DCLPro getInstance() {

if (singleton == null) { synchronized (Singleton_DCLPro.class) { if (singleton == null) { singleton = new Singleton_DCLPro(); } }

}

return singleton;

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

双检锁/双重校验锁(DCL，即 double-checked locking):

线程稳定

延迟初始化

多线程安全

volatile关键字是防止创建对象时的重排序，在访问volatile变量时不会执行加锁操作。

volatile关键字不但可以防止指令重排，也可以保证线程访问的变量值是主内存中的最新值。

完美解决3.DCL1的问题。

5.Hunger1(静态常量)【可用】

public class Singleton_Hunger1 {

private final static Singleton_Hunger1 INSTANCE = new Singleton_Hunger1();

private Singleton_Hunger1() {

};

public static Singleton_Hunger1 getInstance() {

return INSTANCE;

}

}1

2

3

4

5

6

7

8

9

10

饿汉式(静态常量)：

线程稳定

不会延迟加载

多线程安全

优点：采用了类装载的机制来保证初始化实例时只有一个线程，避免了线程同步问题。没有用synchronized进行加锁，提高执行效率。

缺点：在类装载的时候就完成实例化，没有达到延迟加载的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

6.Hunger2(静态代码块)【可用】

public class Singleton_Hunger2 {

private static Singleton_Hunger2 instance;

static {

instance = new Singleton_Hunger2();

}

private Singleton_Hunger2() {

};

public Singleton_Hunger2 getInstance() {

return instance;

}

}1

2

3

4

5

6

7

8

9

10

11

12

13

饿汉式(静态代码块)：

线程稳定

不会延迟初始化

多线程安全

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。没有用synchronized进行加锁，提高执行效率。

缺点：在类装载的时候就完成实例化，没有达到延迟加载的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。 static{ instance = new Singleton_Hunger2;

}1

2

3

7.Pattern(静态内部类)【推荐使用】

public class Singleton_Pattern {

private Singleton_Pattern() {

};

private static class SingletonInstance {

private static final Singleton_Pattern INSTANCE = new Singleton_Pattern();

}

public Singleton_Pattern getSingleton() {

return SingletonInstance.INSTANCE;

}

}1

2

3

4

5

6

7

8

9

10

11

12

静态内部类：

线程稳定

延迟加载

多线程安全

优点：和5.Hunger1类似，采用了类装载的机制来保证初始化实例时只有一个线程。

但静态内部类则可以达到延迟加载的效果，在Singleton_Pattern类被装载的时候并不会马上实例化，而是在需要实例化的时候再调用getInstance方法实例化，这样才会装载静态内部类SingletonInstance，从而达到Singleton_Pattern的实例化。 类的静态属性只会在第一次加载类的时候初始化，如此在类初始化的时候其他进程是无法进入的，从而保护了线程的安全。

总结为：避免了线程不安全，延迟加载，效率高。

8.Enum【推荐使用】

public enum Singleton_E {

INSTANCE;

public void whateverMethod() {

System.out.println("这是一个枚举单例");

}

}1

2

3

4

5

6

不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。代码简洁。使用起来方便。

关键字

synchronized

synchronized的使用

修饰实例方法，对当前实例对象加锁

修饰静态方法，多当前类的Class对象加锁

修饰代码块，对synchronized括号内的对象加锁

volatile

在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。

volatile关键字是防止创建对象时的重排序，在访问volatile变量时不会执行加锁操作。

volatile关键字不但可以防止指令重排，也可以保证线程访问的变量值是主内存中的最新值。

文章来源: blog.csdn.net，作者：小学没毕业笼，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/qq_28618027/article/details/113482809