单例模式

单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

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

1、Singleton类，定义一个getInstance操作，允许客户访问它的唯一实例。

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

2、客户端程序

public class Client
{
public static void main(String[] args)
{
	Singleton s1=Singleton.getInstance();
	Singleton s2=Singleton.getInstance();
	if(s1==s2)
	{
		System.out.println("两个对象是相同的实例");
	}
}
}

3、多线程实例

public class ThreadSingleton
{
private static ThreadSingleton instance;
private  static Object syncRoot=new Object();
private ThreadSingleton()
{
	
}
public static ThreadSingleton getInstance()
{
	synchronized (syncRoot)
	{
		if(instance==null)
		{
			instance=new ThreadSingleton();
		}
	}
	return instance;
}
}

4、多线程双重锁定

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

5、静态内部类 优点：加载时不会初始化静态变量INSTANCE，因为没有主动使用，达到Lazy loading

public class Singleton1
{
private static class SingletonHolder
{
	private final static Singleton1 instance=new Singleton1();
}
private Singleton1(){}
public static Singleton1 getInstance()
{
	return SingletonHolder.instance;
}
}

6、枚举类型 《Effective Java》作者推荐使用的方法，优点：不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象

public enum EnumSingleton
{
	Instance;
	public void doSomething()
	{
	}
}

使用方法：EnumSingleton instance=EnumSingleton.Instance;

注释：enum是枚举类型，每个枚举类型的成员其实就是一个实例。当定义一个枚举类型后，在编译时就能确定该枚举类型有几个实例，在运行期间我们无法使用该枚举类型创建实例了。