设计模式之单例模式

单例模式是一个比较简单的模式。

定义如下：确保某一个类只有一个实例，而且自行化实例并向整个系统提供这个实例。

单例模式的优缺点：

优点：

1、由于内存中只有一个实例，减少了内存的开销，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化。

2、由于单例模式只生成一个实例，所以减少系统开销。尤其是产生需要大量的资源时，可以用过应用启动时直接产生一个单例对象，然后用驻留在内存的方式来解决。

3、可以在系统中设置全局访问，优化和共享资源访问。

缺点：

1、单例模式扩展困难，基本需要修改代码。

2、测试时不方便。

3、单例模式和单一职责原则有冲突。

单例模式的类图：

实现代码：

饿汉模式：

package com.designpatterns.singleton;

public class SingletonHungryMode {
	private static final SingletonHungryMode SINGLETON = new SingletonHungryMode();

	private SingletonHungryMode() {

	}
	
	public static SingletonHungryMode getSingleton(){
		return SINGLETON;
	}

	public void sayHello() {
		System.out.println("I am SingletonHungry!");
		
	}

}

懒汉模式：

package com.designpatterns.singleton;

public class SingletonLazyMode{
	private static SingletonLazyMode SINGLETON = null;

	private SingletonLazyMode() {
		
	}
	
	public static SingletonLazyMode getSingleton(){
		if(SINGLETON==null){
			SINGLETON=new SingletonLazyMode();
		}
		return SINGLETON;
	}

	public void sayHello() {
		System.out.println("I am SingletonLazy!");
		
	}

}

测试用例：

package com.designpatterns.singleton;


public class Main {

	public static void main(String[] args) {
		SingletonHungryMode singletonHungry = SingletonHungryMode.getSingleton();
		SingletonLazyMode singletonLazy = SingletonLazyMode.getSingleton();
		singletonHungry.sayHello();
		singletonLazy.sayHello();

	}

}

但是上面的例子中，饿汉模式是线程安全的，懒汉模式是非线程安全的。

从实现方式来讲他们最大的区别就是懒汉式是延时加载。它是在需要的时候才创建对象,而饿汉式在虚拟机启动的时候就会创建。

如果想实现懒汉模式的线程安全，那么就可以：

方法一：使用synchronized关键字修饰，代码如下：

package com.designpatterns.singleton;

public class SingletonMultiThread{
	private static SingletonMultiThread SINGLETON = null;

	private SingletonMultiThread() {
		
	}
	
	public synchronized static SingletonMultiThread getSingleton(){
		if(SINGLETON==null){
			SINGLETON=new SingletonMultiThread();
		}
		return SINGLETON;
	}

	public void sayHello() {
		System.out.println("I am SingletonLazy!");
		
	}
}

可以通过加同步来解决，只是加上同步效率会稍低，这时候可以使用:

方法二：双重判断来解决这个低效的问题 ，代码如下：

package com.designpatterns.singleton;

public class SingletonMultiThread2{
	private static SingletonMultiThread2 SINGLETON = null;

	private SingletonMultiThread2() {
		
	}
	
	public static SingletonMultiThread2 getSingleton(){
		if(SINGLETON==null){
			
			//加同步的时候使用的锁是 该类所属的字节码文件对象 
			synchronized(SingletonMultiThread2.class){
				if(SINGLETON==null){
					SINGLETON=new SingletonMultiThread2();
				}
			}
		}
		return SINGLETON;
	}

	public void sayHello() {
		System.out.println("I am SingletonLazy!");
		
	}
}

测试代码如下：

package com.designpatterns.singleton;

import java.util.HashSet;
import java.util.Set;

public class MainMT {

	public static class runable implements Runnable{
		public Set<SingletonMultiThread> multiThreads = new HashSet<>();
		public Set<SingletonMultiThread2> multiThreads2 = new HashSet<>();
		public Set<SingletonLazyMode> LazyModes = new HashSet<>();
		
		
		@Override
		public void run() {
			SingletonMultiThread singletonMultiThread = SingletonMultiThread.getSingleton();
			SingletonMultiThread2 singletonMultiThread2 = SingletonMultiThread2.getSingleton();
			SingletonLazyMode singletonLazy = SingletonLazyMode.getSingleton();
			
			multiThreads.add(singletonMultiThread);
			multiThreads2.add(singletonMultiThread2);
			LazyModes.add(singletonLazy);
		}
		
	}
	public static void main(String[] args) {
		runable run = new runable();
		for (int i = 0; i < 1000; i++) {
			new Thread(run).start();
		}
		System.out.println("i am LazyMode"+run.LazyModes);
		System.out.println("i am multiThreads"+run.multiThreads);
		System.out.println("i am multiThreads2"+run.multiThreads2);
	}
}

测试结果如下：

i am LazyMode[com.designpatterns.singleton.SingletonLazyMode@1bf3d87, com.designpatterns.singleton.SingletonLazyMode@60991f]
i am multiThreads[com.designpatterns.singleton.SingletonMultiThread@11671b2]
i am multiThreads2[com.designpatterns.singleton.SingletonMultiThread2@12452e8]

这就是单例模式。