JAVA设计模式:单例模式

Java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍二种：懒汉式单例、饿汉式单例。

单例模式Singleton
 * 应用场合:有些对象只有一个就够了，如皇帝和老婆

 1. Windows的Task Manager（任务管理器）

   2. windows的Recycle Bin（回收站）

   3. 数据库连接池的设计一般也是采用单例模式

   ..............

 * 作用:保证整个应用程序中，某个实例有且只有一个

饿汉模式

public class Singleton {//饿汉模式->在类加载的时候，它的实例就加载了(private static Singleton instance=new Singleton())//将构造方法私有化，不允许外界直接创造对象private Singleton(){}//在类的内部创建一个唯一实例private static Singleton instance=new Singleton();//提供一个获取实例的方法public static Singleton getInstance(){return instance;}}

懒汉模式

public class Singleton2 {//1.将构造方法私有化，不允许外部直接创建对象private Singleton2(){}//2.声明类的唯一实例，使用private static修饰private static Singleton2 instance;//3.提供一个获取实例的方法，使用public static修饰public static Singleton2 getInstance(){if(instance==null){instance=new Singleton2();}return instance;}}

测试:

public static void main(String[] args) {//饿汉模式Singleton s1=Singleton.getInstance();Singleton s2=Singleton.getInstance();if(s1==s2){System.out.println("s1和s2是同一个实例");}else{System.out.println("s1和s2不是同一个实例");}//懒汉模式Singleton2 s3=Singleton2.getInstance();Singleton2 s4=Singleton2.getInstance();if(s3==s4){System.out.println("s3和s4是同一个实例");}else{System.out.println("s3和s4不是同一个实例");}}

结果是

"s1和s2是同一个实例“

”s3和s4是同一个实例“

但是以上懒汉模式的实现没有考虑线程安全的问题，在并发情况下可能出现多个Singleton实例，可以加上synchronized，不过最好加在getInstance方法里面

public static Singleton2 getInstance() {          if (instance == null) {                synchronized (Singleton2.class) {                   if (instance == null) {                      instance = new Singleton2();                  }                }            }            return instance;       }  

synchronized 写在方法上，为什么效率低？
在N个线程同时都在getInstance的情况下，如果synchronized 加在方法上，那么每次getInstance都需要加锁，解锁。
意味着：获取该类的实例对象时，N个线程都必须排队，一个个等着获取锁。

为什么synchronized写在里面，要判断两次instance是否为空？

假设程序刚启动，同时100个线程，都在拿instance，这时候，instance还没实例化，运行在最前面的5个线程A,B,C,D,E，因为instance == null
他们都运行到了的if (instance == null)大括号内，同步代码块前。ABCDE，5个线程中的一个“幸运儿D"，拿到了锁内代码的执行权（cpu给它分配了时间片），而其他4线程，A,B,C,E个只能在同步代码块外面等候，“幸运儿D"，进入代码块后，再次判断instance==null？
发现instance确实没被创建，为null，于是new操作创建instance，拿到了instance，返回，并且把“锁”释放。
剩下的A,B,C,E，也一个一个进入同步代码块，与D不同的是，他们在锁内的判断中都发现instance不等于null，
(很显然同步代码快里面如果没有再次判断，instance会被创建5次...)
不需要new操作，直接拿。


至于剩下的95个线程，他们在instance被创建之后，
才走到第一个判断 if (instance == null) 这里，
这时候，他们发现instance不等于null，已经被创建了
他们都不需要经过同步代码快，所以效率高。