java单例模式八种实现方式

饿汉式两种

懒汉式三种

双重检验

静态内部类

枚举

• 一.饿汉式(两种)
  • 　1.静态常量

 1 /**
 2  * @author 79282
 3  * 单列模式第一种 写法:饿汉式(静态常量)
 4  */
 5 public class Singleton01 {
 6     //私有化构造器
 7     private Singleton01() {
 8
 9     }
10
11     //私有静态常量
12     private static final Singleton01 INSTANCE = new Singleton01();
13
14     //get方法
15     public static Singleton01 getInstance() {
16         return INSTANCE;
17     }
18
19 }
20 class Test01{
21     public static void main(String[] args) {
22         Singleton01 instance01 = Singleton01.getInstance();
23         Singleton01 instance02 = Singleton01.getInstance();
24         System.out.println(instance01 == instance02);
25     }
26
27 }

• • 2.静态代码块

 1 /**
 2  * @author 79282
 3  * 饿汉式 静态代码块
 4  */
 5 public class Singleton02 {
 6     //私有化构造器
 7     private Singleton02() {
 8
 9     }
10
11     private static Singleton02 instance;
12     //静态代码块
13     static{
14         instance = new Singleton02();
15     }
16
17     public static Singleton02 getInstance() {
18         return instance;
19     }
20 }
21 class Test02{
22
23     public static void main(String[] args) {
24         Singleton02 instance01 = Singleton02.getInstance();
25         Singleton02 instance02 = Singleton02.getInstance();
26         System.out.println(instance01 == instance02);
27     }
28 }

• 二.懒汉式(三种).
  • 　　1.线程不安全 不推荐使用

 1 /**
 2  * @author 79282
 3  * 懒汉式 (线程不安全)不可用
 4  */
 5 public class Singleton03 {
 6     //私有化构造器
 7     private Singleton03() {
 8
 9     }
10
11     private static Singleton03 instance = null;
12
13
14     public static Singleton03 getInstance() {
15
16         if (instance == null) {
17              instance = new Singleton03();
18         }
19         return instance;
20     }
21
22 }
23
24 class Test03 {
25     public static void main(String[] args) {
26         Singleton03 instance01 = Singleton03.getInstance();
27         Singleton03 instance02 = Singleton03.getInstance();
28         System.out.println(instance01 == instance02);
29     }
30 }

• • 　　2.线程安全的(使用同步方法) 不推荐使用

 1 /**
 2  * @author 79282
 3  * 懒汉式 线程安全的(使用同步方法) 不推荐使用
 4  */
 5 public class Singleton04 {
 6     //私有化构造器
 7     private Singleton04() {
 8
 9     }
10
11     private static Singleton04 instance = null;
12
13     public static synchronized Singleton04 getInstance() {
14         if (instance == null) {
15             instance = new Singleton04();
16         }
17         return instance;
18     }
19 }
20 class Test04{
21     public static void main(String[] args) {
22         Singleton04 instance01 = Singleton04.getInstance();
23         Singleton04 instance02 = Singleton04.getInstance();
24         System.out.println(instance01 == instance02);
25     }
26 }

• • 　　3.使用同步代码块(线程安全)

 1 /**
 2  * @author 79282
 3  * 懒汉式 使用同步代码块 不可用
 4  */
 5 public class Singleton05 {
 6     private Singleton05() {
 7
 8     }
 9
10     private static Singleton05 instance = null;
11
12     public static Singleton05 getInstance() {
13         if (instance == null) {
14             synchronized (Singleton05.class) {
15                 instance = new Singleton05();
16             }
17         }
18         return instance;
19     }
20 }
21
22 class Test05{
23     public static void main(String[] args) {
24
25         Singleton05 instance01 = Singleton05.getInstance();
26         Singleton05 instance02 = Singleton05.getInstance();
27         System.out.println(instance01 == instance02);
28
29     }
30 }

• 三.双重检查(推荐使用)

 1 /**
 2  * @author 79282
 3  * 懒汉式 双重检验(推荐使用)
 4  */
 5 public class Singleton06 {
 6     private Singleton06() {
 7
 8     }
 9
10     private static Singleton06 instance = null;
11     public static Singleton06 getInstance() {
12         if (instance == null) {
13             synchronized (Singleton06.class) {
14                 if (instance == null) {
15                     instance = new Singleton06();
16                 }
17
18
19             }
20         }
21
22         return instance;
23     }
24 }
25 class Test06{
26     public static void main(String[] args) {
27         Singleton06 instance01 = Singleton06.getInstance();
28         Singleton06 instance02 = Singleton06.getInstance();
29         System.out.println(instance01 == instance02);
30     }
31 }

• 四.使用静态内部类(推荐使用)

 1 /**
 2  * @author 79282
 3  * 静态内部类创建单例(推荐使用)
 4  */
 5 public class Singleton07 {
 6     private Singleton07() {
 7
 8
 9     }
10
11     //私有静态内部类
12     private static class SingletonInstance{
13         private static final Singleton07 INSTANCE = new Singleton07();
14     }
15
16     public static Singleton07 getInstance() {
17         return  SingletonInstance.INSTANCE;
18     }
19
20
21 }
22 class Test07{
23     public static void main(String[] args) {
24
25         Singleton07 instance01 = Singleton07.getInstance();
26         Singleton07 instance02 = Singleton07.getInstance();
27         System.out.println(instance01 == instance02);
28     }
29 }

• 五.使用枚举(推荐使用)

 1 /**
 2  * @author 79282
 3  * 使用枚举 (推荐使用)/
 4  */
 5 public enum Singleton08 {
 6
 7     INSTANCE;
 8
 9 }
10 class Test08{
11     public static void main(String[] args) {
12         Singleton08 instance01 = Singleton08.INSTANCE;
13         Singleton08 instance02 = Singleton08.INSTANCE;
14         System.out.println(instance01 == instance02);
15     }
16
17 }

原文地址：https://www.cnblogs.com/dreamjujujia/p/11695198.html