1 开头

上一讲讲到Looper，大家对Looper有了大概的了结（好几个月过去了…）

大家都知道一个Handler对应有一个MessageQueue，

在哪个线程上new Handler（如果不指定looper对象），那么这个handler就默认对应于这个线程上的prepare过的Looper

如下图Handler.java代码所示，mLooper由Looper.myLooper()指定，

public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

public static Looper myLooper() {
        return sThreadLocal.get();
    }

so，一个handler，对应了一套MessageQueue、Thread、Looper

这些都是 【从源码看Android】01从Looper说起 讲过的东西，那么下面来些硬货

2 一个问题引入

从一个问题引入，如果在子线程12上创建了一个handler，

现在在主线程上调用handler.sendEmptyMessage，

handler如何在主线程上处理这个msg，

然后从子线程12让handler的handleMessage函数处理呢？

那么这个时候就要引入一个跨线程的事件模型--epoll，

这一讲先把cpp epoll模型讲清楚，

下一讲再讲android里如何利用这个模型的

3 epoll模型

epolldemo.cpp

#include <iostream>
#include <vector>
#include <queue>
#include <pthread.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <assert.h>
#include <fcntl.h>

#define NUM_THREAD 4
#define NUM_LENGTH 200
#define MAX_EVENTS 20

#define USES_EPOLL

#ifdef USES_EPOLL
/****

（1）.创建一个epoll描述符，调用epoll_create()来完成，epoll_create()有一个整型的参数size，用来告诉内核，要创建一个有size个描述符的事件列表（集合）
int epoll_create(int size)

（2）.给描述符设置所关注的事件，并把它添加到内核的事件列表中去，这里需要调用epoll_ctl()来完成。
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
这里op参数有三种，分别代表三种操作：
a. EPOLL_CTL_ADD, 把要关注的描述符和对其关注的事件的结构，添加到内核的事件列表中去
b. EPOLL_CTL_DEL，把先前添加的描述符和对其关注的事件的结构，从内核的事件列表中去除
c. EPOLL_CTL_MOD，修改先前添加到内核的事件列表中的描述符的关注的事件

（3）. 等待内核通知事件发生，得到发生事件的描述符的结构列表，该过程由epoll_wait()完成。得到事件列表后，就可以进行事件处理了。
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout)


– EPOLLIN，读事件
– EPOLLOUT，写事件
– EPOLLPRI，带外数据，与select的异常事件集合对应
– EPOLLRDHUP，TCP连接对端至少写写半关闭
– EPOLLERR，错误事件
– EPOLLET，设置事件为边沿触发
– EPOLLONESHOT，只触发一次，事件自动被删除


*/
int g_epollfd;
int g_wakeFds[2];
#endif


void awake()
{
    ssize_t nWrite;
    do 
    {
        nWrite = write(g_wakeFds[1], "W", 1);
    } 
    while (nWrite == -1);
}

void awoken() 
{

    char buffer[16];
    ssize_t nRead;
    do {
        nRead = read(g_wakeFds[0], buffer, sizeof(buffer));
    } while ((nRead == -1 ) || nRead == sizeof(buffer));
}

using namespace std;
void* threadRead(void* userdata)
{
    queue<int>* q = (queue<int>*)userdata;

    struct epoll_event events[MAX_EVENTS];
    while( true )
    {
        int fds = epoll_wait(g_epollfd, events, MAX_EVENTS, 1000);
        if(fds < 0){
            printf("epoll_wait error, exit\n");
            break;
        }

        for(int i = 0; i < fds; i++){
            if( events[i].events & EPOLLIN ) // read event
            {
                printf("%s,%d/%d\n", "EPOLLIN",i,fds);
                while( !q->empty() )
                {
                    q->pop();
                    printf("removed! \n" );
                }
            }
        }
        awoken();
    }
    return userdata;
}

void* threadRun(void* userdata)
{
	queue<int>* q = (queue<int>*)userdata;
	while( true )
    {

#ifdef USES_EPOLL
        q->push( 1 );
        printf("%ld:%s\n",(long)pthread_self() ,"added!");
        awake();

#else
#endif
    	usleep(1000*500);
    }
    printf("exit thread:%ld\n",(long)pthread_self() );
	return userdata;
}

int main(int argc, char const *argv[])
{
/**
	pipe（建立管道）：
1) 头文件 #include<unistd.h>
2) 定义函数： int pipe(int filedes[2]);
3) 函数说明： pipe()会建立管道，并将文件描述词由参数filedes数组返回。
              filedes[0]为管道里的读取端
              filedes[1]则为管道的写入端。
*/
    int result = pipe(g_wakeFds);
    assert( result!=0 );

    result = fcntl(g_wakeFds[0], F_SETFL, O_NONBLOCK);
    assert(result!=0);

    result = fcntl(g_wakeFds[1], F_SETFL, O_NONBLOCK);
    assert(result!=0);

    g_epollfd = epoll_create( MAX_EVENTS );
    assert( g_epollfd > 0 );

    struct epoll_event epv = {0, {0}};
    //epv.data.ptr = userdata;
    epv.data.fd = g_wakeFds[0];
    epv.events = EPOLLIN;

    if(epoll_ctl(g_epollfd, EPOLL_CTL_ADD, g_wakeFds[0], &epv) < 0)
        printf("Event Add failed[fd=%d], evnets[%d]\n", epv.data.fd, epv.events);
    else
        printf("Event Add OK[fd=%d], op=%d, evnets[%0X]\n", epv.data.fd, EPOLL_CTL_ADD, epv.events);

    queue<int> q;
    vector<pthread_t> v;
	for (int i = 0; i < NUM_THREAD; ++i)
	{
		pthread_t tid;
		pthread_create(&tid,NULL,threadRun,&q);
		v.push_back(tid);
	}

    pthread_t tid;
    pthread_create(&tid,NULL,threadRead,&q);
    v.push_back(tid);
      
	for(vector<pthread_t>::const_iterator it = v.begin(); it < v.end(); ++it)
        pthread_join(*it,NULL);

	return 0;
}

大致思路是这样的：

a.127行开始建立管道g_wakeFds，g_wakeFds[0]是读取端口，g_wakeFds[1]是写入端口

b.136行创建全局的g_epollfd，即epoll文件描述符，参数为这个文件描述符所支持的最大事件数

c.144行epoll_ctl创建一个事件关联，即将g_epollfd与g_wakeFds[0]进行关联，如果g_wakeFds[0]发生变化，就会触发事件，并且事件为139创建的epoll_event实例

d.151-156行创建多个线程作为生产者，生产int放入queue中，放入完后调用awake()函数，向g_wakeFds[1]写入一字节，触发事件

f.158-160行创建一个消费者来消费生产的int

g.其中76行int fds = epoll_wait(g_epollfd, events, MAX_EVENTS, 1000);来等待生产者生产的int，当g_wakeFds[1]有数据写入时，g_wakeFds[0]就会触发刚刚注册的事件，获取到注册的事件后对事件进行处理（消费int），随后调用awoken()清空g_wakeFds[0]，进入下一轮epoll_wait

注意：生产enqueue和消费dequeue是需要同步锁的，这里省略了这个过程，android在java中对Message实现的同步锁

4 运行结果

5 源码下载

http://pan.baidu.com/s/1i3BTWpv

6 总结

当一个线程的消息队列没有消息需要处理时，它就会在这个管道的读端文件描述符上进行睡眠等待，直到其他线程通过这个管道的写端文件描述符来唤醒它。这样就节省了线程上对于cpu资源的消耗。

7 reference

《Android系统源码情景分析》- 罗升阳

Android NDK 源代码

Android SDK 源代码