java关于单例模式的一些疑问？

    小弟最近想学习java的设计模式，就从单例模式来学起吧。大家知道在java语言中,可以利用static 关键字来构建单例模式，主要是因为static 这个关键字在所在的类在被java虚拟机装载的时候，变量是最先被装载（如果有多个，那么按照从上往下的顺序执行的），并且是全局共享的。

    因此：按照这个理解：我写了一个单例模式。代码如下：

    public class Test{
    private static Test test=null;
    public static Test getInstence(){

                 if(test==null)
                {
                     test=mew Test();
                }
                  return test;

      }
   }

       在这个方法里，我申明了一个private static类型的成员变量，然后申明了一个static类型的方法，判断test如果是null，则实例化，然后返回Test类的一个实例。应为static类型的变量是全局共享的，所以，一旦test被实例化，那么则被存放到java虚拟机的堆中，全局共享，以后不会在实例化。直到类的生命周期结束然后才会被销毁。在别的类要引用的时候，只需要Test.getInstence()就可以获得一个实例。这就是我理解的单利模式。

 

    但我在网上看了另一种写法，说要有一个私有的构造函数，代码是这样的。

  
  public class Test{
      private Test(){}

      private static Test test=new Test();

      public static Test getInstence(){ 
  
         return test;
      

       }
  }

我是这样理解这个类的：

 1    private static Test test=new Test();在jvm 装载这个类的时候会初始化这个声明，Test类的实例test已经被实例化。并且全局共享。

 2     public static Test getInstence(){ 
  
         return test;
      

       }

  static的方法getInstence用来返回Test 类的实例。这个实例就是上面已经实例化的那个（唯一的一个）

 问题一：问题是私有的构造函数，我不明白为什么一定要有个私有的构造函数？大家帮  忙看看！

 问题二：在开发单例模式中有那些是需要注意的地方？比如构造方法之类的要注意什 么？

 问题三：单利模式有几种形式？能不能给个例子？听说有懒汉式什么的？

问题四：什么时候需要用到单例模式？

      请大家不宁赐教！多谢！我的邮箱[e-mail] ，可以发邮件给我！

 

 

评论

39 楼 chenhua_1984 2009-04-27  

lkjust08 写道

一般Singleton模式通常有几种形式:

public class Singleton {

　　private Singleton(){}

　　//在自己内部定义自己一个实例，是不是很奇怪？
　　//注意这是private 只供内部调用

　　private static Singleton instance = new Singleton();

　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}




第二种形式:

public class Singleton {
　　private static Singleton instance = null;

　　public static synchronized Singleton getInstance() {

　　if (instance==null)
　　　　instance＝new Singleton();
　　return instance; 　　}

}




使用Singleton.getInstance()可以访问单态类。

上面第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。

注意到lazy initialization形式中的synchronized，这个synchronized很重要，如果没有synchronized，那么使用getInstance()是有可能得到多个Singleton实例。关于lazy initialization的Singleton有很多涉及double-checked locking (DCL)的讨论，有兴趣者进一步研究。

一般认为第一种形式要更加安全些。

多谢！明白了

38 楼 lkjust08 2009-04-27  

一般Singleton模式通常有几种形式:

public class Singleton {

　　private Singleton(){}

　　//在自己内部定义自己一个实例，是不是很奇怪？
　　//注意这是private 只供内部调用

　　private static Singleton instance = new Singleton();

　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}




第二种形式:

public class Singleton {
　　private static Singleton instance = null;

　　public static synchronized Singleton getInstance() {

　　if (instance==null)
　　　　instance＝new Singleton();
　　return instance; 　　}

}




使用Singleton.getInstance()可以访问单态类。

上面第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。

注意到lazy initialization形式中的synchronized，这个synchronized很重要，如果没有synchronized，那么使用getInstance()是有可能得到多个Singleton实例。关于lazy initialization的Singleton有很多涉及double-checked locking (DCL)的讨论，有兴趣者进一步研究。

一般认为第一种形式要更加安全些。

37 楼 sunnymoon 2009-04-25  

kulinglei 写道

sunnymoon 写道

longrui 写道

chenhua_1984 写道

1构造函数有什么样的要求？
2这里的线程安全问题是怎么回事？

1.私有构造行数是禁止通过实例该类获得对象，如：

new Test().getInstence();

2.线程安全是指如果有多个线程，在第一个线程还没有执行到new Test()的时候，第二个线程调用该方法时判断test仍然为null，所以仍然会执行new Test()。
所以一般使用synchronized关键字将该方法声明成同步方法，如：

public static synchronized Test getInstence

线程安全是指多个线程访问一个资源时（这里指对象），不会发生冲突，保证同一时间只有一个线程访问该资源。
单例中的类只实例化一次,new Test()不会多次执行，每次线程访问时得到同一个实例。这里说的有点问题。

多个线程同时操作一个单例，不就不安全了吗？？？

no

36 楼 kulinglei 2009-04-24  

youthon 写道

有人根据创建的时间把单例模式分为懒汉式和饿汉式
懒汉式是指在调用的时候才创建，就像你前面的代码所做的，优点是只有用到了才会占用资源
饿汉式是在初始化就创建了这个对象，优点是预先加载，在调用时省去了创建（还有可能加载配置数据）的时间

饿汉式:在类加载时static{}.静态块中

35 楼 youthon 2009-04-24  

有人根据创建的时间把单例模式分为懒汉式和饿汉式
懒汉式是指在调用的时候才创建，就像你前面的代码所做的，优点是只有用到了才会占用资源
饿汉式是在初始化就创建了这个对象，优点是预先加载，在调用时省去了创建（还有可能加载配置数据）的时间

34 楼 kulinglei 2009-04-24  

sunnymoon 写道

longrui 写道

chenhua_1984 写道

1构造函数有什么样的要求？
2这里的线程安全问题是怎么回事？

1.私有构造行数是禁止通过实例该类获得对象，如：

new Test().getInstence();

2.线程安全是指如果有多个线程，在第一个线程还没有执行到new Test()的时候，第二个线程调用该方法时判断test仍然为null，所以仍然会执行new Test()。
所以一般使用synchronized关键字将该方法声明成同步方法，如：

public static synchronized Test getInstence

线程安全是指多个线程访问一个资源时（这里指对象），不会发生冲突，保证同一时间只有一个线程访问该资源。
单例中的类只实例化一次,new Test()不会多次执行，每次线程访问时得到同一个实例。这里说的有点问题。

多个线程同时操作一个单例，不就不安全了吗？？？

33 楼 sunnymoon 2009-04-24  

longrui 写道

chenhua_1984 写道

1构造函数有什么样的要求？
2这里的线程安全问题是怎么回事？

1.私有构造行数是禁止通过实例该类获得对象，如：

new Test().getInstence();

2.线程安全是指如果有多个线程，在第一个线程还没有执行到new Test()的时候，第二个线程调用该方法时判断test仍然为null，所以仍然会执行new Test()。
所以一般使用synchronized关键字将该方法声明成同步方法，如：

public static synchronized Test getInstence

线程安全是指多个线程访问一个资源时（这里指对象），不会发生冲突，保证同一时间只有一个线程访问该资源。
单例中的类只实例化一次,new Test()不会多次执行，每次线程访问时得到同一个实例。这里说的有点问题。

32 楼 kulinglei 2009-04-23  

构造方法私，是防止在其他类中new对象，但你的属性是static的，所以即使在其他类中new了n个对象，但他们的属性是共享的，所以要考虑安全问题，你可以加个类锁，这样数据就安全了，所以私有的构造方法不是必须的，

31 楼 C_J 2009-04-22  

引用

单例首要的条件就是线程安全,所以不会有线程公享资源的事情,何来资源一说?要是有资源公享的话,那还是单例吗?

是的，但我的理解“共享”是“所有线程共享了进程的资源”，而这里的单例实例就是其中的一部分。

  而“共享”并非“同时使用”吧~ 就像那位兄台说的“厕所”
  所以为了解决“同时使用”带来的问题，就得做好“线程安全”了。

30 楼 jansel 2009-04-22  

C_J 写道

tangshd 写道

本来不想注册 写道

Constructor的用法 和 static 的用法，如果不熟悉，可以用单例模式来加深对他们的理解。

单例模式的写法有很多吧，最简洁的才是最好的。

一个实例，虽然节约资源，缺点应该也很明显。就好比，厕所小便槽就一个，大家要排队等候。

兄台,您这个比喻好像不对吧..单例又不是单线程!

所有线程都共享一个资源

一个线程共享所有资源

要是“资源”是马桶，排队的就是“线程”。

兄台为什么认为那位兄台比喻不对呢？？

单例首要的条件就是线程安全,所以不会有线程公享资源的事情,何来资源一说?要是有资源公享的话,那还是单例吗?

29 楼 C_J 2009-04-22  

tangshd 写道

本来不想注册 写道

Constructor的用法 和 static 的用法，如果不熟悉，可以用单例模式来加深对他们的理解。

单例模式的写法有很多吧，最简洁的才是最好的。

一个实例，虽然节约资源，缺点应该也很明显。就好比，厕所小便槽就一个，大家要排队等候。

兄台,您这个比喻好像不对吧..单例又不是单线程!

所有线程都共享一个资源

一个线程共享所有资源

要是“资源”是马桶，排队的就是“线程”。

兄台为什么认为那位兄台比喻不对呢？？

28 楼 tangshd 2009-04-21  

本来不想注册 写道

Constructor的用法 和 static 的用法，如果不熟悉，可以用单例模式来加深对他们的理解。

单例模式的写法有很多吧，最简洁的才是最好的。

一个实例，虽然节约资源，缺点应该也很明显。就好比，厕所小便槽就一个，大家要排队等候。

兄台,您这个比喻好像不对吧..单例又不是单线程!

27 楼 akiraray 2009-04-18  

lucane 写道

看过这个一点点
Double-checked locking and the Singleton pattern
不过还是有点不明白

Out-of-order writes那段中

引用

public static Singleton getInstance()
{
  if (instance == null)
  {
    synchronized(Singleton.class) {  //1
      if (instance == null)          //2
        instance = new Singleton();  //3
    }
  }
  return instance;
}

3.Thread 1 proceeds to //3 and makes instance non-null, but before the constructor executes.

In my opinion,the instance should be null before the constructor executes.

I'm confused about that.

Thanks

双重check的好处就是

如果只是像平时一样 每次判断都要先进性同步操作 性能会降低
因为线程不安全的场景 只是在 第一次创建的时候发生

而double check
先判断是否 已经实例化了 如果实例化了直接跳过同步部分
如果没有实例化 那么就做一次同步--判断--初始化的动作
两者的差距其实就那行没有同步锁的判断，这样再实例化以后所有的getIntanse就不必都要走 同步锁--判断--解锁的这个很浪费性能的流程而已- -

26 楼 iaimstar 2009-04-17  

lucane 写道

看过这个一点点

3.Thread 1 proceeds to //3 and makes instance non-null, but before the constructor executes.

In my opinion,the instance should be null before the constructor executes.

I'm confused about that.

Thanks

先获得实例目的就是不做同步的额外处理，你不能保证取得对象实例的时候没有并发，这样会产生多个实例，而不是单例了，所以使用才生成需要同步，会增加额外的工作
提前获得实例的好处就是把实例化的工作交给系统来干，能保证不需要同步也能保证单例的成功

25 楼 tianlihu 2009-04-17  

一般认为在初始化时就指定好值是比较安全的，不能用时再初始化，虽然加上同步可以解决这个问题，但带来了额外的系统开销，不是好的解决方案

24 楼 lucane 2009-04-16  

看过这个一点点
Double-checked locking and the Singleton pattern
不过还是有点不明白

Out-of-order writes那段中

引用

public static Singleton getInstance()
{
  if (instance == null)
  {
    synchronized(Singleton.class) {  //1
      if (instance == null)          //2
        instance = new Singleton();  //3
    }
  }
  return instance;
}

3.Thread 1 proceeds to //3 and makes instance non-null, but before the constructor executes.

In my opinion,the instance should be null before the constructor executes.

I'm confused about that.

Thanks

23 楼 本来不想注册 2009-04-16  

Constructor的用法 和 static 的用法，如果不熟悉，可以用单例模式来加深对他们的理解。

单例模式的写法有很多吧，最简洁的才是最好的。

一个实例，虽然节约资源，缺点应该也很明显。就好比，厕所小便槽就一个，大家要排队等候。

22 楼 C_J 2009-04-14  

“2.采用Holder类，是为了得用jdk对static变量的定义来保证多线程安全。”

没明白用这里的private Holder类能保证线程安全，莫非不这样做JDK就不去控制线程安全了么？

21 楼 chenhua_1984 2009-04-14  

rrsy23 写道

单例 有没有想过用静态方法会怎么样？

用静态方法就是把方法声明成类的静态方法！在jvm装载这个类的时候会先转载它，并且全局共享。用类名.方法名（）来访问。不知道你这么说是什么用意？或则你是怎么想的？

20 楼 rrsy23 2009-04-13  

单例 有没有想过用静态方法会怎么样？