1.单例模式可分为有状态的和无状态的。

有状态的单例对象一般也是可变的单例对象，多个单态对象在一起就可以作为一个状态仓库一样向外提供服务。

没有状态的单例对象也就是不变单例对象，仅用做提供工具函数。

2.实现：

     饿汉式

      public class Singleton
      {
     	// 在自己内部定义自己一个实例
     	// 注意这是private 只供内部调用
     	private static Singleton instance = new Singleton();
     	// 如上面所述，将构造函数设置为私有
     	private Singleton()
      	{
      	}
     	// 静态工厂方法，提供了一个供外部访问得到对象的静态方法
     	public static Singleton getInstance()
      	{
     		return instance;
      	}
      }
  
 

 懒汉式

       public class Singleton
       {
      	// 和上面有什么不同？
      	private static Singleton instance = null;
      	// 设置为私有的构造函数
      	private Singleton()
       	{
       	}
      	// 静态工厂方法
      	public static synchronized Singleton getInstance()
       	{
      		// 这个方法比上面有所改进
      		if (instance == null)
       			instance = new Singleton();
      		return instance;
       	}
       }
   
  

将构造函数设置为受保护的，这样允许被继承产生子类。这种方式在具体实现上又有所不同，可以将父类中获得对象的静态方法放到子类中再实现；也可以在父类的静态方法中进行条件判断来决定获得哪一个对象；在GOF 中认为最好的一种方式是维护一张存有对象和对应名称的注册表（可以使用HashMap 来实现）。下面的实现参考《java 与模式》采用带有注册表的方式。

      package design.pattern.singleton;
      import java.util.HashMap;
      public class Singleton
      {
     	// 用来存放对应关系
     	private static HashMap sinRegistry = new HashMap();
     	static private Singleton s = new Singleton();
     	// 受保护的构造函数
     	protected Singleton()
      	{
      	}
     	public static Singleton getInstance(String name)
      	{
     		if (name == null)
      			name = "Singleton";
     		if (sinRegistry.get(name) == null)
      		{
     			try
      			{
      				sinRegistry.put(name, Class.forName(name).newInstance());
      			} catch (Exception e)
      			{
      				e.printStackTrace();
      			}
      		}
     		return (Singleton) (sinRegistry.get(name));
      	}
     	public void test()
      	{
      		System.out.println("get class success!");
      	}
      }
  
 

      package design.pattern.singleton;
      public class SingletonChild extends Singleton
      {
     	public SingletonChild()
      	{
      	}
     	static public SingletonChild getInstance()
      	{
     		return (SingletonChild) Singleton.getInstance("SingletonChild");
      	}
     	public void test()
      	{
      		System.out.println("get child class success !");
      	}
      }
  
 

缺陷：由于在 java 中子类的构造函数的范围不能比父类的小，所以可能存在不守规则的客户程序使用其构造函数来产生实例，造成单例模式失效。

什么时候使用单例模式呢？（例如，windows的垃圾回收站就是个单例模式）

1、创建大量的静态函数和静态方法时，可以采用单例模式替换之

2、多处共享一个访问点或者同一个共享数据时，例如web开发的计数器

单例模式邪恶论、

多个虚拟机

当系统中的单例类被拷贝运行在多个虚拟机下的时候，在每一个虚拟机下都可以创建一

个实例对象。在使用了EJB、JINI、RMI 技术的分布式系统中，由于中间件屏蔽掉了分布式

系统在物理上的差异，所以对你来说，想知道具体哪个虚拟机下运行着哪个单例对象是很困

难的。

因此，在使用以上分布技术的系统中，应该避免使用存在状态的单例模式，因为一个有

状态的单例类，在不同虚拟机上，各个单例对象保存的状态很可能是不一样的，问题也就随

之产生。而且在EJB 中不要使用单例模式来控制访问资源，因为这是由EJB 容器来负责的。

在其它的分布式系统中，当每一个虚拟机中的资源是不同的时候，可以考虑使用单例模式来

进行管理。

多个类加载器

当存在多个类加载器加载类的时候，即使它们加载的是相同包名，相同类名甚至每个字

节都完全相同的类，也会被区别对待的。因为不同的类加载器会使用不同的命名空间

（namespace）来区分同一个类。因此，单例类在多加载器的环境下会产生多个单例对象。

也许你认为出现多个类加载器的情况并不是很多。其实多个类加载器存在的情况并不少

见。在很多J2EE 服务器上允许存在多个servlet 引擎，而每个引擎是采用不同的类加载器的；

浏览器中applet 小程序通过网络加载类的时候，由于安全因素，采用的是特殊的类加载器，

等等。

这种情况下，由状态的单例模式也会给系统带来隐患。因此除非系统由协调机制，在一

般情况下不要使用存在状态的单例模式。

错误的同步处理

在使用上面介绍的懒汉式单例模式时，同步处理的恰当与否也是至关重要的。不然可能

会达不到得到单个对象的效果，还可能引发死锁等错误。因此在使用懒汉式单例模式时一定

要对同步有所了解。不过使用饿汉式单例模式就可以避免这个问题。

文章来源: panda1234lee.blog.csdn.net，作者：panda1234lee，版权归原作者所有，如需转载，请联系作者。

原文链接：panda1234lee.blog.csdn.net/article/details/9119373