定义

保证一个类仅有一个实例，并提供一个访问它的全局访问点

场景

例：现在要开发一个程序，接收各种传感器的回馈，这时我们就可以考虑使用单例模式了，在单例中实现传感器的监听注册、回调接口

代码

回调方法

public class AppCore {

    public void onStateResponseA(State state){};

    public void onStateResponseB(State state){};

    public void onStateResponseC(State state){};
}

单例

public class AppManage {

    private List<WeakReference<AppCore>> mCallBacks = null;

    public static AppManage getInstance() {
        return AppCoreManageImlHolder.instance;
    }

    private static class AppCoreManageImlHolder {
        private static AppManage instance = new AppManage();
    }
    private AppManage() {
        init();
    }

    private void init() {
        if (mCallBacks == null) {
            mCallBacks = new ArrayList<WeakReference<AppCore>>();
        }
    }

    /**
     * 注册回调
     * @param cb
     * @return
     */
    public boolean register(@NonNull AppCore cb) {
        boolean result = false;
        if (!isRegister(cb)) {
            mCallBacks.add(new WeakReference<AppCore>(cb));
            result = true;
        }
        return result;
    }

    /**
     * 注销回调
     * @param cb
     * @return
     */
    public boolean remove(@NonNull AppCore cb) {
        boolean result = false;
        for (int i = mCallBacks.size() - 1; i >= 0; i--) {
            if (mCallBacks.get(i).get() == cb) {
                mCallBacks.remove(i);
                result = true;
                break;
            }
        }
        return result;
    }

    private boolean isRegister(AppCore cb) {
        int size = mCallBacks.size();
        for (int i = 0; i < size; i++) {
            if (mCallBacks.get(i).get() == cb) {
                return true;
            }
        }
        return false;
    }

    /**
     * 当接收到状态时可以调用此方法下发
     * @param state
     */
    public void handlerState(State state) {
        int size = mCallBacks.size();
        for (int i = 0; i < size; i++) {
            AppCore cb = mCallBacks.get(i).get();
            if (cb != null) {
                cb.onStateResponseA(state);
            }
        }
    }
}

注册/销毁回调

public class MainActivity extends Activity {

    private AppManage mAppManage;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mAppManage = AppManage.getInstance();
        mAppManage.register(mCallBack);

    }

    AppCore mCallBack = new AppCore() {
        @Override
        public void onStateResponseA(State state) {
            super.onStateResponseA(state);
        }

        @Override
        public void onStateResponseC(State state) {
            super.onStateResponseC(state);
        }
    };

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mAppManage.remove(mCallBack);
    }
}

上面是关于单例的简单用法，用的是静态内部类单例模式，这种写法由JVM来保证线程的安全性，优点是：

• 延迟加载
• 线程安全
  除此之外还有：
• 懒汉模式
• 饿汉模式
• DCL
  但目前最流行的写法还是静态内部类单例模式，所以关于这几种模式在这里就不讲了