设计模式之单例模式

1.单例模式

即保证整个系统只有一个实例对象

1.1使用场景可有：

1).数据缓存对象

2).工具方法

1.2实现方式：

通过对构造函数私有化类实现对象单例

2.单例的代码实现

2.1实现方式一

（懒汉式）

Singleton

public class Singleton {
	
	private static Singleton _instance = null;
	
	private Singleton(){
		System.out.println("初始化");
	}
	
	public static Singleton getInstance(){
		if(_instance == null){
			_instance = new Singleton();
		}
		return _instance;
	}

	public static void doSomething(){
		System.out.println("做点东西吧！");
	}
}

Client

public class Client{
     public static void main(){
        Singleton singleton = Singleton.getInstance();
        singleton.doSomething();
	System.out.println(singleton);
	singleton = Singleton.getInstance();
	System.out.println(singleton);
     }
}

上面这种方式存在问题，当有多线程时，会导致实例被创建多次。于是我们引入同步锁：

2.2同步锁优化

Singleton

public class Singleton{
	private static Singleton _instance = null;
	
	private Singleton(){}
		
	public static Singleton getInstance(){
		synchronized(Singleton.class){
			if(_instance == null){
				_instance = new Singleton();
			}
			return _instance;
		}
	}	
	public static void doSomething(){
		System.out.println("做点东西吧");
	}
}

Client:

public class Client{
	public static void main(String[] args){
		for(int i = 0;i < 10;i++){
			Thread t = new Thread(new Runable(){
				public void run(){
					Singleton singleton = Singleton.getInstnace();
					System.out.println(singleton);
				}
			});
			t.start();
		}
	}
}

如上，加入同步关键字后会引发效率问题，我们可以加入双检锁，缩小锁的范围

2.3使用双检锁

Singleton

public class Singleton {

	private static Singleton _instance = null;

	private Singleton() {
	}

	/**
	 * new Singleton() 这句话其实是包含三个逻辑 1.给Singleton实例创建空间 2.初始化Singleton的构造器
	 * 3.把Singleton这个实例的引用赋值给_instance (_instance就不为null了)
	 * 由于jvm运行期的优化，第二部和第三步的顺序是不能保证的 这样就会导致出现两种情况1,2,3或1,3,2
	 */
	public static Singleton getInstance() {
		if (_instance == null) {
			synchronized (Singleton.class) {
				if (_instance == null) {
					_instance = new Singleton();
				}
			}
		}
		return _instance;
	}

	public static void doSomething() {
		System.out.println("做点东西吧");
	}
}

Client

public class Client{
	public static void main(String[] args){
		for(int i = 0;i < 10;i++){
			Thread t = new Thread(new Runnable(){
				public void run(){
					Singleton singleton = Singleton.getInstance();
					System.out.println(singleton);
				}
			});
			t.start();
		}
	}
}

如上这种实现方式中 new  Singleton()包含三个逻辑：

1.给Singleton实例创建空间

2.初始化Singleton的构造器

3.把singleton这个实例的引用赋值给_instance （_instance就不为null了）

假如第一个线程调用获取实例的方法时，执行到new Singleton();这句话，只执行了1,3两个步骤，

这个时候_instance已经不为null了，但是构造器没有初始化完成，然后第二个线程进来，由于此时

_instance已经不为null了，所以在判读非空的时候就直接返回了，这时如果线程2使用这个构造器没

有初始化完成的singleton对象的话，就会报错！

解决方案有：

1.jdk1.5及1.5以后版本可以在变量中声明volatile关键字，让线程强制读取主内容中的变量，而不去读取变量副本。

2.通过饿汉式的单例模式来解决

3.使用静态类来保存instance

2.4使用volatile关键字

Singleton

public class Singleton {
	
	private static volatile Singleton _instance = null;
	
	private Singleton(){}
	
	public static Singleton getInstance(){
		if(_instance == null){
			synchronized(Singleton.class){
				if(_instance == null){
					_instance = new Singleton();
				}
			}
		}
		return _instance;
	}

	public static void doSomething(){
		System.out.println("做点东西吧！");
	}
}

2.5饿汉式

public class Singleton{
	
	private final static Singleton _instance = new Singleton();
	
	private Singleton(){
		System.out.println("初始化！");
	}
	
	public static Singleton getInstance(){
		return _instance;
	}
	
	public static void doSomething(){
		System.out.println("做点东西吧！");
	}
}

Client

public class Client {
	public static void main(String[] args) throws ClassNotFoundException {
		Class.forName("singleton.Singleton");
		Singleton.getInstance().doSomething();
	}
}

2.6静态类保存instance的方式

Singleton

public class Singleton{
	
	private static class SingletonHolder{
		static Singleton _instance = new Singleton();
	}
	
	private Singleton(){
		System.out.println("初始化！");
	}
	
	public static Singleton getInstance(){
		return SingletonHolder._instance;
	}
	
	public static void doSomething(){
		System.out.println("做点什么吧！");
	}
	
}

Client

public class Client {
	public static void main(String[] args) throws ClassNotFoundException {
		Class.forName("singleton.Singleton");
		Singleton.getInstance().doSomething();
	}
}

小结：在软件设计当中，我们应该遵循一个法则，简单，正确。不为了炫耀技术来实现需求，只有简单，正确的实现方式，它生命周期才是最长，因它可维护性高。所以选择懒汉还是饥汉的方式是根据具体的场景定的。