溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要講解了“Android線程優化知識點有哪些”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Android線程優化知識點有哪些”吧！
在任意時刻，CPU 只能執行一條機器指令，每個線程只有獲得了 CPU 的使用權之后才能執行指令，也就是說 在任意時刻，只有一個線程占用 CPU，處于運行狀態。而我們平常所說的 多線程并發運行，實際上說的是多個線程輪流獲取 CPU 的使用權，然后分別執行各自的任務。其實在可運行池當中有多個處于就緒狀態的線程在等待 CPU，而 JVM 負責線程調度，按照特定機制為多個線程分配 CPU 使用權。
上面的描述提到了三個主要信息：
在任意時刻，只有一個線程占用 CPU，處于運行狀態
多線程并發運行，實際上說的是多個線程輪流獲取 CPU 的使用權
JVM 負責線程調度，按照特定機制為多個線程分配 CPU 使用權
線程調度模型可以分為兩類，分別是 分時調度模型 和 搶占式調度模型。
分時調度模型：讓所有線程輪流獲取 CPU 的使用權，而且均分每個線程占用 CPU 的時間片，這種方式非常公平
搶占式調度模型：JVM 使用的是搶占式調度模型，讓優先級高的線程優先獲取到 CPU 的使用權，如果在可運行池當中的線程優先級都一樣，那就隨機選取一個
Android 的線程調度從兩個因素決定，一個是 nice 值（即線程優先級），一個是 cgroup（即線程調度策略）。
對于 nice 值來說，它首先是在 Process 中定義的，值越小，進程優先級越高，默認值是 THREAD_PRIORITY_DEFAULT = 0，主線程的優先級也是這個值。修改 nice 值只需要在對應的線程下設置即可：
public class MyRunnable implements Runnable {<!-- -->
@Override
public void run() {<!-- -->
Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT)
}
}
// 附上 setThreadPriority() 文檔說明
/**
* Set the priority of the calling thread, based on Linux priorities. See
* {@link #setThreadPriority(int, int)} for more information.
*
* @param priority A Linux priority level, from -20 for highest scheduling
* priority to 19 for lowest scheduling priority.
*
* @throws IllegalArgumentException Throws IllegalArgumentException if
* <var>tid</var> does not exist.
* @throws SecurityException Throws SecurityException if your process does
* not have permission to modify the given thread, or to use the given
* priority.
*
* @see #setThreadPriority(int, int)
*/
public static final native void setThreadPriority(int priority)
throws IllegalArgumentException, SecurityException;nice 值它還有其他的優先級可選：
public class Process {
/**
* Standard priority of application threads.
* Use with {@link #setThreadPriority(int)} and
* {@link #setThreadPriority(int, int)}, <b>not</b> with the normal
* {@link java.lang.Thread} class.
*/
public static final int THREAD_PRIORITY_DEFAULT = 0;
/**
* Lowest available thread priority. Only for those who really, really
* don't want to run if anything else is happening.
* Use with {@link #setThreadPriority(int)} and
* {@link #setThreadPriority(int, int)}, <b>not</b> with the normal
* {@link java.lang.Thread} class.
*/
public static final int THREAD_PRIORITY_LOWEST = 19;
/**
* Standard priority background threads. This gives your thread a slightly
* lower than normal priority, so that it will have less chance of impacting
* the responsiveness of the user interface.
* Use with {@link #setThreadPriority(int)} and
* {@link #setThreadPriority(int, int)}, <b>not</b> with the normal
* {@link java.lang.Thread} class.
*/
public static final int THREAD_PRIORITY_BACKGROUND = 10;
/**
* Standard priority of threads that are currently running a user interface
* that the user is interacting with. Applications can not normally
* change to this priority; the system will automatically adjust your
* application threads as the user moves through the UI.
* Use with {@link #setThreadPriority(int)} and
* {@link #setThreadPriority(int, int)}, <b>not</b> with the normal
* {@link java.lang.Thread} class.
*/
public static final int THREAD_PRIORITY_FOREGROUND = -2;
/**
* Standard priority of system display threads, involved in updating
* the user interface. Applications can not
* normally change to this priority.
* Use with {@link #setThreadPriority(int)} and
* {@link #setThreadPriority(int, int)}, <b>not</b> with the normal
* {@link java.lang.Thread} class.
*/
public static final int THREAD_PRIORITY_DISPLAY = -4;
/**
* Standard priority of the most important display threads, for compositing
* the screen and retrieving input events. Applications can not normally
* change to this priority.
* Use with {@link #setThreadPriority(int)} and
* {@link #setThreadPriority(int, int)}, <b>not</b> with the normal
* {@link java.lang.Thread} class.
*/
public static final int THREAD_PRIORITY_URGENT_DISPLAY = -8;
/**
* Standard priority of video threads. Applications can not normally
* change to this priority.
* Use with {@link #setThreadPriority(int)} and
* {@link #setThreadPriority(int, int)}, <b>not</b> with the normal
* {@link java.lang.Thread} class.
*/
public static final int THREAD_PRIORITY_VIDEO = -10;
/**
* Standard priority of audio threads. Applications can not normally
* change to this priority.
* Use with {@link #setThreadPriority(int)} and
* {@link #setThreadPriority(int, int)}, <b>not</b> with the normal
* {@link java.lang.Thread} class.
*/
public static final int THREAD_PRIORITY_AUDIO = -16;
/**
* Standard priority of the most important audio threads.
* Applications can not normally change to this priority.
* Use with {@link #setThreadPriority(int)} and
* {@link #setThreadPriority(int, int)}, <b>not</b> with the normal
* {@link java.lang.Thread} class.
*/
public static final int THREAD_PRIORITY_URGENT_AUDIO = -19;
/**
* Minimum increment to make a priority more favorable.
*/
public static final int THREAD_PRIORITY_MORE_FAVORABLE = -1;
/**
* Minimum increment to make a priority less favorable.
*/
public static final int THREAD_PRIORITY_LESS_FAVORABLE = +1;
}在實踐過程當中，如果只有 nice 值是不足夠的。比如有一個 app 它有1個前臺線程，而且它還有10個后臺線程，雖然后臺線程的優先級比較低，但是數量比較多，這10個后臺線程對 CPU 的消耗量是可以影響到前臺線程的性能的。所以 Android 需要一種機制來處理這種情況，也就是 cgroup。
Android 借鑒了 Linux 的 cgroup 來執行 更嚴格的前臺和后臺調度策略，后臺優先級的線程會被隱式的移動到后臺 group，而其他 group 的線程如果處于工作狀態，那么后臺這些線程它們將會被限制，只有很小的幾率能夠利用 CPU。
這種分離的調度策略既允許了后臺線程來執行一些任務，同時又不會對用戶可見的前臺線程造成很大的影響，讓前臺線程有更多的 CPU。
或許你會有疑問：哪些線程會被移到后臺 group？
第一種就是那些 手動設置了優先級比較低的線程
第二種就是 不在前臺運行的那些應用程序的線程
線程過多會導致 CPU 頻繁切換，降低線程運行效率。 在前面講解啟動優化的時候有強調要充足的利用線程比如異步啟動任務，但是線程也不能無限制的使用
正確認識任務重要性決定哪種優先級。 一般情況下線程工作量和優先級是成反比，比如線程的工作量越大，所做的工作沒那么重要，那這個線程的優先級應該越低
線程的優先級具有繼承性。 比如在 A 線程創建了 B 線程，在我們沒有指定線程優先級的情況下，B 線程的優先級是和 A 一樣的。所以我們在 UI 線程中創建線程，線程的優先級是和 UI 線程一樣的，這就會導致 UI 線程搶占 CPU 時間片的概率會變少
使用 Thread 創建線程是最簡單、常見的異步方式，但在實際項目中，它也就只有這個優點了，并不推薦直接使用 Thread 創建線程，主要有以下幾點原因：
不易復用，頻繁創建及銷毀開銷大
復雜場景不易使用
是 Android 提供的一個自帶消息循環的線程，它內部使用 串行的方式執行任務，比較 適合長時間運行，不斷從隊列中獲取任務的場景。
繼承了 Android Service 組件，內部創建了 HandlerThread，相比 Service 是在主線程執行，IntentService 是 在子線程異步執行不占用主線程，而且 優先級比較高，不易被系統 kill。
AsyncTask 是 Android 提供的工具類，內部的實現是使用了線程池，它比較大的好處是無需自己處理線程切換，但需要注意 AsyncTask 不同版本執行方式不一致的問題。
java 提供了線程池，在實際項目中比較推薦使用線程池的方式實現異步任務，它主要有以下優點：
易復用，減少線程頻繁創建、銷毀的時間
功能強大：定時、任務隊列、并發數控制等，java 提供了 Executors 工具類可以很方便的創建一個線程池，也可以自己定制線程池
RxJava 由強大的 Scheduler 集合提供，內部實際也是使用的線程池，它封裝的非常完善，可以根據任務類型的不同指定使用不同的線程池，比如 IO 密集型的任務可以指定 Schedulers.IO，CPU 密集型任務可以指定 Schedulers.Computation。
Single.just(xxx) .subscribeOn(Schedulers.IO) // 指定工作線程類型為 IO 密集型 .observeOn(AndroidSchedulers.mainThread()) // 指定下游接收所在線程 .subscribe();
嚴禁使用直接new Thread()的方式
提供基礎線程池供各個業務線使用： 避免各個業務線各自維護一套線程池，導致線程數過多
根據任務類型選擇合適的異步方式： 比如優先級低且長時間執行可以使用Handler Thread，再比如：有一個任務需要定時執行，使用線程池更適合
創建線程必須命名： 方便定位線程歸屬于哪一個業務方，在線程運行期可以使用Thread.currentThread().setName修改名字
關鍵異步任務監控： 異步不等于不耗時，如果一個任務在主線程需要耗費500ms，那么它在異步任務中至少需要500ms，因為異步任務中優先級較低，耗費時間很可能會高于500ms，所以這里可以使用AOP的方式來做監控，并且結合所在的業務場景，根據監控結果來適時的做一些相對應的調整
重視優先級設置： 使用Process.setThreadPriority();設置，并且可以設置多次
接下來針對線程池的使用來做一個簡單的實踐，還是打開我們之前的項目，這里說一下每次實踐的代碼都是基于第一篇啟動優化的那個案例上寫的。
首先新建一個包async，然后在包中創建一個類ThreadPoolUtils，這里我們創建可重用且固定線程數的線程池，核心數為5，并且對外暴露一個get方法，然后我們可以在任何地方都能獲取到這個全局的線程池：
public class ThreadPoolUtils {
//創建定長線程池，核心數為5
private static ExecutorService mService = Executors.newFixedThreadPool(5, new ThreadFactory() {
@Override
public Thread newThread(Runnable runnable) {
Thread thread = new Thread(runnable,"ThreadPoolUtils");//設置線程名
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); //設置線程優先級
return thread;
}
});
//獲取全局的線程池
public static ExecutorService getService(){
return mService;
}
}然后使用的時候就可以在你需要的地方直接調用了，并且你在使用的時候還可以修改線程的優先級以及線程名稱：
//使用全局統一的線程池
ThreadPoolUtils.getService().execute(new Runnable() {
@Override
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT); //修改線程優先級
String oldName = Thread.currentThread().getName();
Thread.currentThread().setName("Jarchie"); //修改線程名稱
Log.i("MainActivity","");
Thread.currentThread().setName(oldName); //將原有名稱改回去
}
});當你的項目做的越來越大的時候一般情況下線程都會變的非常多，最好是能夠對整體的線程數進行收斂，那么問題來了，如何知道某個線程是在哪里創建的呢？不僅僅是你自己的項目源碼，你依賴的第三方庫、aar中都有線程的創建，如果單靠人眼review代碼的方式，工作量很大而且你還不一定能找的全。
并且你這次優化完了線程數，你還要考慮其他人新加的線程是否合理，所以就需要能夠建立一套很好的監控預防手段。然后針對這些情況來做一個解決方案的總結分析，主要思想就是以下兩點：
創建線程的位置獲取堆棧
所有的異步方式，都會走到new Thread
解決方案：
特別適合Hook手段
找Hook點：構造函數或者特定方法
Thread的構造函數
可以在構造函數中加上自己的邏輯，獲取當前的調用棧信息，拿到調用棧信息之后，就可以分析看出某個線程是否使用的是統一的線程池，也可以知道某個線程具體屬于哪個業務方。
Epic簡介
Epic是一個虛擬機層面、以Java Method為粒度的運行時Hook框架
支持Android4.0-10.0（我的手機上程序出現了閃退，后來查找原因發現這個庫開源版本一些高版本手機好像不支持）
Epic使用
implementation 'me.weishu:epic:0.6.0'
繼承XC_MethodHook，實現相應邏輯
注入Hook：DexposedBridge.findAndHookMethod
代碼中使用
@Override
protected void attachBaseContext(Context base) {
super.attachBaseContext(base);
//Hook Thread類的構造函數,兩個參數：需要Hook的類，MethodHook的回調
DexposedBridge.hookAllConstructors(Thread.class, new XC_MethodHook() {
//afterHookedMethod是Hook此方法之后給我們的回調
@Override
protected void afterHookedMethod(MethodHookParam param) throws Throwable {
super.afterHookedMethod(param); //Hook完成之后會回調到這里
//實現自己的邏輯，param.thisObject可以拿到線程對象
Thread thread = (Thread) param.thisObject;
//Log.getStackTraceString打印當前的調用棧信息
Log.i(thread.getName() + "stack", Log.getStackTraceString(new Throwable()));
}
});
}如果你的手機支持的話，這個時候運行程序應該就可以看到線程打印出來的堆棧信息了
根據線程創建堆棧考量合理性，使用統一線程庫
各業務線需要移除自己的線程庫使用統一的線程庫
直接依賴線程庫
缺點：線程庫更新可能會導致基礎庫也跟著更新
基礎庫內部暴露API：setExecutor
初始化的時候注入統一的線程庫
舉個栗子：
比如這里有一個日志工具類，我們將它作為應用的日志基礎庫，假設它內部有一些異步操作，原始的情況下是它自己內部實現的，然后現在在它內部對外暴露一個API，如果外部注入了一個ExecutorService，那么我們就使用外部注入的這個，如果外部沒有注入，那就使用它默認的，代碼如下所示：
public class LogUtils {
private static ExecutorService mExecutorService;
public static void setExecutor(ExecutorService executorService){
mExecutorService = executorService;
}
public static final String TAG = "Jarchie";
public static void i(String msg){
if(Utils.isMainProcess(BaseApp.getApplication())){
Log.i(TAG,msg);
}
// 異步操作
if(mExecutorService != null){
mExecutorService.execute(() -> {
...
});
}else {
//使用原有的
...
}
}
}統一線程庫
區分任務類型：IO密集型、CPU密集型
IO密集型任務不消耗CPU，核心池可以很大（網絡請求、IO讀寫等）
CPU密集型任務：核心池大小和CPU核心數相關（如果并發數超過核心數會導致CPU頻繁切換，降低執行效率）
舉個栗子：根據上面的說明，可以做如下的設置：
//獲取CPU的核心數
private int CPUCOUNT = Runtime.getRuntime().availableProcessors();
//cpu線程池，核心數大小需要和cpu核心數相關聯，這里簡單的將它們保持一致了
private ThreadPoolExecutor cpuExecutor = new ThreadPoolExecutor(CPUCOUNT, CPUCOUNT,
30, TimeUnit.SECONDS, new LinkedBlockingDeque<>(), sThreadFactory);
//IO線程池，核心數64，這個數量可以針對自身項目再確定
private ThreadPoolExecutor iOExecutor = new ThreadPoolExecutor(64, 64,
30, TimeUnit.SECONDS, new LinkedBlockingDeque<>(), sThreadFactory);
//這里面使用了一個count作為標記
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable runnable) {
return new Thread(runnable, "ThreadPoolUtils #" + mCount.getAndIncrement());
}
};感謝各位的閱讀，以上就是“Android線程優化知識點有哪些”的內容了，經過本文的學習后，相信大家對Android線程優化知識點有哪些這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
