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

public class Singleton {
 
    private static volatile Singleton instance = null;
 
    private Singleton(){
    }
 
    public static Singleton getInstance() {
        // if already inited, no need to get lock everytime
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
 
        return instance;
    }
}

public static void main(String[] args){
   Singleton singleton = Singleton.instance;
   singleton.doSomething();
}

public class RxBus {
    private static volatile RxBus instance;
    private final Subject<Object, Object> BUS;

    // PublishSubject只会把在订阅发生的时间点之后来自原始Observable的数据发射给观察者
    public RxBus() {
        BUS = new SerializedSubject<>(PublishSubject.create());
    }

    // 单例RxBus
    public static RxBus getDefault() {
        if (instance == null) {
            synchronized (RxBus.class) {
                if (instance == null) {
                    instance = new RxBus();
                }
            }
        }
        return instance;
    }

    // 发送一个新的事件
    public void post(Object o) {
        BUS.onNext(o);
    }

    // 根据传递的 eventType 类型返回特定类型(eventType)的 被观察者
    public <T> Observable<T> toObservable(Class<T> eventType) {
        return BUS.ofType(eventType);
//        这里感谢小鄧子的提醒: ofType = filter + cast
//        return bus.filter(new Func1<Object, Boolean>() {
//            @Override
//            public Boolean call(Object o) {
//                return eventType.isInstance(o);
//            }
//        }) .cast(eventType);
    }
}

RxBus.getDefault().toObservable(String.class).subscribe(new Action1<String>() {
          @Override
          public void call(String s) {
              Toast.makeText(BleActivity.this,s,Toast.LENGTH_SHORT).show();
          }
      });

button.setOnClickListener(new View.OnClickListener() {
       @Override
       public void onClick(View view) {

       }
   });
   button.performClick(); //触发点击事件

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("Hello");
        subscriber.onNext("Hi");
        subscriber.onNext("Aloha");
        subscriber.onCompleted();
    }
});

Observable observable = Observable.just("Hello", "Hi", "Aloha");
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);
// 将会依次调用：
// onNext("Hello");
// onNext("Hi");
// onNext("Aloha");
// onCompleted();

Action1<String> onNextAction = new Action1<String>() {
    // onNext()
    @Override
    public void call(String s) {
        Log.d(tag, s);
    }
};
Action1<Throwable> onErrorAction = new Action1<Throwable>() {
    // onError()
    @Override
    public void call(Throwable throwable) {
        // Error handling
    }
};
Action0 onCompletedAction = new Action0() {
    // onCompleted()
    @Override
    public void call() {
        Log.d(tag, "completed");
    }
};

// 自动创建 Subscriber ，并使用 onNextAction 来定义 onNext()
observable.subscribe(onNextAction);
// 自动创建 Subscriber ，并使用 onNextAction 和 onErrorAction 来定义 onNext() 和 onError()
observable.subscribe(onNextAction, onErrorAction);
// 自动创建 Subscriber ，并使用 onNextAction、 onErrorAction 和 onCompletedAction 来定义 onNext()、 onError() 和 onCompleted()
observable.subscribe(onNextAction, onErrorAction, onCompletedAction);

Observable.just(1, 2, 3, 4)
    .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
    .observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程
    .subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer number) {
            Log.d(tag, "number:" + number);
        }
    });

TextToSpeech mTts;
mTts=new TextToSpeech(this, new TextToSpeech.OnInitListener() {
          @Override
          public void onInit(int status) {
              // status can be either TextToSpeech.SUCCESS or TextToSpeech.ERROR.
              if (status == TextToSpeech.SUCCESS) {
                  // Set preferred language to US english.
                  // Note that a language may not be available, and the result will indicate this.
                  int result = mTts.setLanguage(Locale.CHINA);
                  // Try this someday for some interesting results.
                  // int result mTts.setLanguage(Locale.FRANCE);
                  if (result == TextToSpeech.LANG_MISSING_DATA || result == TextToSpeech.LANG_NOT_SUPPORTED) {
                      // Lanuage data is missing or the language is not supported.
                      Log.e(TAG, "Language is not available.");
                      Intent installIntent = new Intent();
                      installIntent.setAction(TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA);
                      startActivity(installIntent);
                  } else {
                      // Check the documentation for other possible result codes.
                      // For example, the language may be available for the locale,
                      // but not for the specified country and variant.
                      // The TTS engine has been successfully initialized.
                      // Allow the user to press the button for the app to speak again.
                      Log.i(TAG,"初始化成功");
                      mTts.speak("初始化成功",TextToSpeech.QUEUE_FLUSH,null);
                  }
              } else {
                  // Initialization failed.
                  Log.e(TAG, "Could not initialize TextToSpeech.");
              }
          }
      });

@Override
protected void onDestroy() {
    super.onDestroy();
    // 关闭TextToSpeech对象
    if (mTts != null) {
        mTts.shutdown();
    }
}