Android 自学之路（四）

Android 并发

---

Android 并发技术概览图

线程安全之基本工具

• 线程状态转换视图
  

synchronized (this) { // (1)
    // Execute code (2)
    wait(); // (3)
    // Execute code (4)
} // (5)

• 使用内置锁

synchronized void changeState() {   sharedResource++;   }   // （1）
void changeState() {        // （2）
    synchronized(this) {
        sharedResource++;
    }
}
private final Object mLock = new Object();      // （3）
void changeState() {
    synchronized(mLock) {
            sharedResource++;
    }
}
synchronized static void changeState() {    staticSharedResource++;     }   // （4）
static void changeState() {         // （5）
    synchronized(this.getClass()) {
        staticSharedResource++;
    }
}

• Explicit locks
  
  • java.util.concurrent.locks.ReentrantLock
  • java.util.concurrent.locks.ReentrantReadWriteLock

int sharedResource;
private ReentrantLock mLock = new ReentrantLock();
public void changeState() {
    mLock.lock();
    try {
        sharedResource++;
    }
    finally {
        mLock.unlock();
    }
}

Android 线程基础

• 线程分类

  • UI Thread
  • Binder Threads
  • Background Threads

• 线程调度（使用的是 Linux 的 CFS 而非 Android Frameworks）

  • Priority
  • setPriority(int priority)
  • Process.setThreadPriority(int priority); // calling thread
  • Process.setThreadPriority(int threadId, int priority);
  • 1(Thread.MIN_PRIORITY) - 19, 2 - 16, 3 - 13, 4 - 10, ..., 9 - -6, 10(Thread.MAX_PRIOPRITY) - -8
  • Control group

线程间通信

• Pipes

int BUFFER_SIZE_IN_CHARS = 1024 * 4;
PipedReader r = new PipedReader(BUFFER_SIZE_IN_CHARS);
PipedWriter w = new PipedWriter(r);

• Shared Memory
• Signaling
• BlockingQueue

private final int LIMIT = 10;
private BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<Integer>(LIMIT);

• ① Android Message Passing - Handler

public class LooperActivity extends Activity {
    LooperThread mLooperThread;
    private static class LooperThread extends Thread { 
        public Handler mHandler;
        public void run() {
            Looper.prepare(); 
            mHandler = new Handler() { 
                public void handleMessage(Message msg) { 
                    if(msg.what == 0) {
                        doLongRunningOperation();
                    }
                }
            };
            Looper.loop(); 
        }
    }
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mLooperThread = new LooperThread(); 
        mLooperThread.start();
    }
    public void onClick(View v) {
        if (mLooperThread.mHandler != null) {
            Message msg = mLooperThread.mHandler.obtainMessage(0); 
            mLooperThread.mHandler.sendMessage(msg); 
        }
    }
    private void doLongRunningOperation() {
        // Add long running operation here.
    }
    protected void onDestroy() {
        mLooperThread.mHandler.getLooper().quit(); 
    }
}

• ② Android Message Passing - MessageQueue.IdleHandler

MessageQueue mq = Looper.myQueue();
// Create and register/unregister an idle listener.
MessageQueue.IdleHandler idleHandler = new MessageQueue.IdleHandler();
mq.addIdleHandler(idleHandler)
mq.removeIdleHandler(idleHandler)
interface IdleHandler {
    boolean queueIdle();
}

• ③ Android Message Passing - Message

  • Data message
  • Task message
  • lifecycle
    
  • 创建
    1) Explicit object construction: Message m = new Message();
    2) Factory methods:
    Empty message: Message m = Message.obtain();
    Data message:
    Message m = Message.obtain(Handler h);
Message m = Message.obtain(Handler h, int what);
Message m = Message.obtain(Handler h, int what, Object o);
Message m = Message.obtain(Handler h, int what, int arg1, int arg2);
Message m = Message.obtain(Handler h, int what, int arg1, int arg2, Object o);
    Task message:
    Message m = Message.obtain(Handler h, Runnable task);
    Copy constructor:
    Message m = Message.obtain(Message originalMsg);

• ④ Android Message Passing - Looper

  • Looper termination: quit() or quitSafely() // API level 18 (Jelly Bean 4.3)

• ⑤ Android Message Passing - Handler

  • new Handler();、 new Handler(Handler.Callback)
  • new Handler(Looper);、 new Handler(Looper, Handler.Callback);
  • Message create wrapper
    Message obtainMessage(int what, int arg1, int arg2)
Message obtainMessage()
Message obtainMessage(int what, int arg1, int arg2, Object obj)
Message obtainMessage(int what)
Message obtainMessage(int what, Object obj)
  • Message insertion
    boolean post(Runnable r)
boolean postAtFrontOfQueue(Runnable r)
boolean postAtTime(Runnable r, Object token, long uptimeMillis)
boolean postAtTime(Runnable r, long uptimeMillis)
boolean postDelayed(Runnable r, long delayMillis)
boolean sendMessage(Message msg)
boolean sendMessageAtFrontOfQueue(Message msg)
boolean sendMessageAtTime(Message msg, long uptimeMillis)
boolean sendMessageDelayed(Message msg, long delayMillis)
boolean sendEmptyMessage(int what)
boolean sendEmptyMessageAtTime(int what, long uptimeMillis)
boolean sendEmptyMessageDelayed(int what, long delayMillis)
  • Removing Messages from the Queue
    removeCallbacks(Runnable r)
removeCallbacks(Runnable r, Object token)
removeMessages(int what)
removeMessages(int what, Object object)
removeCallbacksAndMessages(Object token)
  • Taking a snapshot of the current message queue
    mWorkerHandler.dump(new LogPrinter(Log.DEBUG, TAG), "");
Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, TAG));

• ⑥ Communicating with the UI Thread

Runnable task = new Runnable() {...};
new Handler(Looper.getMainLooper()).post(task);
private void postFromUiThreadToUiThread() {
    new Handler().post(new Runnable() { ... });
    // The code at this point is part of a message being processed
    // and is executed before the posted message.
}
private void postFromUiThreadToUiThread() {
    runOnUiThread(new Runnable() { ... });
}

public class EatApplication extends Application {
    private long mUiThreadId;
    private Handler mUiHandler;
    @Override
    public void onCreate() {
        super.onCreate();
        mUiThreadId = Thread.currentThread().getId();
        mUiHandler = new Handler();
    }
    public void customRunOnUiThread(Runnable action) {
        if (Thread.currentThread().getId() != mUiThreadId) {
            mUiHandler.post(action);
        } else {
            action.run();
        }
    }
}

Uncaught Exception

• Thread global handler
  static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler);
• Thread local handler
  void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler);

// Set new global handler
Thread.setDefaultUncaughtExceptionHandler(new ErrorReportExceptionHandler());
// Error handler that redirects exception to the system default handler.
public class ErrorReportExceptionHandler
    implements Thread.UncaughtExceptionHandler {
    private final Thread.UncaughtExceptionHandler defaultHandler;
    public ErrorReportExceptionHandler() {
        this.defaultHandler = Thread.getDefaultUncaughtExceptionHandler();
    }
    @Override
    public void uncaughtException(Thread thread, Throwable throwable) {
        reportErrorToFile(throwable);
        defaultHandler.uncaughtException(thread, throwable);
    }
}