标签：author one span ati 重排序 基础 img 安全 指令重排序
一个系统中有且只有一个对象实例。
创建方式：饿汉式+懒汉式两种方式
饿汉式：程序初始化的时候就创建了类的对象，需要的时候就直接返回对象实例。
1 /** 2 * 饿汉式 3 */ 4 static class Singleton1 { 5 private static final Singleton1 s = new Singleton1(); 6 7 private Singleton1() { 8 } 9 10 public static Singleton1 getInstance() { 11 return s; 12 } 13 }
懒汉式：在真正需要实例化对象的时候才进行创建对象。
1 /** 2 * 懒汉式 3 */ 4 static class Singleton2 { 5 private static Singleton2 s = null; 6 7 private Singleton2() { 8 } 9 10 public static Singleton2 getInstance() { 11 if (s == null) { 12 s = new Singleton2(); 13 } 14 return s; 15 } 16 }
以上两种方式是只适用于单线程，这两种方式在多线程的时候是非线程安全的。
为了在多线程的情况下使用
1. 在懒汉式方式下添加synchronized关键字，形成双检锁方式。
1 /** 2 * 多线程环境下的懒汉式单例模式(DCL，双检锁实现) 3 */ 4 static class Singleton3 { 5 private static Singleton3 s = null; 6 7 private Singleton3() { 8 } 9 10 public static Singleton3 getInstance() { 11 if (s == null) { 12 synchronized (Singleton3.class) { 13 if (s == null) { 14 s = new Singleton3(); 15 } 16 } 17 } 18 return s; 19 } 20 }
2. 在双检锁的基础上添加volatile关键字，形成双检锁+volatile的方式，这种方式主要是防止指令的重排序。
1 /** 2 * 多线程环境下的懒汉式单例模式(DCL，双检锁+volatile实现) 3 * 加入了volatile变量来禁止指令重排序 4 */ 5 static class Singleton4 { 6 private static volatile Singleton4 s = null; 7 8 private Singleton4() { 9 } 10 11 public static Singleton4 getInstance() { 12 if (s == null) { 13 synchronized (Singleton4.class) { 14 if (s == null) { 15 s = new Singleton4(); 16 } 17 } 18 } 19 return s; 20 } 21 }
单例模式以上四种方式的完整代码如下：
1 /** 2 * @author: wooch 3 * @create: 2020/02/13 4 */ 5 6 /** 7 * 单例模式 8 * 分为 饿汉式和懒汉式两种 9 */ 10 public class Singleton { 11 /** 12 * 饿汉式 13 */ 14 static class Singleton1 { 15 private static final Singleton1 s = new Singleton1(); 16 17 private Singleton1() { 18 } 19 20 public static Singleton1 getInstance() { 21 return s; 22 } 23 } 24 25 /** 26 * 懒汉式 27 */ 28 static class Singleton2 { 29 private static Singleton2 s = null; 30 31 private Singleton2() { 32 } 33 34 public static Singleton2 getInstance() { 35 if (s == null) { 36 s = new Singleton2(); 37 } 38 return s; 39 } 40 } 41 42 /** 43 * 多线程环境下的懒汉式单例模式(DCL，双检锁实现) 44 */ 45 static class Singleton3 { 46 private static Singleton3 s = null; 47 48 private Singleton3() { 49 } 50 51 public static Singleton3 getInstance() { 52 if (s == null) { 53 synchronized (Singleton3.class) { 54 if (s == null) { 55 s = new Singleton3(); 56 } 57 } 58 } 59 return s; 60 } 61 } 62 63 /** 64 * 多线程环境下的懒汉式单例模式(DCL，双检锁+volatile实现) 65 * 加入了volatile变量来禁止指令重排序 66 */ 67 static class Singleton4 { 68 private static volatile Singleton4 s = null; 69 70 private Singleton4() { 71 } 72 73 public static Singleton4 getInstance() { 74 if (s == null) { 75 synchronized (Singleton4.class) { 76 if (s == null) { 77 s = new Singleton4(); 78 } 79 } 80 } 81 return s; 82 } 83 } 84 }
标签：author one span ati 重排序 基础 img 安全 指令重排序
原文地址：https://www.cnblogs.com/baishouzu/p/12304559.html
