Design pattern ——singleton pattern(单例基础)

Talk is cheap  Show me the code

个人学习笔记--仅供参考

饿汉式 1

package pattern;

/**
 * 懒汉式，类被加载的时候，就生成相应对象
 * 这种方式会造成资源浪费，
 * Spring 中IOC 容器ApplicationContext 本身就是典型的饿汉式单例
 * @author qsnp236
 *
 */
public class HungarySingleton {
	/**
	 * 私有构造方法，不允许外部
	 */
	private HungarySingleton() {
	}

	/**
	 * 生成对象
	 */
	private final static HungarySingleton obj = new HungarySingleton();

	/**
	 * 提供外部访问
	 * 
	 * @return
	 */
	public final static HungarySingleton getInstance() {
		return obj;
	}
}

饿汉式2

package pattern;

/**
 * 懒汉式，类被加载的时候，就生成相应对象
 * 这种方式会造成资源浪费，
 * Spring 中IOC 容器ApplicationContext 本身就是典型的饿汉式单例
 * @author qsnp236
 *
 */
public class HungarySingleton2 {
	private final static HungarySingleton2 obj;
	/**
	 * 私有构造方法，不允许外部
	 */
	private HungarySingleton2() {
	}
	/**
	 *  静态代码块生成对象
	 */
	static {

		obj = new HungarySingleton2();
	}
	

	/**
	 * 提供外部访问
	 * 
	 * @return
	 */
	public final static HungarySingleton2 getInstance() {

		return obj;
	}
}

懒汉式1

package pattern;
/**
 * 懒汉式  ，在外部调用getInstance的时候，判断对象是不是空，为空就去床架一个，返回，
 * 这种方式在getInstance 时，如果有多个同时调用，会产生两个对象，可以加锁
 * @author qsnp236
 *
 */
public class LazySingleton {
    /**
     * 内部初始化函数
     */
	private LazySingleton() {}
	/**
	 * 构造一个空的对象
	 */
	private static LazySingleton obj=null;
	/**
	 * 提供外部访问
	 * @return
	 */
	public  final static LazySingleton getInstance() {
		//判断是空的时候调用
		 if(obj==null) {
			 obj=new LazySingleton();
		 }
		 return obj;
	}
}

懒汉式2

package pattern;
/**
 * 懒汉式  ，在外部调用getInstance的时候，判断对象是不是空，为空就去床架一个，返回，
 * 这种方式在getInstance 时，如果有多个同时调用，会产生两个对象，可以加锁、
 * 这个是加锁的方式
 * @author qsnp236
 *
 */
public class LazySingletonLock1 {
    /**
     * 内部初始化函数
     */
	private LazySingletonLock1() {}
	/**
	 * 构造一个空的对象
	 */
	private static LazySingletonLock1 obj=null;
	/**
	 * 提供外部访问,加锁
	 * @return
	 */
	public final static synchronized LazySingletonLock1 getInstance() {
		//判断是空的时候调用
		 if(obj==null) {
			 obj=new LazySingletonLock1();
		 }
		 return obj;
	}
}

懒汉式3

package pattern;
/**
 * 懒汉式  ，在外部调用getInstance的时候，判断对象是不是空，为空就去床架一个，返回，
 * 这种方式在getInstance 时，如果有多个同时调用，会产生两个对象，可以加锁、
 * 这个加双重锁的方式
 * @author qsnp236
 *
 */
public class LazySingletonLock2 {
    /**
     * 内部初始化函数
     */
	private LazySingletonLock2() {}
	/**
	 * 构造一个空的对象
	 */
	private volatile static LazySingletonLock2 obj=null;
	/**
	 * 提供外部访问,加锁
	 * @return
	 */
	public static  LazySingletonLock2 getInstance() {
		//判断是空的时候调用
		 synchronized (LazySingletonLock2.class) {
		 if(obj==null) {
			
				 obj=new LazySingletonLock2();
			
		 }
		 }
		 return obj;
	}
}

懒汉式3 

package pattern;
/**
 * 懒汉式  ，在外部调用getInstance的时候，判断对象是不是空，为空就去床架一个，返回，
 * 这种方式在getInstance 时，如果有多个同时调用，会产生两个对象，可以加锁、
 * 这个是加锁的方式
 * @author qsnp236
 *
 */
public class LazySingletonDoubleLock {
    /**
     * 内部初始化函数
     */
	private LazySingletonDoubleLock() {}
	/**
	 * 构造一个空的对象
	 */
	private static volatile LazySingletonDoubleLock obj=null;
	/**
	 * 提供外部访问,加锁
	 * @return
	 */
	public final static  LazySingletonDoubleLock getInstance() {
		//判断是空的时候调用
		 synchronized (LazySingletonDoubleLock.class) {
		 if(obj==null) {
			
				 obj=new LazySingletonDoubleLock();
			}
			
		 }
		 return obj;
	}
}

优化版

package pattern;
/**
 * 懒汉式  ，在外部调用getInstance的时候，判断对象是不是空，为空就去床架一个，返回，
 * 这种方式在getInstance 时，如果有多个同时调用，会产生两个对象，
 * 这个是利用内部类
 * @author qsnp236
 *
 */
public  class LazySingletonInnerClass {
    /**
     * 内部初始化函数
     */
	private LazySingletonInnerClass() {}

	/**
	 * 提供外部访问
	 * @return
	 */
	public static final LazySingletonInnerClass getInstance() {
		
		 return InnerClass.innerObj;
	}

	
	
	private static class InnerClass{
		
		public static final LazySingletonInnerClass innerObj =new LazySingletonInnerClass();
	
	}
}

看代码，看注释