和你一起終身學習，這裏是程序員 Android
經典好文推薦，通過閱讀本文，您將收穫以下知識點:
一、Thread 使用
二、Android Thread
三.線程優先級
一、Thread 使用
在講解多線程之前，我們先來講解Thread使用幾個需要注意的點：
1.Thread 中斷
常用的有兩種方式：
(1).通過拋出InterruptedException來中斷線程
public static class MyThread extends Thread{
private int count=0;
@Override
public void run() {
super.run();
try{
while(true){
count++;
System.out.println("count value:"+count);
if (this.interrupted() || this.isInterrupted()){
System.out.println("check interrupted show!");
throw new InterruptedException();
}
}
}catch ( InterruptedException e) {
System.out.println("thread is stop!");
e.printStackTrace();
}
}
}
(2).通過變量來中斷（常用）
public static class CustomThread extends Thread{
private int count=0;
private boolean isCancel = false;
@Override
public void run() {
super.run();
while(!isCancel){
count++;
System.out.println("count value:"+count);
}
}
public synchronized void cancel(){
isCancel = true;
}
}
2.Thread 同步
我們分變量同步和代碼塊同步兩個方面來講解
(1).變量同步
- 使用volatile關鍵字
/**
* 主內存和線程內存緩存進行同步
*/
volatile int val = 5;
public int getVal() {
return val;
}
public void setVal(int val) {
this.val = val;
}
- 使用synchronized關鍵字
int val2 = 5;
/**
* 使用一個motinor來監聽（實現資源由一個線程進行操作）
* 主內存和線程內存緩存進行同步
* @return
*/
public synchronized int getVal2() {
return val2;
}
public synchronized int setVal2(int val) {
this.val2 = val;
}
- 使用關鍵字AtomicXXXXX
AtomicInteger mAtomicValue = new AtomicInteger(0);
public void setAtomicValue(int value){
mAtomicValue.getAndSet(value);
}
public int getAtomicValue(){
return mAtomicValue.get();
}
(2).代碼塊同步
代碼塊同步分樂觀鎖和悲觀鎖來講解
使用悲觀鎖時，其他線程等待，進入睡眠，頻繁切換任務，消耗cpu資源
synchronized (this) {
.....
}
使用樂觀鎖時，失敗重試，避免任務重複切換，減少cpu消耗
ReentrantLock lock = new ReentrantLock();
lock.lock();
......
lock.unlock();
Thread注意點就講到這裏，下面讓我們進入今天的主題，多線程併發優化。
二、Android Thread
android中很多操作需要在主線程中執行，比如UI的操作，點擊事件等等，但是如果主線程操作太多，佔有的執行時間過長就會出現前面我們說的卡頓現象：
爲了減輕主線程操作過多，避免出現卡頓的現象，我們把一些操作複雜的消耗時間長的任務放到線程池中去執行。下面我們就來介紹android中幾種線程的類。
1.AsyncTask
爲UI線程與工作線程之間進行快速的切換提供一種簡單便捷的機制。適用於當下立即需要啓動，但是異步執行的生命週期短暫的使用場景。
它提供了一種簡便的異步處理機制，但是它又同時引入了一些令人厭惡的麻煩。一旦對AsyncTask使用不當，很可能對程序的性能帶來負面影響，同時還可能導致內存泄露。(關於內存泄漏在上面已經講過)
- 使用AsyncTask需要注意的問題?
(1).在AsyncTask中所有的任務都是被線性調度執行的，他們處在同一個任務隊列當中，按順序逐個執行。一旦有任務執行時間過長，隊列中其他任務就會阻塞。
對於上面的問題，我們可以使用AsyncTask.executeOnExecutor()讓AsyncTask變成併發調度。
(2).AsyncTask對正在執行的任務不具備取消的功能，所以我們要在任務代碼中添加取消的邏輯（和上面Thread類似）
(3).AsyncTask使用不當會導致內存泄漏（可以參考內存泄漏一章）
2.HandlerThread
爲某些回調方法或者等待某些任務的執行設置一個專屬的線程，並提供線程任務的調度機制。
先來了解下Looper，Handler，MessageQueue
Looper: 能夠確保線程持續存活並且可以不斷的從任務隊列中獲取任務並進行執行。
Handler: 能夠幫助實現隊列任務的管理，不僅僅能夠把任務插入到隊列的頭部，尾部，還可以按照一定的時間延遲來確保任務從隊列中能夠來得及被取消掉。
MessageQueue: 使用Intent，Message，Runnable作爲任務的載體在不同的線程之間進行傳遞。
把上面三個組件打包到一起進行協作，這就是HandlerThread
我們先來看下源碼：
public class HandlerThread extends Thread {
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
public Looper getLooper() {
if (!isAlive()) {
return null;
}
// If the thread has been started, wait until the looper has been created.
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
}
從上面的源碼發現，HandlerThread其實就是在線程中維持一個消息循環隊列。下面我們看下使用：
HandlerThread mHanderThread = new HandlerThread("hanlderThreadTest", Process.THREAD_PRIORITY_BACKGROUND);
mHanderThread.run();
Looper mHanderThreadLooper = mHanderThread.getLooper();
Handler mHandler = new Handler(mHanderThreadLooper){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
//子線程中執行
...
}
};
//發送消息
mHandler.post(new Runnable() {
@Override
public void run() {
...
}
});
3.IntentService
適合於執行由UI觸發的後臺Service任務，並可以把後臺任務執行的情況通過一定的機制反饋給UI。
默認的Service是執行在主線程的，可是通常情況下，這很容易影響到程序的繪製性能(搶佔了主線程的資源)。除了前面介紹過的AsyncTask與HandlerThread，我們還可以選擇使用IntentService來實現異步操作。IntentService繼承自普通Service同時又在內部創建了一個HandlerThread，在onHandlerIntent()的回調裏面處理扔到IntentService的任務。所以IntentService就不僅僅具備了異步線程的特性，還同時保留了Service不受主頁面生命週期影響的特點。
使用IntentService需要特別注意的點：
(1).因爲IntentService內置的是HandlerThread作爲異步線程，所以每一個交給IntentService的任務都將以隊列的方式逐個被執行到，一旦隊列中有某個任務執行時間過長，那麼就會導致後續的任務都會被延遲處理。
(2).通常使用到IntentService的時候，我們會結合使用BroadcastReceiver把工作線程的任務執行結果返回給主UI線程。使用廣播容易引起性能問題，我們可以使用LocalBroadcastManager來發送只在程序內部傳遞的廣播，從而提升廣播的性能。我們也可以使用runOnUiThread()快速回調到主UI線程。
(3).包含正在運行的IntentService的程序相比起純粹的後臺程序更不容易被系統殺死，該程序的優先級是介於前臺程序與純後臺程序之間的。
4.Loader
對於3.0後ContentProvider中的耗時操作，推薦使用Loader異步加載數據機制。相對其他加載機制，Loader有那些優點呢？
- 提供異步加載數據機制
- 對數據源變化進行監聽，實時更新數據
- 在Activity配置發生變化（如橫豎屏切換）時不用重複加載數據
- 適用於任何Activity和Fragment
下面我們來看下Loader的具體使用：
我們以獲得手機中所有的圖片爲例：
getLoaderManager().initLoader(LOADER_TYPE, null, mLoaderCallback);
LoaderManager.LoaderCallbacks<Cursor mLoaderCallback = new LoaderManager.LoaderCallbacks<Cursor() {
private final String[] IMAGE_COLUMNS={
MediaStore.Images.Media.DATA,//圖片路徑
MediaStore.Images.Media.DISPLAY_NAME,//顯示的名字
MediaStore.Images.Media.DATE_ADDED,//添加時間
MediaStore.Images.Media.MIME_TYPE,//圖片擴展類型
MediaStore.Images.Media.SIZE,//圖片大小
MediaStore.Images.Media._ID,//圖片id
};
@Override
public Loader<Cursor onCreateLoader(int id, Bundle args) {
toggleShowLoading(true,getString(R.string.common_loading));
CursorLoader cursorLoader = new CursorLoader(ImageSelectActivity.this, MediaStore.Images.Media.EXTERNAL_CONTENT_URI,IMAGE_COLUMNS,
IMAGE_COLUMNS[4] + " 0 AND "+IMAGE_COLUMNS[3] + " =? OR " +IMAGE_COLUMNS[3] + " =? ",
new String[]{"image/jpeg","image/png"},IMAGE_COLUMNS[2] + " DESC");
return cursorLoader;
}
@Override
public void onLoadFinished(Loader<Cursor loader, Cursor data) {
if(data != null && data.getCount() 0){
ArrayList<String imageList = new ArrayList<();
if(mShowCamera){
imageList.add("");
}
while (data.moveToNext()){
String path = data.getString(data.getColumnIndexOrThrow(IMAGE_COLUMNS[0]));
imageList.add(path);
Log.e("ImageSelect", "IIIIIIIIIIIIIIIIIIII====="+path);
}
//顯示數據
showListData(imageList);
toggleShowLoading(false,getString(R.string.common_loading));
}
}
@Override
public void onLoaderReset(Loader<Cursor loader) {
}
onCreateLoader() 實例化並返回一個新創建給定ID的Loader對象
onLoadFinished() 當創建好的Loader完成了數據的load之後回調此方法
onLoaderReset() 當創建好的Loader被reset時調用此方法，這樣保證它的數據無效
LoaderManager會對查詢的操作進行緩存，只要對應Cursor上的數據源沒有發生變化，在配置信息發生改變的時候(例如屏幕的旋轉)，Loader可以直接把緩存的數據回調到onLoadFinished()，從而避免重新查詢數據。另外系統會在Loader不再需要使用到的時候(例如使用Back按鈕退出當前頁面)回調onLoaderReset()方法，我們可以在這裏做數據的清除等等操作。
5.ThreadPool
把任務分解成不同的單元，分發到各個不同的線程上，進行同時併發處理。
線程池適合用在把任務進行分解，併發進行執行的場景。
系統提供ThreadPoolExecutor幫助類來幫助我們簡化實現線程池。
使用線程池需要特別注意同時併發線程數量的控制，理論上來說，我們可以設置任意你想要的併發數量，但是這樣做非常的不好。因爲CPU只能同時執行固定數量的線程數，一旦同時併發的線程數量超過CPU能夠同時執行的閾值，CPU就需要花費精力來判斷到底哪些線程的優先級比較高，需要在不同的線程之間進行調度切換。
一旦同時併發的線程數量達到一定的量級，這個時候CPU在不同線程之間進行調度的時間就可能過長，反而導致性能嚴重下降。另外需要關注的一點是，每開一個新的線程，都會耗費至少64K+的內存。爲了能夠方便的對線程數量進行控制，ThreadPoolExecutor爲我們提供了初始化的併發線程數量，以及最大的併發數量進行設置。
/**
* 核心線程數
* 最大線程數
* 保活時間
* 時間單位
* 任務隊列
* 線程工廠
*/
threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
linkedBlockingQueue, sThreadFactory);
threadPoolExecutor.execute(runnable);
- 我們知道系統還提供了Executors類中幾種線程池，下面我們來看下這些線程池的缺點：
newFixedThreadPool 和 newSingleThreadExecutor:主要問題是堆積的請求處理隊列可能會耗費非常大的內存，甚至 OOM。
newCachedThreadPool 和 newScheduledThreadPool:主要問題是線程數最大數是 Integer.MAX_VALUE，可能會創建數量非常多的線程，甚至 OOM
- 我們看到這些線程池但是有缺點的，所以具體使用那種方式實現要根據我們的需求來選擇。
如果想要避開上面的問題，可以參考OKHttp中線程池的實現，OKHttp中隊線程調度又封裝了一層，使用安全且方便，有興趣的可以去看看源碼。
三.線程優先級
Android系統會根據當前運行的可見的程序和不可見的後臺程序對線程進行歸類，劃分爲forground的那部分線程會大致佔用掉CPU的90%左右的時間片，background的那部分線程就總共只能分享到5%-10%左右的時間片。之所以設計成這樣是因爲forground的程序本身的優先級就更高，理應得到更多的執行時間。
默認情況下，新創建的線程的優先級默認和創建它的母線程保持一致。如果主UI線程創建出了幾十個工作線程，這些工作線程的優先級就默認和主線程保持一致了，爲了不讓新創建的工作線程和主線程搶佔CPU資源，需要把這些線程的優先級進行降低處理，這樣才能給幫組CPU識別主次，提高主線程所能得到的系統資源。
在Android系統裏面，我們可以通過android.os.Process.setThreadPriority(int)設置線程的優先級，參數範圍從-20到24，數值越小優先級越高。Android系統還爲我們提供了以下的一些預設值，我們可以通過給不同的工作線程設置不同數值的優先級來達到更細粒度的控制。
大多數情況下，新創建的線程優先級會被設置爲默認的0，主線程設置爲0的時候，新創建的線程還可以利用THREAD_PRIORITY_LESS_FAVORABLE或者THREAD_PRIORITY_MORE_FAVORABLE來控制線程的優先級。
參考鏈接：https://www.jianshu.com/p/2795aef8980d
至此，本篇已結束。轉載網絡的文章，小編覺得很優秀，歡迎點擊閱讀原文，支持原創作者，如有侵權，懇請聯繫小編刪除，歡迎您的建議與指正。同時期待您的關注，感謝您的閱讀，謝謝！