[color=red]单例模式的优点[/color]
1,实例控制:单例模式防止其它对象对自己的实例化,确保所有的对象都访问一个实例。
2,伸缩性:因为由类自己来控制实例化进程,类就在改变实例化进程上有相应的伸缩性。
[color=red]单例模式的缺点[/color]
1,系统开销。虽然这个系统开销看起来很小,但是每次引用这个类实例的时候都要进行实例是否存在的检查。这个问题可以通过静态实例来解决。
2,开发混淆。当使用一个单例模式的对象的时候(特别是定义在类库中的),开发人员必须要记住不能使用new关键字来实例化对象。因为开发者看不到在类库中的源代码,所以当他们发现不能实例化一个类的时候会很惊讶。
[color=red][b]实现原则:[/b][/color]
a.私有的静态的实例
b.私有的构造方法
c.公有静态的访问接口
[color=red]第一种方法:饿汉式单例类[/color]
[color=red]
第二种方法:懒汉式单例类,可以同步但是效率不高:
[/color]
[color=red]第三种,双检锁写法:[/color]
上面的第二种写法,程序不会出错,因为整个getInstance是一个整体的"critical section",但就是效率很不好,因为我们的目的其实只是在第一个初始化instance的时候需要locking(加锁),而后面取用instance的时候,根本不需要线程同步。
于是聪明的人们想出了下面的做法:
1,实例控制:单例模式防止其它对象对自己的实例化,确保所有的对象都访问一个实例。
2,伸缩性:因为由类自己来控制实例化进程,类就在改变实例化进程上有相应的伸缩性。
[color=red]单例模式的缺点[/color]
1,系统开销。虽然这个系统开销看起来很小,但是每次引用这个类实例的时候都要进行实例是否存在的检查。这个问题可以通过静态实例来解决。
2,开发混淆。当使用一个单例模式的对象的时候(特别是定义在类库中的),开发人员必须要记住不能使用new关键字来实例化对象。因为开发者看不到在类库中的源代码,所以当他们发现不能实例化一个类的时候会很惊讶。
[color=red][b]实现原则:[/b][/color]
a.私有的静态的实例
b.私有的构造方法
c.公有静态的访问接口
[color=red]第一种方法:饿汉式单例类[/color]
//========外部直接调用 DaoFactory.getInstance();静态方法即可得到当前类的实例
public class DaoFactory {
//私有的静态的实例
private static DaoFactory instance = new DaoFactory();
//私有的构造方法
private DaoFactory() {}
//公有静态的访问接口,返回当前类的实例
public static DaoFactory getInstance() {
return instance;
}
}
//客户端访问
public class SingletonTest {
public static void main(String []args){
DaoFactory factory1=DaoFactory.getInstance();
DaoFactory factory2=DaoFactory.getInstance();
//判断得到的2个实例是是否相等
if(factory1==factory2){
System.out.print("属于同一个实例");
}
}
}
[color=red]
第二种方法:懒汉式单例类,可以同步但是效率不高:
[/color]
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
if(instance==null){
instance=new Singleton();
}
return instance;
}
public static void main(String []args){
Singleton s=Singleton.getInstance();
Singleton s2=Singleton.getInstance();
if(s==s2){
System.out.print("s==s2");
}
}
}
[color=red]第三种,双检锁写法:[/color]
上面的第二种写法,程序不会出错,因为整个getInstance是一个整体的"critical section",但就是效率很不好,因为我们的目的其实只是在第一个初始化instance的时候需要locking(加锁),而后面取用instance的时候,根本不需要线程同步。
于是聪明的人们想出了下面的做法:
public class Singleton{
private static Singleton single; //声明静态的单例对象的变量
private Singleton(){} //私有构造方法
public static Singleton getSingle(){ //外部通过此方法可以获取对象
if(single == null){
synchronized (Singleton.class) { //保证了同一时间只能只能有一个对象访问此同步块
if(single == null){
single = new Singleton();
}
}
}
return single; //返回创建好的对象
}
}