java 设计模式 学习笔记（16） 单例模式

单例模式：保证一个类仅有一个实例，并提供一个访问其实例的一个全局访问点

 

根据单例模式的定义，写一个单例模式的例子需要注意两点：

1.实例有该类自己生成 

    为了防止客户代码通过 new Singleton()来实例一个对象，需要将 Singleton的默认构造函数定义为private

2. 提供一个访问其实例的全局访问点

    将访问方法getInstance()定义为 static ，则直接通过Singleton.getInstance() 来获取到实例

3.单例只能有一个实例

   在Singleton类中，将instance 定义为 static ,则保证了不管多少个 Singleton都只有并仅有一个instance 静态变量。

 

单例的实现有两种方式：

饿汉单例：在类被加载时就初始化实例

public class Singleton_hunger { private static Singleton_hunger instance = new Singleton_hunger(); private Singleton_hunger(){ } public static Singleton_hunger getInstance(){ return instance; } }

 

 

懒汉单例：类加载之后，第一次调用getInstance()方法时，才初始化实例。

              不过懒汉式单例的getInstance () 方法需要注意到线程的同步问题：在单例类已经被加载进来，但还没有被调用生成实例之前，有多个线程同时调用getInstance() 方法，那么则可能多次调用  instance = new Singelton_lazy()语句，导致出现多个实例的结果。

所以懒汉单例的getInstance() 方法要使用synchronized 来保证其线程安全性。

 

 

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

 

 

 

现在我们来模拟懒汉单例模式的getInstance() 如果不注意线程安全性时出现的线程不安全现象：

现在将Singleton_lazy 改变一下：  1. 去掉synchronized

                                                  2. 认为的改变getInstance() 方法，但传入的参数为0时，则访问SingletonFull的线程需要休眠500毫秒， 当500毫秒一过，则返回一个单例的实例

public class SingletonFull { private static SingletonFull instance = null; private SingletonFull(){ } public static SingletonFull getInstance (int x) throws InterruptedException{ if(instance == null) { if(x == 0){ Thread.currentThread(); Thread.sleep(500); } instance = new SingletonFull(); } return instance; } }

 

 

 现在编写两个线程类：

/** * Mythread 线程类，主要用来需要延迟500毫秒来获取到一个SingletonFull的实例 * @author liaogang.pt * */ public class Mythread implements Runnable{ private SingletonFull sFull =null; @Override public void run() { // TODO Auto-generated method stub try { sFull = SingletonFull.getInstance(0); } catch (InterruptedException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } System.out.println(sFull); } } /** * Mythread2 线程类，主要用来不需要延迟的获取到一个SingletonFull的实例 * @author liaogang.pt * */ class Mythread2 implements Runnable{ private SingletonFull sFull =null; @Override public void run() { // TODO Auto-generated method stub try { sFull = SingletonFull.getInstance(1); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(sFull); } }

 

 

 

编写测试用的代码：

  public class TestSingletonPattern { public static void main(String[] args){ Singleton_hunger s_hunger = Singleton_hunger.getInstance(); Singleton_hunger s_hunger2 = Singleton_hunger.getInstance(); System.out.println(s_hunger); System.out.println(s_hunger2); Thread thread = new Thread(new Mythread()); Thread thread2 = new Thread(new Mythread2()); thread.start(); thread2.start(); } }

 

输出结果：

Singleton_hunger@c17164 Singleton_hunger@c17164 SingletonFull@1b67f74 SingletonFull@69b332

 

从输出结果中，我们可以看到Mythread 和 Mythread2 两个线程先后访问getInstance()方法，Mythread 在访问getInstance ()时，因为带了参数 0， 所以getInstance()在还没有建立单例实例时停顿了500毫秒。而在这短时间里，Mythread2 趁虚而入，访问 getInstance()方法，立马生成一个单例实例，并返回给Mythread2 。之后500毫秒过了，Mythread所访问的getInstance 线程苏醒，继而执行 instance  = new SingletonFull() 方法，返回另外一个单例实例。

 

 

那么换个思路，我是否可以将测试用的代码换成：

 

 SingletonFull sFull = SingletonFull.getInstance(0);
  SingletonFull sFull2 = SingletonFull.getInstance(1);
  System.out.println(sFull);
  System.out.println(sFull2);

 

结果显示只生成了一个单例实例，为什么呢？

前面提到了在SingletonFull 中的 Thread.currentThread.sleep(500)，是使访问Singleton 类的线程休眠，而不是让SingletonFull 休眠，而且SingletonFull  不是线程类，无法休眠。

 

通过将getInstance() 修改成下面的代码，仅仅是添加了一个输出当前访问SingletonFull 类的线程名字。

public static SingletonFull getInstance (int x) throws InterruptedException{ if(instance == null) { if(x == 0){ System.out.println(Thread.currentThread().getName()); Thread.currentThread(); Thread.sleep(1500); } instance = new SingletonFull(); } return instance; }

 

接着改变测试代码，也添加了一条输出当前线程名称的代码

 

public class TestSingletonPattern { public static void main(String[] args) throws InterruptedException{ System.out.println(Thread.currentThread().getName()); SingletonFull sFull = SingletonFull.getInstance(0); SingletonFull sFull2 = SingletonFull.getInstance(1); System.out.println(sFull); System.out.println(sFull2); } }

 

最后结果输出：

main main SingletonFull@1fb8ee3 SingletonFull@1fb8ee3

从结果中可以看到在整个测试代码运行过程中，只有main 线程在运行。并且这里，由于main线程先休眠了500毫秒，然后才依次打印出单例实例的名称。而在前面的测试代码中，程序一执行，就先输出了一个单例实例名称，过了500毫秒后，才输出另外一个单例实例名称。