Android运行在主线程和子线程浅释

//new子线程的HandlerThread
private static final HandlerThread sWorkerThread = new HandlerThread("launcher-loader");
static {
sWorkerThread.start();
}
private static final Handler sWorker = new Handler(sWorkerThread.getLooper());

//运行在主线程
private void runOnMainThread(Runnable r, int type) {
if (sWorkerThread.getThreadId() == Process.myTid()) {
// If we are on the worker thread, post onto the main handler
mHandler.post(r);
} else {
r.run();
}
}
//运行在工作线程
public static void runOnWorkerThread(Runnable r) {
if (sWorkerThread.getThreadId() == Process.myTid()) {
r.run();
} else {
// If we are not on the worker thread, then post to the worker handler
sWorker.post(r);
}
}

public static class PipelineThreadHandler extends Handler }
mHandler＝new PipelineThreadHandler();

public class PipelineThread extends Thread {
private static final String LOG_TAG = "PipelineThread";
private static final String THREAD_NAME_PREFIX = "Pipeline-";

private static PipelineThread sInstance;

private Handler mHandler;

public PipelineThread() {
super();
setName(THREAD_NAME_PREFIX + getName());
}

public PipelineThread(String name) {
super();
setName(THREAD_NAME_PREFIX + name);
}

public void run() {
try {
// preparing a looper on current thread
// the current thread is being detected implicitly
Looper.prepare();

// now, the handler will automatically bind to the
// Looper that is attached to the current thread
// You don't need to specify the Looper explicitly
synchronized (this) {
mHandler = new PipelineThreadHandler();
this.notifyAll();
}

// After the following line the thread will start
// running the message loop and will not normally
// exit the loop unless a problem happens or you
// quit() the looper (see below)
Looper.loop();
} catch (Throwable t) {
Log.e(LOG_TAG, "halted due to an error", t);
}
}

/**
* Gets the instance of handler. This method should only be invoked after the Pipeline thread
* has been started. If this method is invoked before the Pipeline thread has been started, it will throw
* the PipelineThreadException.
*
* @return
*/
public Handler getHandler()
throws PipelineThreadException {
synchronized (this) {
if (this.getState() == Thread.State.NEW) {
throw new PipelineThreadException("Pipeline thread " + this.getName() + " not started.");
}

if (mHandler == null) {
try {
Log.d(LOG_TAG, "Going to wait for handler to be initialized.");
this.wait();
Log.d(LOG_TAG, "Wait over. Handler is " + mHandler);
} catch (InterruptedException e) {
Log.e(LOG_TAG, e.getMessage(), e);
}
}
}

return mHandler;
}

public static synchronized final PipelineThread getInstance() {
if (sInstance == null) {
sInstance = new PipelineThread();
sInstance.start();
}

return sInstance;
}

public static class PipelineThreadHandler extends Handler {

}
}
//外部调用采用PipelineThread.getInstance().getHandler()

handler = new Handler(new Handler.Callback() {
//....
Thread.currentThread().getId()); //这里拿到的线程ｉｄ和主线程是一样的
}

HandlerThread ht = new HandlerThread("MyThread");
ht.start();
Log.d(TAG,"=========>" + ht.getId());  //这里拿到的就是子线程ｉｄ和主线程不一样
handler = new Handler(ht.getLooper(), new Handler.Callback() {
//...
｝