设计模式---单例模式

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。

1、常见的单例模式有两种创建方式：所谓饿懒汉式与饿汉式

（1）懒汉式

　　懒汉式就是不在系统加载时就创建类的单例，而是在第一次使用实例的时候再创建。

 

package shejimoshi.danLiMoShi;

/**
 * 懒汉实例	第一次使用实例时才创建对象
 */
public class TestSingletonLanHan {
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	private static TestSingletonLanHan ts1 = null;

	// 该类只能有一个实例
	private TestSingletonLanHan() {
	} // 私有无参构造方法
		// 该类必须自行创建
		// 有2种方式


	// 这个类必须自动向整个系统提供这个实例对象
	//public static TestSingletonLanHan getTest() {
	//为了保证线程安全，可以添加synchronized关键字来获取同步，但是每次在执行都会进行同步和判断，效率会降低。
	public static synchronized TestSingletonLanHan getTest() {
		if (ts1 == null) {
			ts1 = new TestSingletonLanHan();
		}
		return ts1;
	}

	public void getInfo() {
		System.out.println("output message " + name);
	}

	public static void main(String[] args) {
		//s和s1是同一个对象，所以赋值会被覆盖
		TestSingletonLanHan s = TestSingletonLanHan.getTest();
		s.setName("test 1");
		System.out.println(s.getName());
		TestSingletonLanHan s1 = TestSingletonLanHan.getTest();
		s1.setName("test 2");
		System.out.println(s1.getName());
		
		TestSingletonLanHan s2 = new TestSingletonLanHan();
		s2.setName("test3");
		TestSingletonLanHan s3 = new TestSingletonLanHan();
		s3.setName("test4");
		s.getInfo();   // output message test 2
		s1.getInfo();	// output message test 2
		s2.getInfo();
		s3.getInfo();
		//s == s1是成立的，说明改变的是同一个name。
		if (s == s1) {
			System.out.println("创建的是同一个实例");
		}
	}
}

　　

（2）饿汉式

　　在加载类的时候就会创建类的单例，并保存在类中。

 

package shejimoshi.danLiMoShi;

/**
 * 饿汉式    系统加载时创建对象
 * 线程安全
 */
public class TestSingletonEHan {
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	private TestSingletonEHan(){
		
	}
	
	private static TestSingletonEHan ts1 = new TestSingletonEHan();
	
	private static TestSingletonEHan instance(){
		return ts1;
	}
	
	public void getInfo() {
		System.out.println("output message " + name);
	}
	
	public static void main(String[] args) {
		TestSingletonEHan s = TestSingletonEHan.instance();
		s.setName("test 1");
		System.out.println(s.getName());
		TestSingletonEHan s1 = TestSingletonEHan.instance();
		s1.setName("test 2");
		System.out.println(s1.getName());
		s.getInfo();   // output message test 2
		s1.getInfo();	// output message test 2
		//s == s1是成立的，说明改变的是同一个name。
		if (s == s1) {
			System.out.println("创建的是同一个实例");
		}
	}
}

2、双重加锁机制

　　何为双重加锁机制？

　　在懒汉式实现单例模式的代码中，有使用synchronized关键字来同步获取实例，保证单例的唯一性，但是上面的代码在每一次执行时都要进行同步和判断，无疑会拖慢速度，使用双重加锁机制正好可以解决这个问题：

package shejimoshi.danlimoshi;

/**
 * 双重加锁机制
 */
public class TestSingleTonShuangChongJiaSuo {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	private TestSingleTonShuangChongJiaSuo() {

	}

	private static volatile TestSingleTonShuangChongJiaSuo dl = null;

	public static TestSingleTonShuangChongJiaSuo getInstance() {
		if (dl == null) {
			synchronized (TestSingleTonShuangChongJiaSuo.class) {
				if (dl == null) {
					dl = new TestSingleTonShuangChongJiaSuo();
				}
			}
		}
		return dl;
	}
	
	public static void main(String[] args) {
		TestSingletonLanHan s = TestSingletonLanHan.getTest();
		s.setName("test 1");
		System.out.println(s.getName());
		TestSingletonLanHan s1 = TestSingletonLanHan.getTest();
		s1.setName("test 2");
		System.out.println(s1.getName());
		s.getInfo();   // output message test 2
		s1.getInfo();	// output message test 2
		//s == s1是成立的，说明改变的是同一个name。
		if (s == s1) {
			System.out.println("创建的是同一个实例");
		}
	}
}

看了上面的代码，有没有感觉很无语，双重加锁难道不是需要两个synchronized进行加锁的吗？

　　......

　　其实不然，这里的双重指的的双重判断，而加锁单指那个synchronized，为什么要进行双重判断，其实很简单，第一重判断，如果单例已经存在，那么就不再需要进行同步操作，而是直接返回这个实例，如果没有创建，才会进入同步块，同步块的目的与之前相同，目的是为了防止有两个调用同时进行时，导致生成多个实例，有了同步块，每次只能有一个线程调用能访问同步块内容，当第一个抢到锁的调用获取了实例之后，这个实例就会被创建，之后的所有调用都不会进入同步块，直接在第一重判断就返回了单例。至于第二个判断，个人感觉有点查遗补漏的意味在内（期待高人高见）。

　　不论如何，使用了双重加锁机制后，程序的执行速度有了显著提升，不必每次都同步加锁。

　　其实我最在意的是volatile的使用，volatile关键字的含义是：被其所修饰的变量的值不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存来实现，从而确保多个线程能正确的处理该变量。该关键字可能会屏蔽掉虚拟机中的一些代码优化，所以其运行效率可能不是很高，所以，一般情况下，并不建议使用双重加锁机制，酌情使用才是正理！

3、类级内部类方式

　　饿汉式会占用较多的空间，因为其在类加载时就会完成实例化，而懒汉式又存在执行速率慢的情况，双重加锁机制呢？又有执行效率差的毛病，有没有一种完美的方式可以规避这些毛病呢？

　　貌似有的，就是使用类级内部类结合多线程默认同步锁，同时实现延迟加载和线程安全。

package shejimoshi.danLiMoShi;

/**
 * 类级内部类方式
 * 最安全的单例模式
 */
public class TestSingletonNeiBuLei {
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	private TestSingletonNeiBuLei() {
		
	}
	
	public static class DanliHolder {
		private static TestSingletonNeiBuLei dl = new TestSingletonNeiBuLei();
	}


	public static TestSingletonNeiBuLei getInstance() {
		return DanliHolder.dl;
	}
	
	public void getInfo(){
		System.out.println("name : " + name);
	}
	
	public static void main(String[] args) {
		TestSingletonNeiBuLei s = TestSingletonNeiBuLei.getInstance();
		s.setName("test 1");
		System.out.println(s.getName());
		TestSingletonNeiBuLei s1 = TestSingletonNeiBuLei.getInstance();
		s1.setName("test 2");
		System.out.println(s1.getName());
		s.getInfo();   // output message test 2
		s1.getInfo();	// output message test 2
		//s == s1是成立的，说明改变的是同一个name。
		if (s == s1) {
			System.out.println("创建的是同一个实例");
		}
	}
}

如上代码，所谓类级内部类，就是静态内部类，这种内部类与其外部类之间并没有从属关系，加载外部类的时候，并不会同时加载其静态内部类，只有在发生调用的时候才会进行加载，加载的时候就会创建单例实例并返回，有效实现了懒加载（延迟加载），至于同步问题，我们采用和饿汉式同样的静态初始化器的方式，借助JVM来实现线程安全。

　　其实使用静态初始化器的方式会在类加载时创建类的实例，但是我们将实例的创建显式放置在静态内部类中，它会导致在外部类加载时不进行实例创建，这样就能实现我们的双重目的：延迟加载和线程安全。

4、使用

　　在Spring中创建的Bean实例默认都是单例模式存在的。