设计模式学习之单例模式

单例模式：简单说就是一个类只能被实例化出一个对象。

单例模式主要有两种写法：

1、饿汉式：类加载时就进行对象的实例化，写法如下：

public class SingleTon {
    private static SingleTon instance = new SingleTon();

    // 构造方法私有，确保外界无法直接实例化，不能被外界继承
    private SingleTon() {

    }
    //通过该方法获得实例
    private static SingleTon getInstance(){
        return instance;
    }
    
}

2、懒汉式：第一次应用时进行对象的实例化，写法如下：

public class SingleTon {
    private static SingleTon instance = null;

    // 构造方法私有，确保外界无法直接实例化，不能被外界继承
    private SingleTon() {

    }

    /**
     * 对静态方法getInstance()进行同步，以确保多线程环境下只创建一个实例。
     * 如果没有同步，线程A和线程B同时调用该方法时，if(instance==null)判断都为真，
     * 线程A和B会各创建一个对象，在内存中就会有两个对象存在，这就违背了单例模式。
     */
    synchronized public static SingleTon getInstance(){
        if(instance==null){
            instance=new SingleTon();
        }
        return instance;
    }
    
}

以上的懒汉式写法虽然通过同步锁保证了线程安全，但是粒度比较大，只需要锁住其中的new Singleton()即可，即只需要针对一些重要的代码进行同步即可，其他的代码不需要同步，这样在运行时效率会有很大的提升，优化的代码如下：

public class SingleTon {
	private static SingleTon instance = null;

	// 构造方法私有，确保外界无法直接实例化，不能被外界继承
	private SingleTon() {

	}
	public static SingleTon getInstance() {
		if (instance == null) {
			synchronized (SingleTon.class) {
				if (instance == null)
					instance = new SingleTon();
			}
		}
		return instance;
	}
}

下面通过一个多线程的实例来验证，实例摘自《设计模式》

先创建一个饿汉式单例类，getNum()用于返回访问次数，并且对该方法进行同布，代码如下

public class GlobalNum {
	private static GlobalNum gn = new GlobalNum();
	private int num=0;
	// 构造方法私有，确保外界无法直接实例化
	private GlobalNum() {

	}
	//通过该方法获得实例
	public static GlobalNum getInstance(){
		return gn;
	}
	public synchronized int getNum(){
		return ++num;
	}
}

在Mian主程序中创建两个线程A，B，通过两个线程演示对实例进行访问，由于对象是单例的，所以能够统一的统计访问次数，代码如下：

public class Demo {
	public static void main(String[] args) {
		NumThread a=new NumThread("A");
		NumThread b=new NumThread("B");
		a.start();
		b.start();
	}
}

//线程类
public class NumThread extends Thread {
	private String threadName;

	public NumThread(String name) {
		threadName = name;
	}
   //重写Run方法
	public void run() {
		GlobalNum gn = GlobalNum.getInstance();
		for(int i=0;i<=5;i++){
			System.out.println(threadName+"第"+gn.getNum()+"次访问");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

根据输出可以看到达到了预期的结果。

另外在《Java多线程编程艺术》这本书中，也讲到了使用静态内置类，序列化与反序列化，及使用static代码块，enum枚举实现单例模式的方式，接下来一起去看看：

1、通过静态内置类实现单例模式，代码如下：

public class MyObject_static {
	//内部类
	private static class MyObjectHandler{
		private static MyObject_static instance = new MyObject_static();
	}

	private MyObject_static() {

	}
	static MyObject_static getInstance(){
		return MyObjectHandler.instance;
	}
}

创建一个线程类用于测试

public class MyThread extends Thread{

	@Override
	public void run() {
		System.out.println(MyObject_static.getInstance().hashCode());
		
	}
}

//创建主程序，实例化两个线程
public class Main {
	public static void main(String[] args) {
		MyThread a=new MyThread();
		MyThread b=new MyThread();
		a.start();
		b.start();
	}
}
运行结果：
1251387847
1251387847

以上运行结果显示两个线程打印的哈希一致，即两个线程只创建了一个实例。

2、通过static代码块实现单例模式，代码如下：

public class MyObject_static {

	private static MyObject_static instance = null;

	static {
		instance = new MyObject_static();
	}

	private MyObject_static() {

	}

	static MyObject_static getInstance() {
		return instance;
	}
}
//运行以上多线程测试实例结果如下：
1326320603
1326320603

结论同上。
3、通过序列化和反序列化实现单例模式，单例模式如果实现了序列化接口，则可以通过反射和反序列化破坏原有的结构，反序列化保证单例的核心是调用readResolve（）方法，readResolve（）基于回调的，反序列化时，如果定义了readResolve()则直接返回此方法指定的对象，而不需要在创建新的对象，代码如下：

public class MyObject_Serlizable implements Serializable {

	private static final long seriaVersionUID = 789L;

	// 内部类
	private static class MyObjectHandler {
		private static final MyObject_Serlizable instance = new MyObject_Serlizable();
	}

	private MyObject_Serlizable() {

	}

	static MyObject_Serlizable getInstance() {
		return MyObjectHandler.instance;
	}

	protected Object readResolve() {
		System.out.println("调用了readResolve()");
		return MyObjectHandler.instance;

	}
}

定义一个测试类如下：

public class ObjectWriteRead {
	public static String path="F:\\a.txt";    

	public static void main(String[] args) throws IOException {
		MyObject_Serlizable myObject = MyObject_Serlizable.getInstance();
		File file = new File(path);
		try (FileOutputStream fot = new FileOutputStream(file); ObjectOutputStream ott = new ObjectOutputStream(fot);) {
			ott.writeObject(myObject);
			System.out.println(myObject.hashCode());
		} catch (Exception e) {
			e.printStackTrace();
		}
		try (FileInputStream fit = new FileInputStream(file); ObjectInputStream ot = new ObjectInputStream(fit);) {
			MyObject_Serlizable myObjectinput = (MyObject_Serlizable) ot.readObject();
			System.out.println(myObjectinput.hashCode());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

注释方法readResolve()以后打印结果为：

118352462
1550089733

不注释方法readResolve()以后打印结果为：

118352462
调用了readResolve()
118352462
通过对比可知道，在不调用readResolve() 方法的前提下，序列化会破坏单例模式，但是通过回调readResolve()方法，可以保证之创建一个实例。

4、通过枚举实现单例模式，代码如下：

public enum EnumSingleton {
	    INSTANCE;
	public EnumSingleton getInstance() {
		return INSTANCE;
	}
}

测试代码如下：

public class MyThread extends Thread{

	@Override
	public void run() {
		System.out.println(EnumSingleton.INSTANCE.hashCode());
		
	}
}


public class Main {
	public static void main(String[] args) {
		MyThread a=new MyThread();
		MyThread b=new MyThread();
		a.start();
		b.start();
	}
}

//打印结果
94165517
94165517

可以发现通过枚举实现单例代码时最简单的，枚举类要求构造方法必须是私有的，这与单例模式不谋而合。

参考资料：

[1] 韩敬海主编  设计模式:Java版本     出版社：电子工业出版社   出版时间：2012-01   ISBN：9787121155826

[2]高洪岩   Java多线程编程核心技术  出版社：机械工业出版社   出版时间：2015-06   ISBN：9787111502067