使用C++11实现Android系统的Handler机制

new Thread(){

 @Override

 public void run() {

 //Do somethings

 }

}.start()

class AlHandler {
public:
 typedef function Callback;
public:
 AlHandler(Callback callback);
 AlHandler(AlLooper *looper, Callback callback);
 void sendMessage(AlMessage *msg) {
 _enqueueMessage(msg);
 }
 void dispatchMessage(AlMessage *msg) {
 if (callback) {
  callback(msg);
 }
 }
private:
 void _enqueueMessage(AlMessage *msg) {
 if (this->looper) {
  msg->target = this;
  this->looper->sendMessage(msg);
 }
 }
private:
 AlLooper *looper = nullptr;
 Callback callback = nullptr;
};

private:
 AlLooperManager() : Object() {}
 AlLooperManager(AlLooperManager &e) : Object() {}
 ~AlLooperManager() {}
 /**
 * 为当前线程创建Looper
 * @return 当前线程的Looper
 */
 AlLooper *create(long tid) {
 std::lock_guard guard(mtx);
 auto it = looperMap.find(tid);
 if (looperMap.end() == it) {
  auto *looper = new AlLooper();
  looperMap[tid] = looper;
  return looper;
 }
 return nullptr;
 }
 /**
 * 获取当前线程的Looper
 * @return 当前线程的Looper
 */
 AlLooper *get(long tid) {
 std::lock_guard guard(mtx);
 auto it = looperMap.find(tid);
 if (looperMap.end() == it) {
  return nullptr;
 }
 return it->second;
 }
 /**
 * 销毁当前线程的Looper
 */
 void remove(long tid) {
 std::lock_guard guard(mtx);
 auto it = looperMap.find(tid);
 if (looperMap.end() != it) {
  looperMap.erase(it);
  auto *looper = it->second;
  delete looper;
 }
 }
private:
 static AlLooperManager *instance;
 std::map looperMap;
 std::mutex mtx;
};

class AlLooper : public Object {
public:
 /**
 * 为线程准备一个Looper，如果线程已经存在Looper，则报错
 */
 static void prepare() {
 AlLooper *looper = AlLooperManager::getInstance()->create(Thread::currentThreadId());
 assert(nullptr != looper);
 }
 /**
 * 获取当前线程的Looper
 * @return 前线程的Looper
 */
 static AlLooper *myLooper() {
 AlLooper *looper = AlLooperManager::getInstance()->get(Thread::currentThreadId());
 assert(nullptr != looper);
 return looper;
 }
 static void exit();
 /**
 * 循环消费消息
 */
 static void loop() {
 myLooper()->_loop();
 }
 void _loop() {
 for (;;) {
  AlMessage *msg = queue.take();
  if (msg) {
  if (msg->target) {
   msg->target->dispatchMessage(msg);
  }
  delete msg;
  }
  queue.pop();
 }
 }
 void sendMessage(AlMessage *msg) {
 queue.offer(msg);
 }
private:
 AlLooper();
 AlLooper(AlLooper &e) : Object() {}
 ~AlLooper();
private:
 AlMessageQueue queue;
};

class AlMessage {
public:
 int32_t what = 0;
 int32_t arg1 = 0;
 int64_t arg2 = 0;
 Object *obj = nullptr;
}
class AlMessageQueue : public Object {
public:
 AlMessageQueue() {
 pthread_mutex_init(&mutex, nullptr);
 pthread_cond_init(&cond, nullptr);
 }
 virtual ~AlMessageQueue() {
 pthread_mutex_lock(&mutex);
 invalid = true;
 pthread_mutex_unlock(&mutex);
 clear();
 pthread_mutex_destroy(&mutex);
 pthread_cond_destroy(&cond);
 }
 void offer(AlMessage *msg) {
 pthread_mutex_lock(&mutex);
 if (invalid) {
  pthread_mutex_unlock(&mutex);
  return;
 }
 queue.push_back(msg);
 pthread_cond_broadcast(&cond);
 pthread_mutex_unlock(&mutex);
 }
 AlMessage *take() {
 pthread_mutex_lock(&mutex);
 if (invalid) {
  pthread_mutex_unlock(&mutex);
  return nullptr;
 }
 if (size() <= 0) {
  if (0 != pthread_cond_wait(&cond, &mutex)) {
  pthread_mutex_unlock(&mutex);
  return nullptr;
  }
 }
 if (queue.empty()) {
  pthread_mutex_unlock(&mutex);
  return nullptr;
 }
 AlMessage *e = queue.front();
 queue.pop_front();
 pthread_mutex_unlock(&mutex);
 return e;
 }
 int size();
 void clear();
private:
 pthread_mutex_t mutex;
 pthread_cond_t cond;
 std::list queue;
 bool invalid = false;
};

class AlHandlerThread {
public:
 AlLooper *getLooper() {
 return mLooper;
 }
private:
 void run() {
 AlLooper::prepare();
 mLooper = AlLooper::myLooper();
 AlLooper::loop();
 AlLooper::exit();
 }
private:
 std::thread mThread = thread(&AlHandlerThread::run, this);
 AlLooper *mLooper = nullptr;
};

mThread = AlHandlerThread::create(name);

mHandler = new AlHandler(mThread->getLooper(), [this](AlMessage *msg) {

 /// Do something.

});