Android设计模式——单例模式

1.单例模式就是确保一个类，只有一个实例化对象，而且自行实例化并向整个系统提供这个实例。

2.使用场景：

 确保某个类，有且只有一个对象，避免产生对个对象，消耗过多的资源。

2.实现单例模式的重要点：

  <1> 构造函数不对外开放，一般为private。

  <2>通过一个静态方法或枚举返回一个单例类对象

  <3>确保单例对类的对象有且只有一个，尤其是在多线程环境中

　<4>确保单例类对象在反序列化时不会重复构建对象

3.简单的单例模式 [饿汉模式]

public class A{

// 构造函数私有化
private static final A a=new A();
private A(){
     }
// 公有的静态函数，对外暴露获取单例对象的接口
public static A getA(){
     
return a;
     }
 }

4.简单的单例模式 [懒汉模式]

 

/**
 * 懒汉模式
 */

public class A {
    /**
     * 私有化构造
     */
    private static  A a;
    private  A(){

    }

    /**
     * 暴露单例类对象  使用synchronized 也就是getA的一个同步方法，在多线程情况下保证单例对象唯一性的手段。
     * 这里导致，每次使用getA时，都会进行同步，会消耗不必要的资源，第一次加载时需要及时的实例化，反映稍慢。
     * @return
     */
    public static synchronized A getA(){
        if(a==null){
            a=new A();

        }
        return  a;
    }
}

5.Double Check Lock (DCL) 实现单例

DCL实现单例模式的优点是既能够在需要的时候才初始化单例，又能够保证线程的安全，且单例对象初始化后调用getInstance不进行同步锁。

 

public class B {
    private static  B b=null;
    private B(){
        
    }
    public static B getB(){
        if(b==null){
            synchronized (B.class){
                if(b==null){
                    b=new B();
                    
                }
            }
            
        }
        return b;
    }
}

 

在getB的方法上，对b进行了二次的判空，第一层的判断主要是避免不必要的同步，第二层判断是为了在null的情况下创建实例。

DCL的优点就是：资源利用率高，第一次执行getB时单例对象才会被实例化，效率高，缺点就是第一次加载反应稍慢。

 

6.静态内部类单例模式

DCL在一定程度上解决了资源消耗，多余同步，线程安全的问题，但是在某些情况下会出现失效问题，这个问题称为：双重检查锁定(DCL)失效。

静态内部类单例模式：第一次加载C类时，不会初始化c，只有在第一次调用getC时才会导致cInstance初始化。这种方式不仅能保证线程的安全，也能保证单例对象的唯一。同时延迟了单例的实例化。

 

/**
 * 静态内部类实现单例模式
 */
public class C {
    
    
    private  C(){}
    
    public static C getC(){
        return CHolder.cInstance;
    }

    /**
     * 静态内部类
     */
    
    private  static class CHolder{
        private static final C cInstance=new C();
        
        
    }
}

<总结>

 1.1 简单的单例模式：

public class F {
    private static F f=new F();
    private F(){}

    public  static F getF(){
        return f;

    }
}

    F f=F.getF();
        Log.i(TAG, "onCreate:FF: "+f.toString());
        new Thread(new Runnable() {
            @Override
            public void run() {
                F f1=F.getF();
                Log.i(TAG, "run: FF:"+f1.toString());
            }
        }).start();

输出结果：不会重现创建新的实例

MainActivity: onCreate:FF: myapplication.com.myfuxiforexample_a.F@afcfa2e
MainActivity: run: FF:myapplication.com.myfuxiforexample_a.F@afcfa2e

 

转载于:https://www.cnblogs.com/galibujianbusana/p/6411838.html