单件模式

单例模式

package singletonPattern;

public class Singleton1 {
	
	private static Singleton1 uniqueInstance;
	
	public Singleton1() {}
	
	public Singleton1 getInstance() {
		if(uniqueInstance==null) {
			uniqueInstance=new Singleton1();
			return uniqueInstance;
		}
		return uniqueInstance;
		
	}
	
	/**
	 * 存在的问题是，在多线程运行中，
	 * 比如第一个线程在getInstace，进行uniqueInstace是否为null
	 * 在new之前，第二个线程也进行判断，也会认为是null
	 * 那么两个线程就会分别创造两个对象，就没有做到唯一
	 */

}

存在的问题是
在多线程运行中， 比如第一个线程在getInstace，进行uniqueInstace是否为null在new之前，第二个线程也进行判断，也会认为是null。那么两个线程就会分别创造两个对象，就没有做到唯一

package singletonPattern;

public class Singleton2 {
	private static Singleton2 uniqueInstance;
	
	public Singleton2() {}
	
	public synchronized Singleton2 getInstance() {
		if(uniqueInstance==null) {
			uniqueInstance=new Singleton2();
			return uniqueInstance;
		}
		return uniqueInstance;
		
	}
	
	
	/**
	 * 
	 * 做到了单一对象
	 * 但是带来了新的问题
	 * 在每次进行 getInstance（） 需要加锁，系统需要消耗大量计算资源来确保 同步
	 *  而且枷锁只应该发生在第一次创建，其他时候调用不需要加锁
	 */
	
}

情况分析
做到了单一对象，但是带来了新的问题
在每次进行 getInstance（） 需要加锁，系统需要消耗大量计算资源来确保 同步而且枷锁只应该发生在第一次创建，其他时候调用不需要加锁

package singletonPattern;

public class Singleton3 {

	private static Singleton3 uniqueInstance =new Singleton3();
	
	
	public Singleton3() {}
	
	public Singleton3 getInstance() {
		return uniqueInstance;
	}
	
	
	/**
	 * 存在的问题
	 * 1.java优化时会采用lazy create，使得并没有提前创建
	 * 2.对象持久化使得资源浪费
	 */
}

存在的问题

1. java优化时会采用lazy create，使得并没有提前创建
2. 对象持久化使得资源浪费

package singletonPattern;

public  class Singleton4 {
	private volatile static Singleton4 uniqueInstance;
	
	public Singleton4() {}
	
	public  Singleton4 getInstance() {
		if(uniqueInstance ==null) {
			synchronized(Singleton4.class) {
				if(uniqueInstance==null) {
					uniqueInstance=new Singleton4();
					return uniqueInstance;
				}
			}
		}
		
		return uniqueInstance;
		
	}
	
	/**
	 * 
	 * 双层加锁
	 * 只在第一次创建时，阻塞其他进程，确定唯一的创建
	 * 
	 * volatile 是告诉编译器，不要在优化时创建其他副本，保证同步
	 * 
	 */
	
}

双层加锁

1. 只在第一次创建时，阻塞其他进程，确定唯一的创建
2. volatile 是告诉编译器，不要在优化时创建其他副本，保证同步

推荐链接：
https://www.cnblogs.com/ayqy/p/3962910.html