单实例 多实例 有什么区别？他们的运行原理是什么？ 单例和多例的区别

单例和多例的区别

原网址出自：http://www.cnblogs.com/zhangliang88/p/5388472.html

单例模式：http://cantellow.iteye.com/blog/838473

 

单例多例需要搞明白两个问题：
1. 什么是单例多例；
2. 如何产生单例多例；
3. 为什么要用单例多例
4. 什么时候用单例，什么时候用多例；

1. 什么是单例、多例:
所谓单例就是所有的请求都用一个对象来处理，比如我们常用的service和dao层的对象通常都是单例的，而多例则指每个请求用一个新的对象来处理，比如action; 

一、单例模式和多例模式说明：

1.单例模式和多例模式属于对象模式。

2.单例模式的对象在整个系统中只有一份，多例模式可以有多个实例。

3.它们都不对外提供构造方法，即构造方法都为私有。

二、应用举例

1.单例模式举例:

第一种：懒汉式(线程不安全，加上synchronized后线程安全)

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

第二种：饿汉式(线程安全)

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

 这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

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

表面上看起来差别挺大，其实差不多，都是在类初始化即实例化instance。

第三种：静态内部类

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

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟饿汉式不同的是（很细微的差别）：饿汉式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比饿汉式就显得很合理。

第四种：枚举

public enum Singleton {
    INSTANCE;
    public void whateverMethod() { } }

这种方式是Java作者提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，我也很少看见有人这么写过。

public enum EnumTest {
    MON, TUE, WED, THU, FRI, SAT, SUN;
}

public class Test{ public static void main(String[] args) { for (EnumTest e : EnumTest.values()) { System.out.println(e.toString()); } System.out.println("----------------我是分隔线------------------"); EnumTest test = EnumTest.MON; switch (test) { case MON: System.out.println("今天是星期一"); break; case TUE: System.out.println("今天是星期二"); break; // ... ... default: System.out.println(test); break; } } }

打印结果

MON

TUE

WED

THU

FRI

SAT

SUN

----------------我是分隔线------------------

今天是星期一

 

第五种：双重校验锁

public class Singleton {
    private volatile static Singleton singleton; private Singleton (){} public static Singleton getSingleton() { if (singleton == null) { synchronized (Singleton.class) { if (singleton == null) { singleton = new Singleton(); } } } return singleton; } }

 这个是第一种方式的升级版，俗称双重检查锁定。在JDK1.5之后，双重检查锁定才能够正常达到单例效果。

2. 多例模式举例:

import java.text.*;
import java.util.*;
class NumberFormatTest { public static void displayNumber(Double d,Locale l) { NumberFormat nf; String dOut; nf = NumberFormat.getNumberInstance(l); dOut = nf.format(d); System.out.println(dOut + " " + l.toString()); } public static void main(String[] args) { displayNumber(1234567.89,new Locale("en","US")); displayNumber(1234567.89,new Locale("de","DE")); displayNumber(1234567.89,new Locale("fr","FR")); displayNumber(1234567.89,new Locale("zh","CN")); } }

一个根据语言代码和地区代码格式化数字的多例模式例子

 

2. 如何产生单例、多例:
  在通用的SSH中，单例在spring中是默认的，如果要产生多例，则在配置文件的bean中添加scope="prototype"; 

我就告诉你昨天我得问题你估计就明白了

我没用scope="prototype"就出现上面得验证问题了 连续点提交就这样
我添加后 不论怎么点都只会出现一个验证提示
3. 为什么用单例、多例：
   之所以用单例，是因为没必要每个请求都新建一个对象，这样子既浪费CPU又浪费内存；
   之所以用多例，是为了防止并发问题；即一个请求改变了对象的状态，此时对象又处理另一个请求，而之前请求对对象状态的改变导致了对象对另一个请求做了错误的处理；
   用单例和多例的标准只有一个：
   当对象含有可改变的状态时（更精确的说就是在实际应用中该状态会改变），则多例，否则单例；
4. 何时用单例？何时用多例？
  对于struts2来说，action必须用多例，因为action本身含有请求参数的值，即可改变的状态；
  而对于STRUTS1来说，action则可用单例，因为请求参数的值是放在actionForm中，而非action中的；
  另外要说一下，并不是说service或dao一定是单例，标准同第3点所讲的，就曾见过有的service中也包含了可改变的状态，同时执行方法也依赖该状态，但一样用的单例，这样就会出现隐藏的BUG,而并发的BUG通常很难重现和查找；

原网址出自：http://www.cnblogs.com/zhangliang88/p/5388472.html

单例模式：http://cantellow.iteye.com/blog/838473

 

单例多例需要搞明白两个问题：
1. 什么是单例多例；
2. 如何产生单例多例；
3. 为什么要用单例多例
4. 什么时候用单例，什么时候用多例；

1. 什么是单例、多例:
所谓单例就是所有的请求都用一个对象来处理，比如我们常用的service和dao层的对象通常都是单例的，而多例则指每个请求用一个新的对象来处理，比如action; 

一、单例模式和多例模式说明：

1.单例模式和多例模式属于对象模式。

2.单例模式的对象在整个系统中只有一份，多例模式可以有多个实例。

3.它们都不对外提供构造方法，即构造方法都为私有。

二、应用举例

1.单例模式举例:

第一种：懒汉式(线程不安全，加上synchronized后线程安全)

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

第二种：饿汉式(线程安全)

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

 这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

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

表面上看起来差别挺大，其实差不多，都是在类初始化即实例化instance。

第三种：静态内部类

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

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟饿汉式不同的是（很细微的差别）：饿汉式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比饿汉式就显得很合理。

第四种：枚举

public enum Singleton {
    INSTANCE;
    public void whateverMethod() { } }

这种方式是Java作者提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，我也很少看见有人这么写过。

public enum EnumTest {
    MON, TUE, WED, THU, FRI, SAT, SUN;
}

public class Test{ public static void main(String[] args) { for (EnumTest e : EnumTest.values()) { System.out.println(e.toString()); } System.out.println("----------------我是分隔线------------------"); EnumTest test = EnumTest.MON; switch (test) { case MON: System.out.println("今天是星期一"); break; case TUE: System.out.println("今天是星期二"); break; // ... ... default: System.out.println(test); break; } } }

打印结果

MON

TUE

WED

THU

FRI

SAT

SUN

----------------我是分隔线------------------

今天是星期一

 

第五种：双重校验锁

public class Singleton {
    private volatile static Singleton singleton; private Singleton (){} public static Singleton getSingleton() { if (singleton == null) { synchronized (Singleton.class) { if (singleton == null) { singleton = new Singleton(); } } } return singleton; } }

 这个是第一种方式的升级版，俗称双重检查锁定。在JDK1.5之后，双重检查锁定才能够正常达到单例效果。

2. 多例模式举例:

import java.text.*;
import java.util.*;
class NumberFormatTest { public static void displayNumber(Double d,Locale l) { NumberFormat nf; String dOut; nf = NumberFormat.getNumberInstance(l); dOut = nf.format(d); System.out.println(dOut + " " + l.toString()); } public static void main(String[] args) { displayNumber(1234567.89,new Locale("en","US")); displayNumber(1234567.89,new Locale("de","DE")); displayNumber(1234567.89,new Locale("fr","FR")); displayNumber(1234567.89,new Locale("zh","CN")); } }

一个根据语言代码和地区代码格式化数字的多例模式例子

 

2. 如何产生单例、多例:
  在通用的SSH中，单例在spring中是默认的，如果要产生多例，则在配置文件的bean中添加scope="prototype"; 

我就告诉你昨天我得问题你估计就明白了

我没用scope="prototype"就出现上面得验证问题了 连续点提交就这样
我添加后 不论怎么点都只会出现一个验证提示
3. 为什么用单例、多例：
   之所以用单例，是因为没必要每个请求都新建一个对象，这样子既浪费CPU又浪费内存；
   之所以用多例，是为了防止并发问题；即一个请求改变了对象的状态，此时对象又处理另一个请求，而之前请求对对象状态的改变导致了对象对另一个请求做了错误的处理；
   用单例和多例的标准只有一个：
   当对象含有可改变的状态时（更精确的说就是在实际应用中该状态会改变），则多例，否则单例；
4. 何时用单例？何时用多例？
  对于struts2来说，action必须用多例，因为action本身含有请求参数的值，即可改变的状态；
  而对于STRUTS1来说，action则可用单例，因为请求参数的值是放在actionForm中，而非action中的；
  另外要说一下，并不是说service或dao一定是单例，标准同第3点所讲的，就曾见过有的service中也包含了可改变的状态，同时执行方法也依赖该状态，但一样用的单例，这样就会出现隐藏的BUG,而并发的BUG通常很难重现和查找；

单例多例需要搞明白两个问题：
1. 什么是单例多例；
2. 如何产生单例多例；
3. 为什么要用单例多例
4. 什么时候用单例，什么时候用多例；

1. 什么是单例、多例:
所谓单例就是所有的请求都用一个对象来处理，比如我们常用的service和dao层的对象通常都是单例的，而多例则指每个请求用一个新的对象来处理，比如action; 

一、单例模式和多例模式说明：

1.单例模式和多例模式属于对象模式。

2.单例模式的对象在整个系统中只有一份，多例模式可以有多个实例。

3.它们都不对外提供构造方法，即构造方法都为私有。

二、应用举例

1.单例模式举例:

第一种：懒汉式(线程不安全，加上synchronized后线程安全)

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

第二种：饿汉式(线程安全)

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

 这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

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

表面上看起来差别挺大，其实差不多，都是在类初始化即实例化instance。

第三种：静态内部类

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

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟饿汉式不同的是（很细微的差别）：饿汉式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比饿汉式就显得很合理。

第四种：枚举

public enum Singleton {
    INSTANCE;
    public void whateverMethod() { } }

这种方式是Java作者提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，我也很少看见有人这么写过。

public enum EnumTest {
    MON, TUE, WED, THU, FRI, SAT, SUN;
}

public class Test{ public static void main(String[] args) { for (EnumTest e : EnumTest.values()) { System.out.println(e.toString()); } System.out.println("----------------我是分隔线------------------"); EnumTest test = EnumTest.MON; switch (test) { case MON: System.out.println("今天是星期一"); break; case TUE: System.out.println("今天是星期二"); break; // ... ... default: System.out.println(test); break; } } }

打印结果

MON

TUE

WED

THU

FRI

SAT

SUN

----------------我是分隔线------------------

今天是星期一

 

第五种：双重校验锁

public class Singleton {
    private volatile static Singleton singleton; private Singleton (){} public static Singleton getSingleton() { if (singleton == null) { synchronized (Singleton.class) { if (singleton == null) { singleton = new Singleton(); } } } return singleton; } }

 这个是第一种方式的升级版，俗称双重检查锁定。在JDK1.5之后，双重检查锁定才能够正常达到单例效果。

2. 多例模式举例:

import java.text.*;
import java.util.*;
class NumberFormatTest { public static void displayNumber(Double d,Locale l) { NumberFormat nf; String dOut; nf = NumberFormat.getNumberInstance(l); dOut = nf.format(d); System.out.println(dOut + " " + l.toString()); } public static void main(String[] args) { displayNumber(1234567.89,new Locale("en","US")); displayNumber(1234567.89,new Locale("de","DE")); displayNumber(1234567.89,new Locale("fr","FR")); displayNumber(1234567.89,new Locale("zh","CN")); } }

一个根据语言代码和地区代码格式化数字的多例模式例子

 

2. 如何产生单例、多例:
  在通用的SSH中，单例在spring中是默认的，如果要产生多例，则在配置文件的bean中添加scope="prototype"; 

我就告诉你昨天我得问题你估计就明白了

我没用scope="prototype"就出现上面得验证问题了 连续点提交就这样
我添加后 不论怎么点都只会出现一个验证提示
3. 为什么用单例、多例：
   之所以用单例，是因为没必要每个请求都新建一个对象，这样子既浪费CPU又浪费内存；
   之所以用多例，是为了防止并发问题；即一个请求改变了对象的状态，此时对象又处理另一个请求，而之前请求对对象状态的改变导致了对象对另一个请求做了错误的处理；
   用单例和多例的标准只有一个：
   当对象含有可改变的状态时（更精确的说就是在实际应用中该状态会改变），则多例，否则单例；
4. 何时用单例？何时用多例？
  对于struts2来说，action必须用多例，因为action本身含有请求参数的值，即可改变的状态；
  而对于STRUTS1来说，action则可用单例，因为请求参数的值是放在actionForm中，而非action中的；
  另外要说一下，并不是说service或dao一定是单例，标准同第3点所讲的，就曾见过有的service中也包含了可改变的状态，同时执行方法也依赖该状态，但一样用的单例，这样就会出现隐藏的BUG,而并发的BUG通常很难重现和查找；