大家好,我叫噬魂
2.1单例模式介绍
单例模式的应用场景是:在一个应用中,应当只有一个ImageLoader实例,这个实例ImageLoader中又有线程池,缓存系统,网络请求等,这些都很消耗资源,所以应当采用单例模式。
2.2单例模式的定义
确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。
2.3单例模式UML类图
图2-1
角色介绍:
Client----高层客户端
Singleton----单例类
实现单例模式有以下几个关键点:
1.构造函数不对外开放,一般为private;
2.通过一个静态方法或者枚举返回单例类对象;
3.确保单例类只有一个,尤其是在多线程的环境下;
4.确保单例类对象在反序列化时不会重新构建对象(这个可能是很多人没有注意到的)。
在获取单例对象的时候,我们要确保线程安全,在多线程环境也只有一个对象,这在单例模式实现中比较困难。
2.4单例模式的简单实现
示例实现代码 coding
package com.dp.example.singleton;
//普通员工
public class Staff{
public void work(){
//干活
}
}
//副总裁
public class VP extends Staff{
@override
public void work(){
//管理下面的经理
}
}
//CEO,恶汉单例模式
public class CEO extends Staff{
private static final CEO mCeo = new CEO();
//构造函数私有
private CEO(){
}
//公有的静态方法,对外暴露获取单例对象的接口
public static CEO getCeo(){
return mCeo;
}
@override
public void work(){
//管理vp
}
}
//公司类
public class Company{
private List<Staff> allStaffs = new ArrayList<Staff>;
public void addStaff(Staff per){
allStaff.add(per);
}
public void showAllStaffs(){
for (Staff per: allStaffs ) {
System.out.println("Obj: "+ per.toString());
}
}
}
public class Test{
public static void man(String[] args){
Company cp = new Company();
//CEO对象只能用getCeo函数获取
Staff ceo1 = CEO.getCeo();
Staff ceo2 = CEO.getCeo();
cp.addStaff(ceo1);
cp.addStaff(ceo2);
//通过new创建vp对象
Staff vp1 = new VP();
Staff vp2 = new VP();
//通过new创建staff对象
Staff staff1 = new Staff();
Staff staff2 = new Staff();
Staff staff3 = new Staff();
cp.addStaff(vp1);
cp.addStaff(vp2);
cp.addStaff(staff1);
cp.addStaff(staff2);
cp.addStaff(staff3);
cp.showAllStaffs();
}
}
2.5单例模式的其他实现方式
懒汉模式
public class singleton{
private static singleton instance;
private singleton (){};
public static synchronized singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
我们在getInstance()方法中添加了synchronized关键字，也就是一个同步方法，这是为了保证在多线程中对象唯一性的手段，不过这里有一个问题，就是当instance已经被初始化了之后，以后每次调用geitInstance方法都会进行同步操作，这样会消耗不必要的资源，这就是懒汉式存在的最大问题。
最后总结一下：懒汉式的优点是单例只有在使用时才会实例化，在一定程度上节约了资源，缺点是第一次加载时需要及时进行实例化，反应稍慢，最大的问题是当我们用geitIntance时，每次都要同步，这样就造成了不必要的开销，懒汉式这种模式我们一般不推荐使用，我们还是建议使用下面几种方式。
Double Check Lock(DCL)
DCL方式实现单例模式的优点是既能够在需要的时候才初始化单例，又能够保证线程安全，且单例对象初始化之后调用getInstance不进行同步锁。
public class Singleton{
private static Singleton sInstance = null;
private Singleton(){};
public void doSometing(){
System.out.println("do sth.");
}
public static Singleton getInstance(){
if(sInstance == null){
synchronized (Singleton.class){
if(sInstance == null){
sIntance = new Singleton();
}
}
}
return sIntance;
}
}
下面是比较好的实现方式
2.6 静态内部类单例模式
public class Singleton{
private Singleton(){};
public static Singleton getInstance(){
return SingletonHolder.sInstance;
}
/**
*静态内部类
*/
private static class SingletonHolder{
private static final Singleton sInstance = new Singleton();
}
}
这种方式是我们推荐的方式。
