设计模式——单例模式

设计模式——单例模式

概念

基本介绍
所谓单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)；

八种写法的单例模式

• 饿汉式(静态常量)
• 饿汉式(静态代码块)
• 懒汉式(线程不安全)
• 懒汉式(线程安全，同步方法)
• 懒汉式(线程安全，改进第四种方式)
• 双重检查
• 静态内部类
• 枚举

细节和注意事项

• 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能；
• 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new；
• 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)；

饿汉式(静态常量)

即在类中直接创建静态的成员，然后通过某个方法让外部能够获得这个静态成员，如下编码；

public class Type1Test {

	public static void main(String[] args) {
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		
		System.out.println("instance1的hashCode = " + instance1.hashCode() + "; instance2的hashCode = " + instance2.hashCode());
		System.out.println("instance1和instance2是否是同一个对象：" + (instance1 == instance2));
		
	}
}

class Singleton {
	// 1、私有化构造器
	private Singleton() {}
	
	// 2、类的内部创建对象
	private static final Singleton instance = new Singleton();
	
	// 3、向外提供一个静态的公共方法来获取instance实例对象
	public static Singleton getInstance() {
		return instance;
	}
	
}

优缺点分析：

• 这种方式写法简单，就是在类装载的时候去完成实例化，避免了线程同步问题，是线程安全的；
• 在类装载的时候就完成实例化，没有达到懒加载的效果，如果从始至终都未使用这个实例，则会造成内存的浪费；
• 这种方式基于classLoader机制避免了多线程的同步问题，不过instance在类装载时就实例化了，在单例模式中 大多数都是调用getInstance()方法，此时导致类装载的原因有很多，因此不能确定有其他的方式(或者其他的静态方 法)导致类装载，这时候初始化instance就没有达到懒加载的效果；
• 这种方式实现的单例模式可用，但是可能造成内存的浪费；

饿汉式(静态代码块)

将上述的对象实例化的过程放在静态代码块中执行；

public class Type2Test {
	public static void main(String[] args) {
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		
		System.out.println("instance1的hashCode = " + instance1.hashCode() + "; instance2的hashCode = " + instance2.hashCode());
		System.out.println("instance1和instance2是否是同一个对象：" + (instance1 == instance2));
		
	}
}

class Singleton {
	
	// 1、私有化构造器
	private Singleton() {}
	
	private static Singleton instance;
	// 2、静态代码块
	static {
		instance = new Singleton();
	}
	
	// 3、对外提供一个静态的公共方法来获取instance实例对象
	public static Singleton getInstance() {
		return instance;
	}
	
}

优缺点分析：

• 种方法和上面的方法其实类似，只不过将类实例化的过程放到了静态代码块中，也是在类装载的时候就执行静态代码块中的代码，初始化类的实例，优点和缺点与方式一模一样；
• 这种方式实现的单例模式可用，但是可能造成内存浪费；

懒汉式(线程不安全)

public class Type3Test {
	public static void main(String[] args) {
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		
		System.out.println("instance1的hashCode = " + instance1.hashCode() + "; instance2的hashCode = " + instance2.hashCode());
		System.out.println("instance1和instance2是否是同一个对象：" + (instance1 == instance2));
		
	}
}

class Singleton {
	
	private static Singleton instance;
	
	// 1、私有化构造器
	private Singleton() {}
	
	// 2、对外提供一个静态的公共方法来获取instance实例对象
	public static Singleton getInstance() {
		if(instance == null) {
			instance = new Singleton();
		}
		return instance;
	}

}

优缺点分析：

• 起到了懒加载的效果，但是只能在单线程下使用(线程不安全)；
• 如果在多线程下，一个线程进入if(instance == null)判断语句，可能还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例，所以在多线程环境下不可以使用这种方式；
• 在实际开发中，不要使用这种方式实现单例模式；

懒汉式(线程安全，同步方法)

public class Type4Test {
	public static void main(String[] args) {
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		
		System.out.println("instance1的hashCode = " + instance1.hashCode() + "; instance2的hashCode = " + instance2.hashCode());
		System.out.println("instance1和instance2是否是同一个对象：" + (instance1 == instance2));
		
	}
}

class Singleton {
	
	private static Singleton instance;
	
	// 1、私有化构造器
	private Singleton() {}
	
	// 2、对外提供一个静态的公共方法来获取instance实例对象
	public static synchronized Singleton getInstance() {
		if(instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
}

优缺点分析：

• 解决了线程不安全问题；
• 效率太低了，每个线程在想获取类的实例时，执行getInstance()方法都要进行同步，而其实这个方法只要执行一次实例化代码就够了，后面的想获得这个类的实例，直接return就行，但是使用此方式时是方法体全部同步的，效率太低了；
• 在实际开发中，不推荐使用这种方式实现单例模式；

懒汉式(线程安全，改进第四种方式)，注意该方式改进是失败的

public class Type5Test {
	public static void main(String[] args) {
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		
		System.out.println("instance1的hashCode = " + instance1.hashCode() + "; instance2的hashCode = " + instance2.hashCode());
		System.out.println("instance1和instance2是否是同一个对象：" + (instance1 == instance2));
		
	}
}

class Singleton {
	
	private static Singleton instance;
	
	// 1、私有化构造器
	private Singleton() {}
	
	// 2、对外提供一个静态的公共方法来获取instance实例对象
	public static Singleton getInstance() {
		if(instance == null) {
			synchronized(Singleton.class) {
				instance = new Singleton();
			}
		}
		return instance;
	}
	
}

优缺点分析：

• 这种方式本意是想对第四种方式进行改进，因为前者的效率太低了；
• 但是仔细分析发现该方式并不能实现同步的作用，因为当多个线程进入if(instance == null)中，此时synchronized(){}只能让这些线程一个一个的创建实例instance，此时会产生多个instance实例；
• 在实际开发中，不能使用这种方式实现单例模式；

双重检查方式

public class Type6Test {
	public static void main(String[] args) {
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		
		System.out.println("instance1的hashCode = " + instance1.hashCode() + "; instance2的hashCode = " + instance2.hashCode());
		System.out.println("instance1和instance2是否是同一个对象：" + (instance1 == instance2));
		
	}
}

class Singleton {
	
	private static volatile Singleton instance; // volatile修饰这个变量表示：当这个变量发生变化，值立刻会刷入主存中，在一定程度上达到同步的效果
	
	// 1、私有化构造器
	private Singleton() {}
	
	// 2、对外提供一个静态的公共方法来获取instance实例对象
	public static Singleton getInstance() {
		if(instance == null) {
			synchronized(Singleton.class) {
				if(instance == null) {
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
	
}

优缺点分析：

• 双重检查(Double Check)是多线程开发中常使用到的；如下面的代码所示使用两次if(instance == null)检查，保证线程更加安全，这样实例化代码只用执行一次， 在首次执行这个方法，即使外部的if(instance == null)进入多个线程，其内部还会有一个if(instance == null)保证只能出现一个instance，不会创建多个instance；后面再次访问时，会通过外层的if(instance == null)后，直接return出instance，避免了执行同步的代码块synchronized(Singleton.class)的执行，极大的提高了检查效率；
• 此方式实现的单例模式线程安全、能延迟加载、效率较高；
• 在实际开发中，推荐使用这种方式实现单例模式；

静态内部类方式

public class Type7Test {
	public static void main(String[] args) {
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		
		System.out.println("instance1的hashCode = " + instance1.hashCode() + "; instance2的hashCode = " + instance2.hashCode());
		System.out.println("instance1和instance2是否是同一个对象：" + (instance1 == instance2));
		
	}
}

/*
 * 须知：
 * 	静态内部类的特点：
 * 		1、当主类进行类装载时，静态内部类不会被装载；
 * 		2、当主类调用静态内部类的静态变量时，会导致静态内部类装载；
 * 
 */
class Singleton {
	
	// 1、私有化构造器
	private Singleton() {}
	
	// 2、创建静态内部类，并在其内部实例化一个Singleton的实例
	private static class SingletonInstance {
		private static final Singleton INSTANCE = new Singleton();
	}
	
	// 3、对外提供一个静态的公共方法来获取instance实例对象
	public static Singleton getInstance() {
		return SingletonInstance.INSTANCE;
	}
	
}

优缺点分析：

• 这种方式采用了类加载的机制来保证初始化实例时只有一个线程(线程安全)；
• 如下代码，静态内部类方式在Singleton类加载时并不会立即实例化，而是在需要实例化时，调用getInstance()方法才会导致SingletonInstance类装载，从而完成对Singleton的实例化；
• 类的静态属性只会在第一次加载类的时侯初始化，所以在这里JVM帮助我们保证了线程的安全性，在类进行初始化时别的线程是无法进入的；
• 避免了线程不安全，利用静态内部类特点实现延迟加载，效率高；
• 在实际开发中，推荐使用这种方式实现单例模式；

枚举的方式

public class Type8Test {
	public static void main(String[] args) {
		Singleton instance1 = Singleton.INSTANCE;
		Singleton instance2 = Singleton.INSTANCE;
		
		System.out.println("instance1的hashCode = " + instance1.hashCode() + "; instance2的hashCode = " + instance2.hashCode());
		System.out.println("instance1和instance2是否是同一个对象：" + (instance1 == instance2));
		
		instance1.method1();
		instance2.method1();
	}
}

enum Singleton {
	INSTANCE;
	public void method1() {
		System.out.println("方法method1执行了...");
	}
}

优缺点分析：

• 借助JDK1.5中新增的枚举类来实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象；
• 在实际开发中，推荐使用这种方式实现单例模式；