何为单例设计，这种模式在现实开发中，用的多不多啊？

-单例设计模式：解决以来在内存中只存在一个对象。
想要保证对象的唯一，需要确保：
为了避免其他程序过多建立该类的对象，先要禁止其他程序建立该类的对象；
还为了让其他程序可以访问到该类的对象，只好在本类中自定义一个对象；
为了方便其他程序对自定义对象的访问，可以对外提供一些访问的方式；

用代码体现需要三步：
将构造函数私有化；
在类中创建一个本类的(私有的)对象；
提供一个方法可以获取到对象。

--对于事物该怎么描述，还怎么描述。
当需要将该事物的对象保证在内存中唯一时，就将三步加上即可。

饿汉式：
----就是正常操作上面三步；（当类加载时，堆内存就创建对象了，即先初始化）

懒汉式：
----当类变量等于null ，而不等于new的对象时，再定义获取对象的方法的时候，需要在其内判断类变量是否为null ，如果为 null 需要new一个对象赋值给类变量；（当类加载时，堆内存中没对象，只有使用到了创建对象的函数时才在堆内存创建对象）

一般开发时用饿汉式，因为比较安全，多人操作时不会出现问题；
如果需要使用懒汉式，即需要对其进行同步，而同步的效率就会变慢，所以就需要进行双重现在来提高使用效率。

单例设计模式：
1.1.饿汉式

1. public class Singleton1 {
   
2. 
   
3.         //饿汉式,线程安全的
   
4.         private static final Singleton1 instance = new Singleton1();
   
5.         //构造方法私有化
   
6.         private Singleton1(){}
   
7.         //获得对象
   
8.         public static Singleton1 getInstance(){
   
9.                 return instance;
   
10.         }
    
11. }

复制代码

2.懒汉式：

1. public class Singleton2 {
   
2. 
   
3.         //懒汉式,线程不安全的
   
4.         private static  Singleton2 instance ;
   
5.         //构造方法私有化
   
6.         private Singleton2(){}
   
7.         //获得对象
   
8.         public static Singleton2 getInstance(){
   
9.                 if(instance == null){
   
10.                         synchronized (Singleton2.class) {
    
11.                                 instance = new Singleton2();
    
12.                         }
    
13.                 }
    
14.                 return instance;
    
15.         }
    
16. }

复制代码

3，使用java5新特性枚举实现单例设计模式

1. public enum Singleton {
   
2.         INSTANCE;
   
3. }

复制代码

对于楼上的懒汉模式。当有两个线程同时创建实例时，一个线程获得锁对象，另一个处于等待状态，当第一个
创建完实例后，第二个还会进入 synchronized，再次创建实例，所有还有在synchronized代码块里再次经行判断。修改代码为：

1. public class Singleton2 {
   
2. 
   
3.         //懒汉式,线程不安全的
   
4.         private static  Singleton2 instance ;
   
5.         //构造方法私有化
   
6.         private Singleton2(){}
   
7.         //获得对象
   
8.         public static Singleton2 getInstance(){
   
9.                 if(instance == null){
   
10.                         synchronized (Singleton2.class) {
    
11.                                  if(instance == null){
    
12.                                 instance = new Singleton2();
    
13.                                  }
    
14.                         }
    
15.                 }
    
16.                 return instance;
    
17.         }
    
18. }

复制代码

java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。

单例模式有一下特点：

1、单例类只能有一个实例。　

2、单例类必须自己自己创建自己的唯一实例。　　

3、单例类必须给所有其他对象提供这一实例。
单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。选择单例模式就是为了避免不一致状态，避免政出多头。

1.饿汉式单例类

1 //饿汉式单例类.在类初始化时，已经自行实例化  2 public class Singleton1 {

3     //私有的默认构造子 4     private Singleton1() {}

5     //已经自行实例化  6     private static final Singleton1 single = new Singleton1();

7     //静态工厂方法  8     public static Singleton1 getInstance() {

9         return single;

10     }

11 }

2.懒汉式单例类

1 //懒汉式单例类.在第一次调用的时候实例化  2 public class Singleton2 {
3     //私有的默认构造子 4     private Singleton2() {}
5     //注意，这里没有final     6     private static Singleton2 single=null;
7     //静态工厂方法  8     public synchronized  static Singleton2 getInstance() {
9          if (single == null) {
10              single = new Singleton2();
11          }
12         return single;
13     }
14 }

3.登记式单例类

1 import java.util.HashMap;

2 import java.util.Map;

3 //登记式单例类.

4 //类似Spring里面的方法，将类名注册，下次从里面直接获取。 5 public class Singleton3 {

6     private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();

7     static{

8         Singleton3 single = new Singleton3();

9         map.put(single.getClass().getName(), single);

10     }

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

13     //静态工厂方法,返还此类惟一的实例14     public static Singleton3 getInstance(String name) {

15         if(name == null) {

16             name = Singleton3.class.getName();

17             System.out.println("name == null"+"--->name="+name);

18         }

19         if(map.get(name) == null) {

20             try {

21                 map.put(name, (Singleton3) Class.forName(name).newInstance());

22             } catch (InstantiationException e) {

23                 e.printStackTrace();

24             } catch (IllegalAccessException e) {

25                 e.printStackTrace();

26             } catch (ClassNotFoundException e) {

27                 e.printStackTrace();

28             }

29         }

30         return map.get(name);

31     }

32     //一个示意性的商业方法33     public String about() {   

34         return "Hello, I am RegSingleton.";   

35     }   

36     public static void main(String[] args) {

37         Singleton3 single3 = Singleton3.getInstance(null);

38         System.out.println(single3.about());

39     }

40 }

菜不鸟 发表于 2013-12-27 11:32
java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。单例模 ...

版主，csdn:'(

菜不鸟 发表于 2013-12-27 22:13
版主，csdn

{:soso_e149:}

速度跟上节拍。。