设计模式之单例模式

单例模式

1. singleton pattern，采取一定的方法，保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法)；
2. 确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例
3. 单例模式的优点
   1. 单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建，销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显；
   2. 减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取资源，产生其他依赖对象时，可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决
   3. 避免对资源的多重占用
   4. 在系统设置全局的访问点，优化和共享资源访问
4. 缺点
   1. 一般没有接口，扩展困难
   2. 对测试不利
   3. 与单一职责原则冲突
5. 单例模式的使用场景
   需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多（重量级对象），但又经常使用的对象，工具类对象，频繁访问数据库或文件的对象（比如数据源，session工厂等);
6. 单例模式在jdk中的应用
   1. java.lang.Runtime就是经典的单例模式（饿汉式）
   2. 在Spring框架中，每个Bean默认是单例的，这样的优点是Spring容器可以管理这些bean的生命周期，决定什么时候创建，什么时候销毁，销毁时如何处理等

单例模式的八种实现

• 饿汉式（静态变量）

//饿汉式（静态变量）
class Singleton{
	//1.私有化构造方法
	private Singleton() {
		
	}
	//2.实例化一个静态对象
	private static Singleton instance = new Singleton();
	//3.返回实例化对象
	public static Singleton getInstance() {
		return instance;
	}
}

优缺点

1. 优点：写法简单，就是在类装载的时候就完成实例化，避免了线程同步问题
2. 缺点：在类装载的时候就完成实例化，没有达到懒加载的效果，若没有在整个过程中没有使用这个实例，造成内存的浪费
3. 基于classloader机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中多数是调用getInstance方法，但是导致类装载的原因很多，不能确定有其他方式（或者其他的静态方法）导致类加载，这时初始化instance就没有达到lazy loading的效果
4. 这种单例模式可以使用，但是可能造成内存浪费

• 饿汉式（静态代码块）

//饿汉式（静态块）
class Singleton2{
	//1.私有化构造方法
	private Singleton2() {
		
	}
	//2.实例化一个静态对象
	private static final Singleton2 instance;
	//在静态代码块中创建单例对象；
	static {
		instance = new Singleton2();
	}
	//3.返回实例化对象
	public static Singleton2 getInstance() {
		return instance;
	}
}

1. 优缺点
   1. 和上面的方式相似，只不过类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例
   2. 优点：代码简单
   3. 缺点：容易造成内存的浪费
2. 这种单例模式可以使用，但是可能造成内存浪费

• 懒汉式（线程不安全）

class Singleton3{
	private Singleton3() {
		
	}
	
	private static Singleton3 instance;
	
	public static Singleton3 getInstance() {
		if(instance == null) {
			instance = new Singleton3();
		}
		return instance;
	}
}

1. 优缺点
   1. 起到了懒加载的效果，但是只能在单线程下使用
   2. 如果在多线程下，一个线程进入了if(singleton==null)判断语句块，还未来得及往下执行，另一个线程也通过这个判断语句，这时就会产生多个实例，在多线程下不能使用这种
2. 在实际开发中，不使用这种方式

• 懒汉式（线程安全，同步方法）

class Singleton4{
	private static Singleton4 instance;
	
	private Singleton4() {}
	
	//提供一个静态的公有方法,加入同步处理的代码，解决线程安全问题
	//即懒汉式；
	public static synchronized Singleton4 getInstance() {
		if(instance==null) {
			instance=new Singleton4();
		}
		return instance;
	}
}

1. 优缺点
   1. 解决了线程安全的问题
   2. 效率低，每个线程在想获得类的实例的时候，执行getInstance()方法都要进行同步，其实这个方法只执行一次实例化代码即可，后面想获得类实例，直接return即可，方法进行同步效率低
2. 实际开发中，不建议使用

• 懒汉式（同步代码块）

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

1. 和上面一个相似
2. 不建议使用

• 懒汉式（DoubleCheck双重检查）

class Singleton6{ 
	
	private static volatile Singleton6 instance;
	
	private Singleton6() {}
	
	//提供一个静态的公有方法，加入双重检查方法，解决线程安全问题，同时解决懒加载问题
	
	public static synchronized Singleton6 getInstance() {
		if(instance==null) {
			synchronized(Singleton6.class) {
				if(instance==null) {
					instance=new Singleton6();
				}
			}
			
		}
		return instance;
	}
}

1. 优缺点
   1. 是多线程开发中经常使用的，进行两次if（singleton==null）检查，保证线程安全
   2. 实例化代码只执行了一次，避免了反复的方法同步
2. 在开发中，推荐使用这种方式

• 静态内部类

class Singleton7{
	
	private Singleton7() {}
	
	private static class SingletonInstance{
		private static final Singleton7 INSTANCE=new Singleton7();
	}
	//提供一个静态的公有方法,直接返回SingletonInstance.INSTANCE;
	public static  Singleton7 getInstance() {
		return SingletonInstance.INSTANCE;
		
	}
}

1. 优缺点
   1. 采用了类装载的机制来保证初始化实例时只有一个线程
   2. 静态内部类方式在Singleton类被装载时并不会立即被实例化，而是在需要实例化时，调用getInstance方法， 才会装载SingletonInstance类，从而完成Singleton的实例化
   3. 类的静态属性只会在第一次加载时初始化，所以在这里，jvm帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的
   4. 避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
2. 推荐使用

• 枚举实现

public class SingleTonTest8 {
	
	//懒汉式，线程安全；
	//测试
	public static void main(String[] args) {
		Singleton8 s1=Singleton8.INSTANCE;
		Singleton8 s2=Singleton8.INSTANCE;
		System.out.println(s1==s2);
		System.out.println(s1.hashCode());
		System.out.println(s2.hashCode());
	}
}
enum Singleton8{
	INSTANCE ;
	public void sayOk() {
		System.out.println("ok----");
	}
}

1. 优缺点
   1. 借助jdk1.5中添加的枚举实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象
2. 推荐使用