单例模式的几种写法

 1 package single;
 2 
 3 /**
 4  * 饿汉式，类一加载直接创建好实例对象
 5  *
 6  * （1） 构造器私有化
 7  * （2） 自行创建，并且用静态变量保存
 8  * （3） 向外提供这个实例
 9  * （4） 强调这是一个单例，用static关键字修饰
10  */
11 public class Singleton1 {
12     public static final Singleton1 INSTANCE=new Singleton1();
13 
14     private Singleton1(){
15 
16     }
17 }

 1 package single;
 2 
 3 /**
 4  * 使用枚举的方式设计单例模式
 5  * 枚举类型，表示该类型呢的对象是有限的几个
 6  * 限定为一个就成单例了
 7  *
 8  */
 9 public enum Singleton2 {
10     INSTANCE
11 }

 1 package single;
 2 
 3 /**
 4  * 可以给类传参的饿汉式写法，对第一种方法的改造
 5  */
 6 public class SingleTon3 {
 7     public static final SingleTon3 INSTANCE;
 8     private String info;
 9     private SingleTon3(String info){
10         this.info=info;
11     }
12 
13     static {
14         INSTANCE=new SingleTon3("传入参数");
15     }
16 }

 1 package single;
 2 
 3 /**
 4  * 为解决多线程情况下的可能被创建多个实例的情况，在实例为空，创建第一个实例的时候加入synchronize同步锁
 5  */
 6 public class Singleton5 {
 7     private static Singleton5 INSTANCE;
 8     private Singleton5(){
 9 
10     }
11     public static Singleton5 getInstance(){
12         if(INSTANCE==null){
13             synchronized (Singleton5.class){
14                 //模拟多线程下的延时
15                 try {
16                     Thread.sleep(100);
17                 } catch (InterruptedException e) {
18                     e.printStackTrace();
19                 }
20                 INSTANCE=new Singleton5();
21             }
22         }
23         return INSTANCE;
24     }
25 }

 1 package single;
 2 
 3 /**
 4  * 懒汉式的另一种思路，设计一个内部类，将实例的创建放在内部类的静态变量中，
 5  * 静态内部类相当于一个独立的类，使内部类被加载和初始化时才创建实例，因此不会存在线程安全问题
 6  */
 7 public class Singleton6 {
 8     private Singleton6(){
 9 
10     }
11     private static class Inner{
12         private static final Singleton6 INSTANCE=new Singleton6();
13     }
14     public static Singleton6 getInstance(){
15         return Inner.INSTANCE;
16     }
17 }