设计模式—单例模式

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

目的：使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

单例模式：

有些对象我们只需要一个，比如：配置文件、工具类、线程池、缓存、日志对象等。

如果创造出多个实例，就会导致许多问题，比如占用过多资源，不一致的结果等。

作用：保证整个应用中某个实例有且只有一个

类型：饿汉模式和懒汉模式

饿汉模式：静态初始化的方式，解决了多线程环境下的不安全问题，类一加载就实例化对象，所以要提前占用系统资源。

懒汉模式：第一次被引用时，才会将自己实例化

区别：饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快，线程安全

           懒汉模式的特点是加载类时比较快，但运行时获取对象的速度比较慢，线程不安全

线程不安全：多线程的程序中，多个线程同时访问Singleton类，调用getInstance()方法时，会有可能造成创建多个实例

//饿汉模式，线程安全
public class Singleton {   
	//instance设置为：private静态成员变量
	private static Singleton instance = new Singleton();   
	//隐藏构造器
	private Singleton(){}     
	//静态方法
	public static Singleton getInstance() {    
		return instance;
	}
}

//懒汉模式，线程不安全
public class Singleton {   
	//instance设置为：private静态成员变量
	private static Singleton instance;   
	//隐藏构造器
	private Singleton(){}     
	//静态方法
	public static Singleton getInstance() {    
		if(null == instance) {
			instance = new Singleton();
		}
		return instance;
	}
}

import java.util.concurrent.locks.ReentrantLock;
//每个线程调用时都先加锁在判断是否创建实例，影响性能
public class Singleton {

	private static Singleton instance;
	// 定义一个锁对象确保多个线程共用一个
	private static ReentrantLock col = new ReentrantLock();

	private Singleton(){}

	public static Singleton getInstance() {
		try {//加锁
			col.lock(); 
			if(null == instance) {
				instance = new Singleton();
			}} finally {    // 必须在finally里面释放锁，否则程序可能永远处于等待锁的状态！
				col.unlock();
			}
		return instance;
	}
}

import java.util.concurrent.locks.ReentrantLock;
//懒汉模式（双重锁定），只有在实例未被创建的时候再加锁处理，保证多线程的安全
public class Singleton {

	private static Singleton instance;
	// 定义一个锁对象确保多个线程共用一个
	private static ReentrantLock col = new ReentrantLock();

	private static Singleton s1;
	private static Singleton s2;
	private static Singleton s3;
	private static Singleton s4;

	private Singleton(){}

	public static Singleton getInstance() {
		if(null == instance) {
			try { //加锁
				col.lock(); 
				if(null == instance) {
					instance = new Singleton();
				}} finally {
					// 必须在finally里面释放锁，否则程序可能永远处于等待锁的状态！
					col.unlock();
				};
		}
		return instance;
	}
	//测试
	public static void main(String[] args) {
		//创建4个线程去调用getInstance()
		Thread t1 = new Thread(() ->{
			Singleton s = Singleton.getInstance();
			Singleton s1 = s;});
		Thread t2 = new Thread(() ->{
			Singleton s = Singleton.getInstance();
			Singleton s2 = s;});
		Thread t3 = new Thread(() ->{
			Singleton s = Singleton.getInstance();
			Singleton s3= s;});
		Thread t4 = new Thread(() ->{
			Singleton s = Singleton.getInstance();
			Singleton s4 = s;});

		t1.start();
		t2.start();
		t3.start();
		t4.start();
		try {
			t1.join();
			t2.join();
			t3.join();
			t4.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//是否都获取同一个实例
		System.out.println(s1 == s2 && s1 == s2 && s1 == s3 &&
				s2 == s3 && s2 == s4 && s3 == s4);
	}
}

//大话设计模式的结论：

lock确保当一个线程位于代码的临界区时，另一个线程不进入临界区。如果其他线程试图进入锁定的代码，则它将一直等待（即被阻止），直到对象被释放

加锁后还需要进行一次判断——原因：当instance为null并且同时有两个线程调用getInstance方法时，进入第一重判断后，由于lock机制，两个线程只有一个能过进入执行，另一个在外排队等待，待第一个执行完才进入。