学习单例模式

看了下单例模式，个人理解就是只能有一此实例化，这样对性能有一定提高。

下面说说学习小例子：

public class Singleton {
		private Singleton(){}
		private static Singleton instance = new Singleton();
		public static Singleton getInstance(){
			return instance;
		}
		public void sys(String s){
			System.out.println(s+"singleton.........");
		}
}

 

此类就是一个单例类，里面我写了一个方法

测试此类：

public class TestSingletion {

	public static void main(String args[]){

		Singleton.getInstance().sys("fdsfds");
	}
}

 

只能通过Singleton.getInstance()得到实例，调用类中方法。

这就是一个单例模式。

 

网上还有一种方法是：

public class Singleton { 
 private static Singleton instance = null;
 private Singleton(){
  //应该加上这个
 }
 public static synchronized Singleton getInstance(){
  if(instance==null){
    instance = new Singleton();
  }
  return instance;
 }
 public void sys(String s){
  System.out.println(s+"singleton.........");
 }
}

 网上说可以这样可以防止多个实例。

而我用测试类进行测试时，却可以实例化此类，不知道为何，谢谢能有人讨论下。

 

在各位的帮助下，我知道错了，谢谢

 

评论

35 楼 aishangtao 2009-01-01  

构造器一定要私有化。

34 楼 Burce Cai 2008-12-27  

个人对使用synchronized的看法是诚然他可能会减低你的程序性能，但使用不使用应该看你的软件的需要而定。软件开发受各种因素（安全、性能等）影响，有时候不能要了性能就丢了安全性，所以就解决方案来说没有最好，只有最适合。

话说回来，单件模式多数情况下解决的是控制一组共享资源的问题，在多线程对资源进行结构性修改的情况下要保证程序正常运行，急切模式是不错的，但有时候又偏偏不想或不能让类被过早的实例化，那使用延迟实例化或双重检验加锁模式也是可以考虑的。

33 楼 Burce Cai 2008-12-27  

第一个例子是急切模式，第二个是延迟实例化模式，还有一种双重检验加锁模式（对第二个的优化）
public class Singleton {//volatile在早前版本的实现中会导致双重检验加锁的
                        //失败，故请使用java 5及更新的版本
private volatile static Singleton uniqueInstance;
private Singleton(){}

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

32 楼 liouys 2008-12-20  

nairuo1988 写道

第一个是单线程下，在多线程下为防止并发访问导致实例化2个出来，要用第2个，更好的方法是：

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

双重检查加锁，只在第一次调用getInstance（）时才要同步，提高性能

我在《Head First设计模式》这本书上看到过这种。那上面写了三种。
１.如果getInstance()的性能对应用程序不是很关键，就什么都别做。
２.使用‘急切’创建实例，而不用延迟实例化的做法。
３.就是上面这种。用‘双重检查加锁’，在getInstance()中减少使用同步。

31 楼 yunhaifeiwu 2008-12-19  

xieke 写道

yunhaifeiwu 写道

nairuo1988 写道

第一个是单线程下，在多线程下为防止并发访问导致实例化2个出来，要用第2个，更好的方法是：

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

双重检查加锁，只在第一次调用getInstance（）时才要同步，提高性能

打板子!看我发的网址，有多线程下，大多数单例模式的应用进行了测试与介绍。如果有兴趣，自已照他的方法检查你的双重检查加锁吧！

你发的网址在那里?感觉她写的没问题啊

http://www.iteye.com/topic/60179

30 楼 xieke 2008-12-19  

yunhaifeiwu 写道

nairuo1988 写道

第一个是单线程下，在多线程下为防止并发访问导致实例化2个出来，要用第2个，更好的方法是：

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

双重检查加锁，只在第一次调用getInstance（）时才要同步，提高性能

打板子!看我发的网址，有多线程下，大多数单例模式的应用进行了测试与介绍。如果有兴趣，自已照他的方法检查你的双重检查加锁吧！

你发的网址在那里?感觉她写的没问题啊

29 楼 yunhaifeiwu 2008-12-09  

网上还有一种方法是：
Java代码
public class Singleton {  
private static Singleton instance = null; 
private Singleton(){ 
  //应该加上这个 
} 
public static synchronized Singleton getInstance(){ 
  if(instance==null){ 
    instance = new Singleton(); 
  } 
  return instance; 
} 
public void sys(String s){ 
  System.out.println(s+"singleton........."); 
} 
} 
网上说可以这样可以防止多个实例。
而我用测试类进行测试时，却可以实例化此类，不知道为何，谢谢能有人讨论下。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
正想说，才发现被人已经说了。楼主这里的构造函数没指出，在java中，缺省就意味着有一公有的构造函数。

28 楼 yunhaifeiwu 2008-12-08  

nairuo1988 写道

第一个是单线程下，在多线程下为防止并发访问导致实例化2个出来，要用第2个，更好的方法是：

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

双重检查加锁，只在第一次调用getInstance（）时才要同步，提高性能

打板子!看我发的网址，有多线程下，大多数单例模式的应用进行了测试与介绍。如果有兴趣，自已照他的方法检查你的双重检查加锁吧！

27 楼 nairuo1988 2008-12-08  

第一个是单线程下，在多线程下为防止并发访问导致实例化2个出来，要用第2个，更好的方法是：

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

双重检查加锁，只在第一次调用getInstance（）时才要同步，提高性能

26 楼 xiaofei_suman 2008-12-08  

学习，大家都很厉害，都是榜样呀，努力！

25 楼 zhxy0234 2008-12-07  

单例模式，学习了。

24 楼 wanghualeilei 2008-12-06  

防止在对象构造过程中，也就是构造函数执行过程中，被其他线程抢占，从而产生第二个对象

23 楼 daweiangel 2008-12-05  

xin911 写道

很典型的 饿汉，懒汉式单例类吧
public class Singleton {  
 
    private static final Singleton s = new Singleton();  
 
    private Singleton() {  
    }  
 
    public static Singleton getInstance() {  
        return s;  
    }  
}

说是更符合java面向对象语言特点--推荐

推荐

22 楼 wangchao_17915566 2008-12-05  

yunhaifeiwu 写道

对了，发现javaeye的圈子没有这类似的机制，人群也较多！在javaeye中，论坛潜规则是给高手过招的地方！（仔细读版规，琢磨一下）

一个人和一个人理解不一样，我理解的javaeye也许跟你琢磨的不是很一样，不好意思哦。

21 楼 yunhaifeiwu 2008-12-04  

对了，发现javaeye的圈子没有这类似的机制，人群也较多！

在javaeye中，论坛潜规则是给高手过招的地方！（仔细读版规，琢磨一下）

20 楼 yunhaifeiwu 2008-12-04  

wangchao_17915566 写道

netfork 写道

哎，管理员在哪里啊～～～
发现只要不是纯技术问题，均可以在论坛（非入门版）里混～

我觉得此人思想有点..每个人都是从不懂-学习-懂，为什么我以我的方式理解>的东西不能写出来，最起码我是用心写的，你找管理员干嘛？难道我自己总结下干扰你了

在javaeye中，你不能发这种东东的！你就是再用心写，就算你能给更多人与启迪参考与帮助都不能。

在你发的文中不能有明显的牛人们能发现的错误！

正确的做法是：把你的真正的内容放到blog或其他网站中，然后发一个说明，一个效果图，OK!然后别在论坛里讨论！

要讨论，一定要讨论高质量的东东！

在javaeye中，像你类讨论，只配新手区！（不好意思，这是教训！像你这种待遇我已经习惯了。）

19 楼 chan.d 2008-12-04  

呵呵，这样的文章也上首页喔~~

怀疑JavaEye的水平了喔，开玩笑呵呵

18 楼 xin911 2008-12-03  

很典型的 饿汉，懒汉式单例类吧
public class Singleton {  
 
    private static final Singleton s = new Singleton();  
 
    private Singleton() {  
    }  
 
    public static Singleton getInstance() {  
        return s;  
    }  
}

说是更符合java面向对象语言特点--推荐

17 楼 puroc 2008-12-03  

使用synchronized是避免在多个线程同时访问getInstance方法时，会返回两个实例。现在一般不在方法上加synchronized，一般在getInstantce里面加，并且使用双check，以避免第二次调用getInstantce方法时，不会再进入synchronized里面。这种方式属于lazy Initialize

但我的写法如下,不是lazy的：

public class Singleton {

    private static final Singleton s = new Singleton();

    private Singleton() {
    }

    public static Singleton getInstance() {
        return s;
    }
}

前一阵JavaEye还有一个帖子，说一个老外推荐了一种singleton的写法。你可以找找那个帖子。

16 楼 hanjs 2008-12-03  

如果看过双单子，也不能避免存在多个实例。


还是感觉第一种实现适合java，而且也已经能达到目的了。

静态的肯定是只编译一次的，应该不会存在两个吧。