单例模式

 

单例模式是一种模式（貌似是废话），其实想说的是既然是模式。那么实现方式也有很多种。并不是那种实现方式错误。而是每种实现方式都有他特定的场景。

 

下面直接来代码：

 

public class Singleton1
{
	// 私有的默认构造子
	private Singleton1()
	{
	}
	// 已经自行实例化
	private static final Singleton1 INSTANCE = new Singleton1();

	// 静态工厂方法
	public static Singleton1 getInstance()
	{
		return INSTANCE;
	}
}

 

上面是一个饿汉式单例。为什么叫饿汉式呢？因为他在类的初始化时候就要实例INSTANCE(注意：类的初始化)。他的缺点是首先在使用该类的时候就生成了对象：1：它占用了空间，因为可能一直不会用到他的实例，但是他已经new了一个对象。2：需要生成的对象需要一些配置参数，这样的话就无法按此种方法来生成对象。

所以就出现了下面的几种方法：

 

 

public class Singleton2
{
	// 私有的默认构造子
	private Singleton2()
	{
	}
	//可配置参数
	private Singleton2(String str)
	{
	}

	// 注意，这里没有final
	private static  Singleton2 single = null;

	// 静态工厂方法
	public synchronized static Singleton2 getInstance(String str)
	{
		if (single == null)
		{
			single = new Singleton2(str);
		}
		return single;
	}
	

}

上面这种方法解决了第一种方法的问题，但是当并发量比较多的话，效率还能怎么提高：

 

 

public class Singleton4
{
	private static Singleton4 instance = null;

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

}

 

package com.singleton.single;

public class Singleton5
{
	private static volatile Singleton5 instance = null;

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

以上是2的两种优化，但是4的优化效率并不高，5中有两个if判断是不是看的也有点烦人。。哈哈

 

 

 

public class Singleton6
{

	private static class SingletonHolder
	{
		/**
		 * 单例对象实例
		 */
		static final Singleton6 INSTANCE = new Singleton6();
	}

	public static Singleton6 getInstance()
	{
		return SingletonHolder.INSTANCE;
	}
}

上面这种是比较推荐的一种，代码比较简单（虽然用到了内部类），效率应该也不低吧。。

 

 

 

import java.util.HashMap;
import java.util.Map;
//登记式单例类.
//类似Spring里面的方法，将类名注册，下次从里面直接获取。

public class Singleton3
{
	private static Map<String, Singleton3> map = new HashMap<String, Singleton3>();
	static
	{
		Singleton3 single = new Singleton3();
		map.put(single.getClass().getName(), single);
	}

	// 保护的默认构造子
	protected Singleton3()
	{
	}

	// 静态工厂方法,返还此类惟一的实例
	public static Singleton3 getInstance(String name)
	{
		if (name == null)
		{
			name = Singleton3.class.getName();
			System.out.println("name == null" + "--->name=" + name);
		}
		if (map.get(name) == null)
		{
			try
			{
				map.put(name, (Singleton3) Class.forName(name).newInstance());
			} catch (InstantiationException e)
			{
				e.printStackTrace();
			} catch (IllegalAccessException e)
			{
				e.printStackTrace();
			} catch (ClassNotFoundException e)
			{
				e.printStackTrace();
			}
		}
		return map.get(name);
	}

	// 一个示意性的方法
	public String doSomething()
	{
		return "Hello, I am singleton3,i doSomething..";
	}

	public static void main(String[] args)
	{
		Singleton3 single3 = Singleton3.getInstance(null);
		System.out.println(single3.doSomething());
	}
}

上面登记式这种单例类当然也是一种方法了。。