Android 對於線程，線程池的操做
說到線程就要說說線程機制 Handler,Looper,MessageQueue 能夠說是三座大山了git
Handler
Handler 其實就是一個處理者，或者說一個發送者，它會把消息發送給消息隊列，也就是Looper，而後在一個無限循環隊列中進行取出消息的操做 mMyHandler.sendMessage(mMessage); 這句話就是我耗時操做處理完了，我發送過去了! 而後在接受的地方處理！簡單理解是否是很簡單。github
通常咱們在項目中異步操做都是怎麼作的呢？
// 這裏開啓一個子線程進行耗時操做
new Thread() {
@Override
public void run() {
.......
Message mMessage = new Message();
mMessage.what = 1;
//在這裏發送給消息隊列
mMyHandler.sendMessage(mMessage);
}
}.start();
/**
* 這裏就是處理的地方 經過msg.what進行處理分辨
*/
class MyHandler extends Handler{
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
//取出對應的消息進行處理
........
}
}
}
複製代碼
那麼咱們的消息隊列是在什麼地方啓動的呢?跟隨源碼看一看面試
# ActivityThread.main
public static void main(String[] args) {
//省略代碼。。。。。
//在這裏建立了一個消息隊列！
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
//這句我也沒有看懂 這不是一直都不會執行的麼
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
//消息隊列跑起來了！
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
複製代碼
public Handler(Callback callback, boolean async) {
mLooper = Looper.myLooper();
//注意看這裏拋出的異常 若是這裏mLooper==null
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
//獲取消息隊列
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
複製代碼
以上操做Android系統就獲取而且啓動了一個消息隊列，過多的源碼這裏不想去描述，免的佔用不少篇幅緩存
這裏說一下面試常見的一個問題，就是在子線程中可不能夠建立一個Handler，實際上是能夠的，可是誰這麼用啊- -
new Thread() {
Handler mHandler = null;
@Override
public void run() {
//在這裏獲取
Looper.prepare();
mHandler = new Handler();
//在這裏啓動
Looper.loop();
}
}.start();
複製代碼
多線程的建立
通常咱們在開發過程當中要開啓一個線程都是直接bash
new Thread() {
@Override
public void run() {
doing.....
}
}.start();
複製代碼
new Thread(new Runnable() {
@Override
public void run() {
doing.....
}
}).start();
複製代碼
注意看，一個傳遞了Runnable對象，另外一個沒有,可是這兩個有什麼不一樣，爲何要衍生出2個呢？ 這裏不去看源碼，簡單敘述一下，實際上Thread是Runnabled的一個包裝實現類，Runnable只有一個方法，就是run(),在這裏之前也想過，爲何Runnable只有一個方法呢，後來的某一次交談中也算是找到一個答案，多是由於多拓展，可能JAVA語言想拓展一些其餘的東西，之後就直接在Runnable再寫了。否則我是沒有想到另外一答案爲何都要傳遞一個Runnable,可能就像咱們開發中的baseActivity同樣吧多線程
線程經常使用的操做方法併發
- wait() 當一個線程執行到了wait() 就會進去一個和對象有關的等待池中，同時失去了釋放當前對象的機所，使其餘線程能夠訪問，也就是讓其餘線程能夠調用notify()喚醒
- sleep() 調用得線程進入睡眠狀態，不能該改變對象的機鎖，其餘線程不能訪問
- join() 就等本身完事
- yidld 你急你先來
簡單的白話敘述其實也就是這樣，但願能看看demo而後理解一下。異步
一些其餘的方法，Callable,Future,FutureTaskasync
Runnable是線程管理的拓展接口，不能夠運用於線程池,因此你總要有方法能夠在線程池中管理啊因此Callable,Future,FutureTask就是能夠在線程池中開啓線程的接口。ide
Future定義了規範的接口，如get(),isDone(),isCancelled()...FutureTask是他的實現類這裏簡單說一下他的用法
/**
* ================================================
* 做 者：夏沐堯 Github地址：https://github.com/XiaMuYaoDQX
* 版 本：1.0
* 建立日期： 2018/1/10
* 描 述：
* 修訂歷史：
* ================================================
*/
class FutureDemo {
//建立一個單例線程
static ExecutorService mExecutor = Executors.newSingleThreadScheduledExecutor();
public static void main(String[] args) throws ExecutionException, InterruptedException {
ftureWithRunnable();
ftureWithCallable();
ftureTask();
}
/**
* 沒有指定返回值，因此返回的是null,向線程池中提交的是Runnable
*
* @throws ExecutionException
* @throws InterruptedException
*/
private static void ftureWithRunnable() throws ExecutionException, InterruptedException {
Future<?> result1 = mExecutor.submit(new Runnable() {
@Override
public void run() {
fibc(20);
System.out.println(Thread.currentThread().getName());
}
});
System.out.println("Runnable" + result1.get());
}
/**
* 提交了Callable，有返回值，能夠獲取阻塞線程獲取到數值
*
* @throws ExecutionException
* @throws InterruptedException
*/
private static void ftureWithCallable() throws ExecutionException, InterruptedException {
Future<Integer> result2 = mExecutor.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName());
return fibc(20);
}
});
System.out.println("Callable" + result2.get());
}
/**
* 提交的futureTask對象
* @throws ExecutionException
* @throws InterruptedException
*/
private static void ftureTask() throws ExecutionException, InterruptedException {
FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName());
return fibc(20);
}
});
mExecutor.submit(futureTask);
System.out.println("futureTask" + futureTask.get());
}
private static int fibc(int num) {
if (num == 0) {
return 0;
}
if (num == 1) {
return 1;
}
return fibc(num - 1) + fibc(num - 2);
}
}
複製代碼
線程池
Java經過Executors提供線程池，分別爲：
- newCachedThreadPool建立一個可緩存線程池，若是線程池長度超過處理須要，可靈活回收空閒線程，若無可回收，則新建線程。
- newFixedThreadPool 建立一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。
- newScheduledThreadPool 建立一個定長線程池，支持定時及週期性任務執行。
- newSingleThreadExecutor 建立一個單線程化的線程池，它只會用惟一的工做線程來執行任務，保證全部任務按照指定順序(FIFO, LIFO, 優先級)執行。
示例代碼
- newCachedThreadPool 建立一個可緩存線程池，若是線程池長度超過處理須要，可靈活回收空閒線程，若無可回收，則新建線程。示例代碼以下：
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable() {
public void run() {
System.out.println(index);
}
});
}
}
}
線程池爲無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的線程，而不用每次新建線程。
複製代碼
- newFixedThreadPool 建立一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。示例代碼以下：
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
由於線程池大小爲3，每一個任務輸出index後sleep 2秒，因此每兩秒打印3個數字。
定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()
複製代碼
- newScheduledThreadPool 建立一個定長線程池，支持定時及週期性任務執行。延遲執行示例代碼以下：
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
}
}
表示延遲3秒執行。
複製代碼
按期執行示例代碼以下：
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);
}
}
表示延遲1秒後每3秒執行一次。
複製代碼
- newSingleThreadExecutor
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
複製代碼
這裏只是簡單敘述了一下線程的管理的各類方法,後續還會針對鎖進行講解 2018年1月17日下午8:19說到線程就要說說線程機制 Handler,Looper,MessageQueue 能夠說是三座大山了
Handler
Handler 其實就是一個處理者，或者說一個發送者，它會把消息發送給消息隊列，也就是Looper，而後在一個無限循環隊列中進行取出消息的操做 mMyHandler.sendMessage(mMessage); 這句話就是我耗時操做處理完了，我發送過去了! 而後在接受的地方處理！簡單理解是否是很簡單。
通常咱們在項目中異步操做都是怎麼作的呢？
// 這裏開啓一個子線程進行耗時操做
new Thread() {
@Override
public void run() {
.......
Message mMessage = new Message();
mMessage.what = 1;
//在這裏發送給消息隊列
mMyHandler.sendMessage(mMessage);
}
}.start();
/**
* 這裏就是處理的地方 經過msg.what進行處理分辨
*/
class MyHandler extends Handler{
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
//取出對應的消息進行處理
........
}
}
}
複製代碼
那麼咱們的消息隊列是在什麼地方啓動的呢?跟隨源碼看一看
# ActivityThread.main
public static void main(String[] args) {
//省略代碼。。。。。
//在這裏建立了一個消息隊列！
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
//這句我也沒有看懂 這不是一直都不會執行的麼
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
//消息隊列跑起來了！
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
複製代碼
public Handler(Callback callback, boolean async) {
mLooper = Looper.myLooper();
//注意看這裏拋出的異常 若是這裏mLooper==null
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
//獲取消息隊列
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
複製代碼
以上操做Android系統就獲取而且啓動了一個消息隊列，過多的源碼這裏不想去描述，免的佔用不少篇幅
這裏說一下面試常見的一個問題，就是在子線程中可不能夠建立一個Handler，實際上是能夠的，可是誰這麼用啊- -
new Thread() {
Handler mHandler = null;
@Override
public void run() {
//在這裏獲取
Looper.prepare();
mHandler = new Handler();
//在這裏啓動
Looper.loop();
}
}.start();
複製代碼
多線程的建立
通常咱們在開發過程當中要開啓一個線程都是直接
new Thread() {
@Override
public void run() {
doing.....
}
}.start();
複製代碼
new Thread(new Runnable() {
@Override
public void run() {
doing.....
}
}).start();
複製代碼
注意看，一個傳遞了Runnable對象，另外一個沒有,可是這兩個有什麼不一樣，爲何要衍生出2個呢？ 這裏不去看源碼，簡單敘述一下，實際上Thread是Runnabled的一個包裝實現類，Runnable只有一個方法，就是run(),在這裏之前也想過，爲何Runnable只有一個方法呢，後來的某一次交談中也算是找到一個答案，多是由於多拓展，可能JAVA語言想拓展一些其餘的東西，之後就直接在Runnable再寫了。否則我是沒有想到另外一答案爲何都要傳遞一個Runnable,可能就像咱們開發中的baseActivity同樣吧
線程經常使用的操做方法
- wait() 當一個線程執行到了wait() 就會進去一個和對象有關的等待池中，同時失去了釋放當前對象的機所，使其餘線程能夠訪問，也就是讓其餘線程能夠調用notify()喚醒
- sleep() 調用得線程進入睡眠狀態，不能該改變對象的機鎖，其餘線程不能訪問
- join() 就等本身完事
- yidld 你急你先來
簡單的白話敘述其實也就是這樣，但願能看看demo而後理解一下。
一些其餘的方法，Callable,Future,FutureTask
Runnable是線程管理的拓展接口，不能夠運用於線程池,因此你總要有方法能夠在線程池中管理啊因此Callable,Future,FutureTask就是能夠在線程池中開啓線程的接口。
Future定義了規範的接口，如get(),isDone(),isCancelled()...FutureTask是他的實現類這裏簡單說一下他的用法
/**
* ================================================
* 做 者：夏沐堯 Github地址：https://github.com/XiaMuYaoDQX
* 版 本：1.0
* 建立日期： 2018/1/10
* 描 述：
* 修訂歷史：
* ================================================
*/
class FutureDemo {
//建立一個單例線程
static ExecutorService mExecutor = Executors.newSingleThreadScheduledExecutor();
public static void main(String[] args) throws ExecutionException, InterruptedException {
ftureWithRunnable();
ftureWithCallable();
ftureTask();
}
/**
* 沒有指定返回值，因此返回的是null,向線程池中提交的是Runnable
*
* @throws ExecutionException
* @throws InterruptedException
*/
private static void ftureWithRunnable() throws ExecutionException, InterruptedException {
Future<?> result1 = mExecutor.submit(new Runnable() {
@Override
public void run() {
fibc(20);
System.out.println(Thread.currentThread().getName());
}
});
System.out.println("Runnable" + result1.get());
}
/**
* 提交了Callable，有返回值，能夠獲取阻塞線程獲取到數值
*
* @throws ExecutionException
* @throws InterruptedException
*/
private static void ftureWithCallable() throws ExecutionException, InterruptedException {
Future<Integer> result2 = mExecutor.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName());
return fibc(20);
}
});
System.out.println("Callable" + result2.get());
}
/**
* 提交的futureTask對象
* @throws ExecutionException
* @throws InterruptedException
*/
private static void ftureTask() throws ExecutionException, InterruptedException {
FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName());
return fibc(20);
}
});
mExecutor.submit(futureTask);
System.out.println("futureTask" + futureTask.get());
}
private static int fibc(int num) {
if (num == 0) {
return 0;
}
if (num == 1) {
return 1;
}
return fibc(num - 1) + fibc(num - 2);
}
}
複製代碼
線程池
Java經過Executors提供線程池，分別爲：
- newCachedThreadPool建立一個可緩存線程池，若是線程池長度超過處理須要，可靈活回收空閒線程，若無可回收，則新建線程。
- newFixedThreadPool 建立一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。
- newScheduledThreadPool 建立一個定長線程池，支持定時及週期性任務執行。
- newSingleThreadExecutor 建立一個單線程化的線程池，它只會用惟一的工做線程來執行任務，保證全部任務按照指定順序(FIFO, LIFO, 優先級)執行。
示例代碼
- newCachedThreadPool 建立一個可緩存線程池，若是線程池長度超過處理須要，可靈活回收空閒線程，若無可回收，則新建線程。示例代碼以下：
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable() {
public void run() {
System.out.println(index);
}
});
}
}
}
線程池爲無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的線程，而不用每次新建線程。
複製代碼
- newFixedThreadPool 建立一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。示例代碼以下：
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
由於線程池大小爲3，每一個任務輸出index後sleep 2秒，因此每兩秒打印3個數字。
定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()
複製代碼
- newScheduledThreadPool 建立一個定長線程池，支持定時及週期性任務執行。延遲執行示例代碼以下：
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
}
}
表示延遲3秒執行。
複製代碼
按期執行示例代碼以下：
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);
}
}
表示延遲1秒後每3秒執行一次。
複製代碼
- newSingleThreadExecutor
public class ThreadPoolExecutorTest {
public static void main(String[] args) {
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
複製代碼
這裏只是簡單敘述了一下線程的管理的各類方法,後續還會針對鎖進行講解 2018年1月17日下午8:19
相關文章
- 1. Android多線程操做——線程池管理綜述
- 2. Android線程與線程池
- 3. Android 線程池
- 4. Android的線程和線程池
- 5. （十五）Android的線程和線程池
- 6. android 中的線程和線程池
- 7. Android多線程編程__線程池(ThreadPoolExector)
- 8. 淺談線程池（上）：線程池的做用及CLR線程池
- 9. 淺談線程池（中）：獨立線程池的做用及IO線程池
- 10. android UI跨線程操做
- 更多相關文章...
- • C# 多線程 - C#教程
- • SVG 漸變 - 線性 - SVG 教程
- • 適用於PHP初學者的學習線路和建議
- • TiDB 在摩拜單車在線數據業務的應用和實踐
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 「插件」Runner更新Pro版，幫助設計師遠離996
- 2. 錯誤 707 Could not load file or assembly ‘Newtonsoft.Json, Version=12.0.0.0, Culture=neutral, PublicKe
- 3. Jenkins 2018 報告速覽，Kubernetes使用率躍升235%！
- 4. TVI-Android技術篇之註解Annotation
- 5. android studio啓動項目
- 6. Android的ADIL
- 7. Android卡頓的檢測及優化方法彙總（線下+線上）
- 8. 登錄註冊的業務邏輯流程梳理
- 9. NDK(1)創建自己的C/C++文件
- 10. 小菜的系統框架界面設計-你的評估是我的決策
歡迎關注本站公眾號,獲取更多信息
