设计模式之单例模式

单例模式

单例模式的定义为：一个类有且仅有一个实例，并且提供一个访问该实例的全局访问入口。

如何保证一个类只有一个实例对象：

1、将构造方法私有化（不能让外部随便就能创建对象）

2、自己创建对象（不能让别人创建，那就只能自己创建对象）

3、提供一个公共的获取对象的方法（全局访问入口）

饿汉式单例

饿汉式单例就是在类加载的时候就直接创建一个对象，而不管实际是否需要。

优点： 线程安全，因为类加载的时候已经创建了对象，所以调用的时候速度快。

缺点： 资源效率不高，不管用不用都创建，浪费内存空间。

public class SingletonHungry {

	// 1、在单例类的内部直接创建对象
	private static final SingletonHungry instance = new SingletonHungry();

	// 2、讲构造方法私有化
	private SingletonHungry() {
	};

	// 3、提供一个公有的构造方法，对外提供实例对象
	public static SingletonHungry getInstance() {
		return instance;
	}

}

另一种写法：

public class SingletonHungry {

	// 1、在单例类的内部直接创建对象
	private static final SingletonHungry instance;

	static {
		instance = new SingletonHungry();
	}

	// 2、构造方法私有化
	private SingletonHungry() {
	};

	// 3、提供一个公有的构造方法，对外提供实例对象
	public static SingletonHungry getInstance() {
		return instance;
	}

}

两种写法其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。

懒汉式单例

懒汉式单例就是在程序需要该对象的时候才实例化对象，实现懒加载。

public class SingletonLazy {

	// 1、在第一次调用的时候实例化自己
	private static SingletonLazy instance = null;

	// 2、将构造方法私有化
	private SingletonLazy() {
	};

	// 3、提供一个公有的获取实例对象的方法
	public static SingletonLazy getInstance() {
		// 判断是否存在该类的实例对象，不存在则创建
		if (instance == null) {
			instance = new SingletonLazy();
		}
		return instance;
	}
}

缺点：该单例虽然实现了延迟加载，但它是线程不安全的，并发环境下有可能有多个实例对象。

要实现线程安全，可以通过改造getInstance方法实现线程安全。

方法一：在getInstance()方法上加同步

public class SingletonLazy1 {

	private static SingletonLazy1 instance = null;

	private SingletonLazy1() {
	};
    
	public static synchronized SingletonLazy1 getInstance() {
		if (instance == null) {
			instance = new SingletonLazy1();
		}
		return instance;
	}

}

方法二：双重检查锁

在getInstance()方法中做两次null检查，这样不是任何时候都加锁，只有创建对象的时候才加锁，避免了每次都同步的性能损耗

public class SingletonLazy2 {
	
    //volatile关键字
	private static volatile SingletonLazy2 instance = null;

	private SingletonLazy2() {
	};

	public static SingletonLazy2 getInstance() {
        //不是任何时候都加锁，只有创建对象的时候才加锁
		if (instance == null) {
			synchronized (SingletonLazy2.class) {
				if (instance == null) {
					instance = new SingletonLazy2();
				}
			}

		}
		return instance;
	}

}

volatile关键字的作用：防止JVM指令重排优化，保证变量在多线程运行时的可见性

方法三：静态内部类

利用类的加载机制，他在内部类中去创建对象实例。这样的话只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会去创建单例对象，从而实现了懒汉式的延迟加载。

public class SingletonLazy3 {

	private static class LazyHolder {
		private static final SingletonLazy3 instance = new SingletonLazy3();
	}

	private SingletonLazy3() {
	};

	public static SingletonLazy3 getInstance() {
		return LazyHolder.instance;
	}
}

静态内部类和非静态内部类一样，不会因为外部类的加载而加载，只是在第一次使用的时候才加载，属于懒加载。