淺談Android中線程池的管理

發布時間：2020-09-09 20:53:53 來源：腳本之家閱讀：138 作者：堯沐欄目：移動開發

說到線程就要說說線程機制 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(); 
  } 
 } 
 }); 
 } 
 } 
}

這里只是簡單敘述了一下線程的管理的各種方法,后續還會針對鎖進行講解

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持億速云。

向AI問一下細節

中文字幕av专区_日韩电影在线播放_精品国产精品久久一区免费式_av在线免费观看网站

淺談Android中線程池的管理

猜你喜歡

中文字幕av专区_日韩电影在线播放_精品国产精品久久一区免费式_av在线免费观看网站

淺談Android中線程池的管理

猜你喜歡

最新資訊

相關推薦

相關標簽