设计模式学习笔记（15）——单例模式的实现

一、单例模式
单例模式，保证一个类仅有一个实例，并提供一个访问它的全局访问点。通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。

package operation;

class Singleton{
	private static Singleton instance;
	private Singleton() {
//构造方法为private,这就堵死了外界利用new创建此类的可能
	}
	public static Singleton GetInstance() {
//此方法是获得本类实例的唯一全局访问点
		if(instance==null) {
//如果实例不存在则new一个新实例，否则返回已有的实例
			instance=new Singleton();
		}
		return instance;
	}
}
public class Main{
	public static void main(String[] args){
		Singleton s1=Singleton.GetInstance();
		Singleton s2=Singleton.GetInstance();
		if(s1==s2) 
//比较两次实例化后对象的结果是实例相同
			System.out.println("两个对象是相同的实例");
		
	}
}

二、多线程时的单例

package operation;

class Singleton{
	private static Singleton instance;
	private static final Object syncRoot=new Object();
	public static Singleton getInstance() {
		synchronized(syncRoot)
		{
			if(instance==null)
			{
				instance=new Singleton();
			}
			System.out.println("singleton创建");
			return instance;
		}
	}
}
public class Main{
	public static void main(String[] args){
		Singleton s1=Singleton.getInstance();
		Singleton s2=Singleton.getInstance();
		if(s1==s2)
		{
			System.out.println("该对象的字符串表示形式：");
		   System.out.println("s1:"+s1.toString());
		   System.out.println("s2:"+s2.toString());
		}
	}
}

三、双重锁定

class SingletonDCL{
	private volatile static SingletonDCL singleton;
	private SingletonDCL() {}
	public static SingletonDCL getInstance() {
		
		if(singleton==null) {
			synchronized(SingletonDCL.class) {
				if(singleton==null) {
					singleton=new SingletonDCL();
				}
			}
		}
		System.out.println("singleton创建");
		return singleton;
	}
}
public class Main{
	public static void main(String[] args){
		SingletonDCL s1=SingletonDCL.getInstance();
		SingletonDCL s2=SingletonDCL.getInstance();
		System.out.println("singleton1==singleton2?"+(s1==s2));
			System.out.println("该对象的字符串表示形式：");
		   System.out.println("s1:"+s1.toString());
		   System.out.println("s2:"+s2.toString());
	}
}

四、单例模式的两种：懒汉模式和饿汉模式
1.懒汉式单例模式(时间换空间)
在第一次被引用时才会将自己实例化，所以就被称为懒汉式单例类。

class Singleton{
	private static Singleton instance;
	private Singleton() {}
	public static Singleton getInstance() {
		//此方法是获得本类实例的唯一全局访问点
		if(instance==null) {//给类加锁，类的所有对象用同一把锁
			instance=new Singleton();
			}
		return instance;
	}
}

2.饿汉式单例模式(空间换时间)
只能在静态初始化期间或在类构造函数中分配变量，这种静态初始化的方式是在自己被加载时就将自己实例化，所以被形象地称之为饿汉式单例类。

class Singleton{
	private static Singleton instance=new Singleton();
	//static修饰的方法，在类加载的时候被创建，后期不会再改变，所以是线程安全的。
	private Singleton() {}
	public static Singleton getInstance() {
		return instance;
	}
}

3。饿汉-懒汉单例模式的主要区别:
懒汉式，会面临着多线程访问的安全性问题，需要做双重锁定处理才可以保证安全。
饿汉式，即静态初始化的方式，它是类一加载就实例化的对象，所以要提前占用系统资源。