单例模式

<pre name="code" class="java">//单例中的饿汉式实现,不管你需不需要这个对象,在类加载的时候就会创建,不存在线程安全的问题
public class Singleton implements Cloneable
{
	private static Singleton singleton = new Singleton();
	private Singleton(){};//私有化构造方法,保证该类实例的唯一性
	
	public static Singleton getInstance()
	{
		return singleton;
	}
	
	public static void main(String[] args)
	{
		Singleton singleton = Singleton.getInstance();
		try
		{
			Singleton clone = (Singleton) singleton.clone();
			System.out.print(clone.equals(singleton));
		} catch (CloneNotSupportedException e)
		{
			e.printStackTrace();
		}
	}
}
//懒汉式实现,在需要的时候才会创建该对象,下面的实现方法在多线程的时候不能保证对象的唯一性
class LazySingleton
{
	private static LazySingleton lazySingleton = null;
	public static LazySingleton getInstance()
	{
		if(lazySingleton == null)
		{
			lazySingleton = new  LazySingleton();
		}
		return lazySingleton;
	}
}

//懒汉式实现,在需要的时候才会创建该对象,下面的实现方法在多线程的时候虽然能够保证对象的唯一性,但是锁的粒度过大,影响性能
class LazySingleton1
{
	private static LazySingleton1 lazySingleton = null;
	public static synchronized LazySingleton1 getInstance()
	{
		if(lazySingleton == null)
		{
			lazySingleton = new  LazySingleton1();
		}
		return lazySingleton;
	}
}

//懒汉式实现,在需要的时候才会创建该对象,下面的实现方法在多线程的时候虽然能够保证对象的唯一性,上面的锁是加在方法上的,其实主要锁住new对象的那一条语句就行了
//双重检查同步锁
class LazySingleton2
{
	private static LazySingleton2 lazySingleton = null;
	public static LazySingleton2 getInstance()
	{
		if(lazySingleton == null)
		{
			synchronized (LazySingleton2.class)
			{
				/*
				 * 这里的检查是因为,当第一次执行并且有多个线程的并发,第一个线程会创建一个新的对象,完成之后释放锁,第二个现场继续执行
				 * 如果不加入该判断,第二个线程也会创建一个新的线程,这样就不能保证对象的唯一性
				 */
				if(lazySingleton == null)
					lazySingleton = new  LazySingleton2();
			}
		}
		return lazySingleton;
	}
}