在Android中ProcessState是客户端和服务端公共的部分，作为Binder通信的基础，ProcessState是一个singleton类，每个
进程只有一个对象，这个对象负责打开Binder驱动，建立线程池，让其进程里面的所有线程都能通过Binder通信。
与之相关的是IPCThreadState，每个线程都有一个IPCThreadState实例登记在Linux线程的上下文附属数据中，主要负责
Binder的读取，写入和请求处理框架。IPCThreadState在构造的时候获取进程的ProcessState并记录在自己的成员变量
mProcess中，通过mProcess可以获得Binder的句柄。

frameworks/base/include/binder/ProcessState.h

class ProcessState : public virtual RefBase

{

public:

	static sp<ProcessState> self();	// 单例模式，获取实例

	void setContextObject(const sp<IBinder>& object);

	sp<IBinder> getContextObject(const sp<IBinder>& caller);

	void setContextObject(const sp<IBinder>& object, const String16& name);

	sp<IBinder> getContextObject(const String16& name, const sp<IBinder>& caller);

	void startThreadePool();

	typdef bool (*context_check_func)(const String16& name, const sp<IBinder>& caller, void* userData);

	bool isContextManager(void) const;

	bool becomeContextManager(context_check_func checkFunc, void* userData);

	sp<IBinder> getStrongProxyForHandle(int32_t handle);

	wp<IBinder> getWeakProxyForHandle(int32_t handle);

	void espungeHandle(int32_t handle, IBinder* binder);

	void spawnPooledThread(boot isMain);

private:

	friend class IPCThreadState;

		ProcessState();

		~ProcessState;

		ProcessState(const ProcessState& o);

	ProcessState& operator=(const ProcessState& o);

	struct hdndle_entry {

		IBinder* binder;

		RefBase::weakref_type* refs;

	};

	handle_entry* lookupHandleLocked(int32_t handle);

	int mDriverFD;		// 打开的binder驱动文件描述符

	void* mVMStart;

	Vector<handle_entry> mHandleToObject;

	bool mManagerContexts;

	context_check_func mBinderContextCheckFunc;

	void* mBinderContextUserData;

	KeyedVector<String16, sp<IBinder> > mContexts;	// 映射，服务名字 和 IBinder对应

	bool mThreadPoolStarted;	// 线程池是否已经创建

volatile int32_t mThreadPoolSeq;	// 这个进程中启动线程个数

};

1）获得ProcessState的实例

sp<ProcessState> proc(ProcessState::self());

调用函数：

sp<ProcessState> ProcessState::self()

{

	if (gProcess != NULL) return gProcess;

	AutoMutext _l(gProcessMutex);

	if(gProcess == NULL) gProcess = new ProcessState;

	return gProcess;

}

进入构造函数：

ProcessState::ProcessState() : mDriverFD(open_driver())

			, mVMStart(MAP_FAILED),

			, mManagerContexts(false)

			, mBinderContextCheckFunc(NULL)

			, mBinderContextUserData(NULL)

			, mThradPoolStarted(false)

			, mThreadPoolSeq(1)

{

}

这个构造函数里面调用open_driver()打开了/dev/binder设备驱动文件，返回文件描述符。这样我们就能通过这个mDriverFd
来和binder驱动交互了。

2）创建线程ProcessState::self()->startThreadPool();

void ProcessState::startThreadPool()

{

	AutoMutex _l(mLock);

	if(!mThreadPoolStarted) {

		mThreadPoolStarted = true;

		spawnPooledThread(true);

	}

}

void ProcessState::spawnPoolThread(bool isMain)

{

	if (mThreadPoolStarted) {

		int32_t s = android_atomic_add(1, &mThreadPoolSeq);

		sp<Thread> t = new PoolThread(isMain);

		t->run(buf);

	}

}
其实这里就是创建一个线程PoolThread，而PoolThread是一个继承于Thread的类。所以调用t->run()之后相当于调用

PoolThread类的threadLoop()函数，我们来看看PoolThread类的threadLoop线程函数。

virtual bool threadLoop()

{

	IPCThreadState::self()->joinThreadPool(mIsMain);

	// 这里线程函数调用了一次IPCThreadState::self()->joinThreadPool()后就退出了

	return false;

}

3）IPCThreadState::self()->joinThreadPool();

我们知道：进程调用spawnPoolThread()创建了一个线程，执行joinThreadPool(),而主线程也是调用这个函数。唯一区别
是参数，主线程调用的joinThreadPool(true)，创建的线程调用的是jointThreadPool(false)。
下面我们来分析下这个函数，首先我们来看看IPCThreadState这个类

frameworks/base/include/IPCThreadState.h

class IPCThreadState

{

public:

	static IPCThreadState* self();

	sp<ProcessState> process();

	......

	void joinThradPool(bool isMain = true);

	status_t transact(int32_t handle, uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);

	void incStrongHandle(int32_t handle);

	void decStrongHandle(int32_t handle);

	void incWeakHandle(int32_t handle);

	void decWeakHandle(int32_t handle);

private:

	IPCThraedState();

	~IPCThreadState();

	status_t sendReplay(const Parcel& reply, uint32_t flags);

	status_t waitForResponse(Parcel& reply,  status_t *acquireResult = NULL);

	status_t talkWithDriver(bool doReceice = true);

	status_t writeTransactionData();

	status_t executeCommand();

private:

	sp<ProcessState> mProcess;

	Vector<BBinder> mPendingStrongDerefs;

	Vector<RefBase::weakref_type*> mPendingWeakDerefs;

	Parcel mIn;

	Parcel mOut;

}

上面是IPCThreadState类常用的几个函数。

IPCThreadState* IPCThreadState::self()

{

	if(gHaveTLS) {	// 第一次进来肯定为false

restart:

		const pthread_key_t k = gTLS;

		IPCThreadState* st = (IPCThreadState*)pthread_getspecific(k);

		if(st) return st;

		return new IPCThreadState;	// new 一个IPCThreadState对象

	}

	if(gShutdown) return NULL;

	pthread_mutex_lock(&gTLSMutex);

	if(!gHaveTLS) {

		// 第一个参数为指向一个键值的指针，第二个参数指明一个destructor函数，当线程结束时调用

		if(phread_key_create(&gTLS, threadDestructor) != 0) {

			pthread_mutex_unlock(&gTLSMutex);

			return NULL;

		}

		gHaveTLS = true;

	}

	pthread_mutex_unlock(&gTLSMutex);

	goto restart;

}

下面来说明下线程中特有的线程存储：Thread Specific Data.
在多线程中，所有线程共享程序中变量，如果每一个线程都希望单独拥有它，就需要线程存储了。即一个变量表面看起来是
全局变量，所有线程都可以使用它，它的值在每一个线程都是单独存储的。
用法：
       1）创建一个类型为pthread_key_t 类型变量
       2）pthread_key_create()创建改变量，第二个参数表上一个清理函数，用来在线程释放该线程存储的时候调用。
       3）当线程中需要存储特殊值的时候，可以用pthread_setspecific()，第一个参数为pthread_key_t 变量，第二个参数为void* 变量，可以存储任何类型的值。
       4）当需要取出存储值的时候，调用pthread_getspecific()，返回void*类型变量值。

好了我们现在知道pthread_key_t是干什么用的了？既然代码中有pthread_getspecific()获取IPCThreadState*对象的函数
那么肯定有设置这个变量值的地方？我们找到IPCThreadState的构造函数：

IPCThreadState:IPCThreadState()

	: mProcess(ProcessState::self()),

	  mMyThreadId(androidGetTid()),

	  mStrictModePolicy(0),

	  mLastTransactionBinderFlags(0)

{

	pthread_setspecific(gTLS, this);	// 设置为当前this 指针

	clearCaller();

	mIn.setDataCapacity(256);	// 这里mIn 和 mOut分别表示Binder输入输出的变量，我们后面分析

	mOut.setDataCapacity(256);

}

最后进入IPCThreadState::joinThreadPool(bool isMain)

void IPCThreadState::joinThreadPool(bool isMain)	// 默认为true

{

	mOut.writeInt32(isMain ? BC_ENTER_LOOPER : BC_REGISTER_LOOPER);

	do {

		int32_t cmd;

		if(mIn.dataPosition() >= mIn.dataSize()){

			size_t numPending = mPendingWeakDerefs.size();

			if(numPending > 0) {

				for(size_t i = 0; i < numPending; i++) {

					RefBase::weakref_type* refs = mPendingWeakDerefs[i];

					refs->decWeak(mProcess.get);

				}

				mPendingWeakDerefs.clear();

			}

			numPending = mPendingStrongDerefs.size();

			if(numPending > 0) {

				for(sizt_t i = 0; i < numPending; i++) {

					BBinder* obj = mPendingStrongDerefs[i];

					obj->decStrong(mProcess.get);

				}

				mPendingStrongDerefs.clear();

			}

		}

		// 读取下一个command进行处理

		result = talkWithDriver();// 来等待Client的请求

		if(result >= NO_ERROR) {

			size_t IN = mIn.dataAvail();

			if(IN < sizeof(int32_t)) continue;

			cmd = mIn.readInt32();

		}

		result = executeCommand(cmd);

		if(result == TIMED_OUT && !isMain)

			break;

	} while(result != -ECONNREFUSED && result != -EBADF);

	mOut.writeInt32(BC_EXIT_LOOPER);

	talkWithDriver(false);

}

这里的talkWithDriver()里面之际调用的是ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr)从/dev/binder读取
Client端发过来的请求，然后调用executeCommand处理

status_t IPCThreadState::executeCommand(int32_t cmd)

{

	BBinder* obj;

	RefBase::weakref_type* refs;

	status_t result = NO_ERROR;

	switch(cmd) {

		case BR_TRANSACTION:

		binder_transaction_data tr;

		result = mIn.read(&tr, sizeof(tr));

		....

		Parcel reply;

		if(tr.target.ptr) {

			sp<BBinder> b((BBinder*)tr.cookie);

			const status_t error  = b->transact(tr.code, buffer, &reply, tr.flags);

		}

		....

		break;

	}

}

最后又调用到BBinder 的transact()函数里面去了。

status_t BBinder::transact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags )

{

	data.setDataPosition(0);

	switch(code)

	{

		case PING_TRANSACTION:

			reply->writeInt32(pingBinder());

			break;

		default:

			err = onTransact(code, data, reply, flags);

			break;

	}

	return err;

}

到这里IPCThreadState类的流程就大概清楚了，线程调用joinThreadPool()从/dev/binder读取客户端的请求，然后调用
BBinder::transact()处理。那么这个BBinder是怎么来的呢？
上面代码中：sp<BBinder> b((BBinder*)tr.cookie)说明这个BBinder指针是从Binder驱动中获取到，肯定是客户端
发送过来的，那么它的实际类型又是什么呢？而BBinder调用的onTransact()函数只是一个虚函数，肯定由它的子类来实
现，那我们服务端又怎么找到这个BBinder的实际类型呢？
这些内容我们下一节通过MediaPlayer这个具体示例分析。

最新文章

  1. 不错的 iOS 工具
  2. Linux系统中 安装Vmware Toolst工具
  3. php mb_convert_encoding的使用
  4. Struts2 中Parameters是如何获取值的
  5. c#中结构体(struct)和类(class)的区别
  6. ✡ leetcode 162. Find Peak Element --------- java
  7. Oracle -&gt;&gt; 行转列， 列转行
  8. 中国首个 SaaS 模式的云告警平台安卓版 APP 上线
  9. asp.net EasyUI DataGrid 实现增删改查
  10. COCI 2015/2016 Day 8 PROKLETNIK
  11. android 向serverGet和Post请求的两种方式,android向server发送文件,自己组装协议和借助第三方开源
  12. requests-代理设置
  13. unity网络----简单基础
  14. Java程序员从阿里拿到offer回来，这些面试题你会吗？
  15. MySQL+MyBatis下批量修改数据的问题
  16. cas配置不通过登陆校验的页面
  17. Looper分析。ThreadLocal有关
  18. Razor及HtmlHelper学习笔记
  19. MySQL的innoDB锁机制以及死锁处理
  20. 【精选】Ubuntu 14.04 安装Nginx、php5-fpm、ThinkPHP5.0(已经测试上线)

热门文章

  1. Bridge 桥梁模式 桥接模式
  2. 修改Calendar（梅花雨）日历控件 兼容IE9 谷歌 火狐
  3. linq的一些用法总结
  4. HTML5 文件域+FileReader 读取文件(一)
  5. repeater控件 + marquee标签 实现文字滚动显示
  6. 【SQL Server】SQL与Excel的数据互通导入导出
  7. (转帖) 有限狀態機FSM coding style整理 (SOC) (Verilog)
  8. xmpp发送文件
  9. iOS开发 UITableView之cell
  10. Scene is unreachable due to lack of entry points and does not have an identifier for runtime access