1 package com.cnblogs.mufasa.Demo3;
 2 
 3 public class Singleton {
 4     private static Singleton instance=new Singleton();
 5     private Singleton(){
 6         System.out.println("饿汉式 无参构造");
 7     }
 8     public static Singleton getInstance(){
 9         return instance;
10     }
11     public void print(){
12         System.out.println("饿汉式【单例设计模式】");
13     }
14 }

 1 package com.cnblogs.mufasa.Demo3;
 2 //普通懒汉式，多线程会出现多个实例化
 3 //多线程情况下，就不是单例模式了，没有进行synchronized
 4 public class Singleton1 {
 5     private static Singleton1 instance=null;
 6     private String str="";
 7     private Singleton1(){
 8         System.out.println("【"+Thread.currentThread().getName()+"】单线程下的单例模式");
 9     }
10     public static Singleton1 getInstance(){
11         if(instance==null){
12             instance=new Singleton1();
13         }
14         return instance;
15     }
16     public void print(){
17         System.out.println(str+"懒汉式单例模式");
18     }
19 
20     public String getStr() {
21         return str;
22     }
23 
24     public void setStr(String str) {
25         this.str = str;
26     }
27 }

 1 package com.cnblogs.mufasa.Demo3;
 2 //代价很大，以前的并发变成串行，效率降低
 3 public class Singleton2 {
 4     private static Singleton2 instance = null;
 5     private Singleton2(){
 6         System.out.println("【"+Thread.currentThread().getName()+"】单线程下的单例模式");
 7     }
 8     public static synchronized Singleton2 getInstance(){
 9         if(instance==null){
10             instance=new Singleton2();
11         }
12         return instance;
13     }
14     public void print(){
15         System.out.println("懒汉式【单例设计模式】添加getInstance同步修饰");
16     }
17 }

 1 package com.cnblogs.mufasa.Demo3;
 2 //双重效验锁
 3 //只是在处理空对象时，才进行同步操作，只有一次是同步其他全部是并发非同步处理
 4 public class Singleton3 {
 5 //    private static volatile Singleton3 instance=null;
 6     private static Singleton3 instance = null;//添加volatile修饰符
 7     private Singleton3(){
 8         System.out.println("【"+Thread.currentThread().getName()+"】*** 单线程下的【单例模式】 ***");
 9     }
10     public static Singleton3 getInstance(){//还是并发处理
11         if(instance==null){
12             synchronized (Singleton3.class){
13                 if(instance==null){
14                     instance=new Singleton3();
15                 }
16             }
17         }
18         return instance;
19     }
20     public void print(){
21         System.out.println("懒汉式【单例设计模式】");
22     }
23 }

 1 package com.cnblogs.mufasa.Demo3;
 2 //双重效验锁
 3 //只是在处理空对象时，才进行同步操作，只有一次是同步其他全部是并发非同步处理
 4 public class Singleton3 {
 5     private static volatile Singleton3 instance=null;
 6 //    private static Singleton3 instance = null;//添加volatile修饰符
 7     private Singleton3(){
 8         System.out.println("【"+Thread.currentThread().getName()+"】*** 单线程下的【单例模式】 ***");
 9     }
10     public static Singleton3 getInstance(){//还是并发处理
11         if(instance==null){
12             synchronized (Singleton3.class){
13                 if(instance==null){
14                     instance=new Singleton3();
15                 }
16             }
17         }
18         return instance;
19     }
20     public void print(){
21         System.out.println("懒汉式【单例设计模式】");
22     }
23 }

 1 package com.cnblogs.mufasa.Demo3;
 2 
 3 public class Singleton4 {
 4     private static class SingletonHolder{
 5         private static Singleton4 instance=new Singleton4();
 6     }
 7     private Singleton4(){
 8         System.out.println("无参构造");
 9     }
10     public static Singleton4 getInstance(){
11         return SingletonHolder.instance;
12     }
13     public void print(){
14         System.out.println("holder模式实现的线程安全单例"+Thread.currentThread().getName());
15     }
16 }

1 package com.cnblogs.mufasa.Demo3;
2 
3 enum  Singleton5 {
4     INSTANCE;
5     public void print(){
6         System.out.println("枚举法实现的线程安全单例模式"+Thread.currentThread().getName());
7     }
8 }

 1 package com.cnblogs.mufasa.Demo3;
 2 //使用ThreadLocal实现单例模式（线程安全）
 3 public class Singleton6 {
 4     private Singleton6(){}
 5     private static final ThreadLocal<Singleton6> tlSingleton=new ThreadLocal<>(){
 6         @Override
 7         protected Singleton6 initialValue(){
 8             return new Singleton6();
 9         }
10     };
11 
12     public static Singleton6 getInstance(){
13         return tlSingleton.get();
14     }
15 
16     public static void print(){
17         System.out.println("ThreadLocal实现单例模式");
18     }
19 
20 }

 1 package com.cnblogs.mufasa.Demo3;
 2 
 3 import java.util.concurrent.atomic.AtomicReference;
 4 
 5 //使用CAS锁实现（线程安全）
 6 public class Singleton7 {
 7     private static final AtomicReference<Singleton7> INSTANCE = new AtomicReference<Singleton7>();
 8     private Singleton7(){
 9     }
10     public static final Singleton7 getInstance(){
11         for(;;){
12             Singleton7 current=INSTANCE.get();
13             if(current!=null){
14                 return current;
15             }
16             current=new Singleton7();
17             if(INSTANCE.compareAndSet(null,current)){
18                 System.out.println("同步锁比较");
19                 return current;
20             }
21         }
22     }
23     public static void print(){
24         System.out.println("CAS锁实现单例模式");
25     }
26 
27 }