android進程線程
① android 一個進程 多少個線程
一個程序可以有很多進程，一個進程可以包含多個線程。我們在寫程序的時候，一般要用到並發，這里講的是線程。
② Android中的線程狀態 - AsyncTask詳解
在操作系統中，線程是操作系統調度的最小單元，同時線程又是一種受限的系統資源，即線程不可能無限制地產生，並且 線程的創建和銷毀都會有相應的開銷。 當系統中存在大量的線程時，系統會通過會時間片輪轉的方式調度每個線程，因此線程不可能做到絕對的並行。
如果在一個進程中頻繁地創建和銷毀線程，顯然不是高效的做法。正確的做法是採用線程池，一個線程池中會緩存一定數量的線程，通過線程池就可以避免因為頻繁創建和銷毀線程所帶來的系統開銷。
AsyncTask是一個抽象類，它是由Android封裝的一個輕量級非同步類（輕量體現在使用方便、代碼簡潔），它可以在線程池中執行後台任務，然後把執行的進度和最終結果傳遞給主線程並在主線程中更新UI。
AsyncTask的內部封裝了 兩個線程池 (SerialExecutor和THREAD_POOL_EXECUTOR)和 一個Handler (InternalHandler)。
其中 SerialExecutor線程池用於任務的排隊，讓需要執行的多個耗時任務，按順序排列 ， THREAD_POOL_EXECUTOR線程池才真正地執行任務 ， InternalHandler用於從工作線程切換到主線程 。
1.AsyncTask的泛型參數
AsyncTask是一個抽象泛型類。
其中，三個泛型類型參數的含義如下：
Params： 開始非同步任務執行時傳入的參數類型；
Progress： 非同步任務執行過程中，返回下載進度值的類型；
Result： 非同步任務執行完成後，返回的結果類型；
如果AsyncTask確定不需要傳遞具體參數，那麼這三個泛型參數可以用Void來代替。
有了這三個參數類型之後，也就控制了這個AsyncTask子類各個階段的返回類型，如果有不同業務，我們就需要再另寫一個AsyncTask的子類進行處理。
2.AsyncTask的核心方法
onPreExecute()
這個方法會在 後台任務開始執行之間調用，在主線程執行。 用於進行一些界面上的初始化操作，比如顯示一個進度條對話框等。
doInBackground(Params...)
這個方法中的所有代碼都會 在子線程中運行，我們應該在這里去處理所有的耗時任務。
任務一旦完成就可以通過return語句來將任務的執行結果進行返回，如果AsyncTask的第三個泛型參數指定的是Void，就可以不返回任務執行結果。 注意，在這個方法中是不可以進行UI操作的，如果需要更新UI元素，比如說反饋當前任務的執行進度，可以調用publishProgress(Progress...)方法來完成。
onProgressUpdate(Progress...)
當在後台任務中調用了publishProgress(Progress...)方法後，這個方法就很快會被調用，方法中攜帶的參數就是在後台任務中傳遞過來的。 在這個方法中可以對UI進行操作，在主線程中進行，利用參數中的數值就可以對界面元素進行相應的更新。
onPostExecute(Result)
當doInBackground(Params...)執行完畢並通過return語句進行返回時，這個方法就很快會被調用。返回的數據會作為參數傳遞到此方法中， 可以利用返回的數據來進行一些UI操作，在主線程中進行，比如說提醒任務執行的結果，以及關閉掉進度條對話框等。
上面幾個方法的調用順序：
onPreExecute() --> doInBackground() --> publishProgress() --> onProgressUpdate() --> onPostExecute()
如果不需要執行更新進度則為onPreExecute() --> doInBackground() --> onPostExecute(),
除了上面四個方法，AsyncTask還提供了onCancelled()方法， 它同樣在主線程中執行，當非同步任務取消時，onCancelled()會被調用，這個時候onPostExecute()則不會被調用 ，但是要注意的是， AsyncTask中的cancel()方法並不是真正去取消任務，只是設置這個任務為取消狀態，我們需要在doInBackground()判斷終止任務。就好比想要終止一個線程，調用interrupt()方法，只是進行標記為中斷，需要在線程內部進行標記判斷然後中斷線程。
3.AsyncTask的簡單使用
這里我們模擬了一個下載任務，在doInBackground()方法中去執行具體的下載邏輯，在onProgressUpdate()方法中顯示當前的下載進度，在onPostExecute()方法中來提示任務的執行結果。如果想要啟動這個任務，只需要簡單地調用以下代碼即可：
4.使用AsyncTask的注意事項
①非同步任務的實例必須在UI線程中創建，即AsyncTask對象必須在UI線程中創建。
②execute(Params... params)方法必須在UI線程中調用。
③不要手動調用onPreExecute()，doInBackground(Params... params)，onProgressUpdate(Progress... values)，onPostExecute(Result result)這幾個方法。
④不能在doInBackground(Params... params)中更改UI組件的信息。
⑤一個任務實例只能執行一次，如果執行第二次將會拋出異常。
先從初始化一個AsyncTask時，調用的構造函數開始分析。
這段代碼雖然看起來有點長，但實際上並沒有任何具體的邏輯會得到執行，只是初始化了兩個變數，mWorker和mFuture，並在初始化mFuture的時候將mWorker作為參數傳入。mWorker是一個Callable對象，mFuture是一個FutureTask對象，這兩個變數會暫時保存在內存中，稍後才會用到它們。 FutureTask實現了Runnable介面，關於這部分內容可以看這篇文章。
mWorker中的call()方法執行了耗時操作，即result = doInBackground(mParams);,然後把執行得到的結果通過postResult(result);,傳遞給內部的Handler跳轉到主線程中。在這里這是實例化了兩個變數，並沒有開啟執行任務。
那麼mFuture對象是怎麼載入到線程池中，進行執行的呢？
接著如果想要啟動某一個任務，就需要調用該任務的execute()方法，因此現在我們來看一看execute()方法的源碼，如下所示：
調用了executeOnExecutor()方法,具體執行邏輯在這個方法裡面：
可以 看出，先執行了onPreExecute()方法，然後具體執行耗時任務是在exec.execute(mFuture)，把構造函數中實例化的mFuture傳遞進去了。
exec具體是什麼？
從上面可以看出具體是sDefaultExecutor，再追溯看到是SerialExecutor類，具體源碼如下：
終於追溯到了調用了SerialExecutor 類的execute方法。SerialExecutor 是個靜態內部類，是所有實例化的AsyncTask對象公有的，SerialExecutor 內部維持了一個隊列，通過鎖使得該隊列保證AsyncTask中的任務是串列執行的，即多個任務需要一個個加到該隊列中，然後執行完隊列頭部的再執行下一個，以此類推。
在這個方法中，有兩個主要步驟。
①向隊列中加入一個新的任務，即之前實例化後的mFuture對象。
②調用 scheleNext()方法，調用THREAD_POOL_EXECUTOR執行隊列頭部的任務。
由此可見SerialExecutor 類僅僅為了保持任務執行是串列的，實際執行交給了THREAD_POOL_EXECUTOR。
THREAD_POOL_EXECUTOR又是什麼？
實際是個線程池，開啟了一定數量的核心線程和工作線程。然後調用線程池的execute()方法。執行具體的耗時任務，即開頭構造函數中mWorker中call()方法的內容。先執行完doInBackground()方法，又執行postResult()方法，下面看該方法的具體內容：
該方法向Handler對象發送了一個消息，下面具體看AsyncTask中實例化的Hanlder對象的源碼：
在InternalHandler 中，如果收到的消息是MESSAGE_POST_RESULT，即執行完了doInBackground()方法並傳遞結果，那麼就調用finish()方法。
如果任務已經取消了，回調onCancelled()方法，否則回調 onPostExecute()方法。
如果收到的消息是MESSAGE_POST_PROGRESS，回調onProgressUpdate()方法，更新進度。
InternalHandler是一個靜態類，為了能夠將執行環境切換到主線程，因此這個類必須在主線程中進行載入。所以變相要求AsyncTask的類必須在主線程中進行載入。
到此為止，從任務執行的開始到結束都從源碼分析完了。
AsyncTask的串列和並行
從上述源碼分析中分析得到，默認情況下AsyncTask的執行效果是串列的，因為有了SerialExecutor類來維持保證隊列的串列。如果想使用並行執行任務，那麼可以直接跳過SerialExecutor類，使用executeOnExecutor()來執行任務。
四、AsyncTask使用不當的後果
1.）生命周期
AsyncTask不與任何組件綁定生命周期，所以在Activity/或者Fragment中創建執行AsyncTask時，最好在Activity/Fragment的onDestory()調用 cancel(boolean)；
2.)內存泄漏
3.) 結果丟失
屏幕旋轉或Activity在後台被系統殺掉等情況會導致Activity的重新創建，之前運行的AsyncTask（非靜態的內部類）會持有一個之前Activity的引用，這個引用已經無效，這時調用onPostExecute()再去更新界面將不再生效。
自己是從事了七年開發的Android工程師，不少人私下問我，2019年Android進階該怎麼學，方法有沒有？
沒錯，年初我花了一個多月的時間整理出來的學習資料，希望能幫助那些想進階提升Android開發，卻又不知道怎麼進階學習的朋友。【 包括高級UI、性能優化、架構師課程、NDK、Kotlin、混合式開發（ReactNative+Weex）、Flutter等架構技術資料 】，希望能幫助到您面試前的復習且找到一個好的工作，也節省大家在網上搜索資料的時間來學習。
③ 每個Android 都應必須了解的多線程知識點~
進程是系統調度和資源分配的一個獨立單位。
在Android中，一個應用程序就是一個獨立的集成，應用運行在一個獨立的環境中，可以避免其他應用程序/進程的干擾。當我們啟動一個應用程序時，系統就會創建一個進程（該進程是從Zygote中fork出來的，有獨立的ID），接著為這個進程創建一個主線程，然後就可以運行MainActivity了，應用程序的組件默認都是運行在其進程中。開發者可以通過設置應用的組件的運行進程，在清單文件中給組件設置：android:process = "進程名";可以達到讓組件運行在不同進程中的目的。讓組件運行在不同的進程中，既有好處，也有壞處。我們依次的說明下。
好處：每一個應用程序（也就是每一個進程）都會有一個內存預算，所有運行在這個進程中的程序使用的總內存不能超過這個值，讓組件運行不同的進程中，可以讓主進程可以擁有更多的空間資源。當我們的應用程序比較大，需要的內存資源比較多時（也就是用戶會抱怨應用經常出現OutOfMemory時），可以考慮使用多進程。
壞處：每個進程都會有自己的虛擬機實例，因此讓在進程間共享一些數據變得相對困難，需要採用進程間的通信來實現數據的共享。
線程是進程的一個實體，是CPU調度和分派的基本單位，它是比進程更小的能獨立運行的基本單位。
在Android中，線程會有那麼幾種狀態：創建、就緒、運行、阻塞、結束。當應用程序有組件在運行時，UI線程是處於運行狀態的。默認情況下，應用的所有組件的操作都是在UI線程里完成的，包括響應用戶的操作（觸摸，點擊等），組件生命周期方法的調用，UI的更新等。因此如果UI線程處理阻塞狀態時(在線程里做一些耗時的操作，如網路連接等)，就會不能響應各種操作，如果阻塞時間達到5秒，就會讓程序處於ANR（application not response）狀態。
1.線程作用
減少程序在並發執行時所付出的時空開銷，提高操作系統的並發性能。
2.線程分類
守護線程、非守護線程（用戶線程）
2.1 守護線程
定義：守護用戶線程的線程，即在程序運行時為其他線程提供一種通用服務
常見：如垃圾回收線程
設置方式：thread.setDaemon(true);//設置該線程為守護線程
2.2 非守護線程（用戶線程）
主線程 & 子線程。
2.2.1 主線程（UI線程）
定義：Android系統在程序啟動時會自動啟動一條主線程
作用：處理四大組件與用戶進行交互的事情（如UI、界面交互相關）
因為用戶隨時會與界面發生交互，因此主線程任何時候都必須保持很高的響應速度，所以主線程不允許進行耗時操作，否則會出現ANR。
2.2.2 子線程（工作線程）
定義：手動創建的線程
作用：耗時的操作（網路請求、I/O操作等）
2.3 守護線程與非守護線程的區別和聯系
區別：虛擬機是否已退出，即
a. 當所有用戶線程結束時，因為沒有守護的必要，所以守護線程也會終止，虛擬機也同樣退出
b. 反過來，只要任何用戶線程還在運行，守護線程就不會終止，虛擬機就不會退出
3.線程優先順序
3.1 表示
線程優先順序分為10個級別，分別用Thread類常量表示。
3.2 設置
通過方法setPriority(int grade)進行優先順序設置，默認線程優先順序是5，即 Thread.NORM_PRIORITY。
4.線程狀態
創建狀態：當用 new 操作符創建一個線程的時候
就緒狀態：調用 start 方法，處於就緒狀態的線程並不一定馬上就會執行 run 方法，還需要等待CPU的調度
運行狀態：CPU 開始調度線程，並開始執行 run 方法
阻塞（掛起）狀態：線程的執行過程中由於一些原因進入阻塞狀態，比如：調用 sleep/wait 方法、嘗試去得到一個鎖等
結束（消亡）狀態：run 方法執行完 或者 執行過程中遇到了一個異常
（1）start()和run()的區別
通過調用Thread類的start()方法來啟動一個線程，這時此線程是處於就緒狀態，並沒有運行。調用Thread類調用run()方法來完成其運行操作的，方法run()稱為線程體，它包含了要執行的這個線程的內容，run()運行結束，此線程終止，然後CPU再調度其它線程。
（2）sleep()、wait()、yield()的區別
sleep()方法屬於Thread類，wait()方法屬於Object類。
調用sleep()方法，線程不會釋放對象鎖，只是暫停執行指定的時間，會自動恢復運行狀態；調用wait()方法，線程會放棄對象鎖，進入等待此對象的等待鎖定池，不調用notify()方法，線程永遠處於就緒（掛起）狀態。
yield()直接由運行狀態跳回就緒狀態，表示退讓線程，讓出CPU，讓CPU調度器重新調度。禮讓可能成功，也可能不成功，也就是說，回到調度器和其他線程進行公平競爭。
1.Android線程的原則
（1）為什麼不能再主線程中做耗時操作
防止ANR, 不能在UI主線程中做耗時的操作，因此我們可以把耗時的操作放在另一個工作線程中去做。操作完成後，再通知UI主線程做出相應的響應。這就需要掌握線程間通信的方式了。 在Android中提供了兩種線程間的通信方式：一種是AsyncTask機制，另一種是Handler機制。
（2）為什麼不能在非UI線程中更新UI 因為Android的UI線程是非線程安全的，應用更新UI，是調用invalidate()方法來實現界面的重繪，而invalidate()方法是非線程安全的，也就是說當我們在非UI線程來更新UI時，可能會有其他的線程或UI線程也在更新UI，這就會導致界面更新的不同步。因此我們不能在非UI主線程中做更新UI的操作。
2.Android實現多線程的幾種方式
3.為何需要多線程
多線程的本質就是非同步處理，直觀一點說就是不要讓用戶感覺到「很卡」。
4.多線程機制的核心是啥
多線程核心機制是Handler
推薦Handler講解視頻： 面試總被問到Handler？帶你從源碼的角度解讀Handler核心機制
根據上方提到的 多進程、多線程、Handler 問題，我整理了一套 Binder與Handler 機制解析的學習文檔，提供給大家進行學習參考，有需要的可以 點擊這里直接獲取！！！ 裡面記錄許多Android 相關學習知識點。
④ Android一個APP裡面最少有幾個線程
https://www.jianshu.com/p/92bff8d6282f
https://www.jianshu.com/p/8a820d93c6aa
Android一個進程裡面最少包含5個線程，分別為：
下圖是創建的一個僅有hello World！頁面的工程，線程包含以下的這些。
查看 VMRuntime 的源碼發現 startHeapTaskProcessor()、runHeapTasks()均是native方法。
在Android studio中點擊 Profile 圖標，點擊 CPU ，顯示如下圖，點擊 Record ，然後再點擊 Stop ，即可生成。
⑤ Android進程和線程的區別
Android進程和線程的區別
下面我先介紹下Android進程和線程各是什麼，然後再一一比較區別下
Android進程基本知識：
當一個程序第一次啟動的時候，Android會啟動一個LINUX進程和一個主線程。默認的情況下，所有該程序的組件都將在該進程和線程中運行。 同時，Android會為每個應用程序分配一個單獨的LINUX用戶。Android會盡量保留一個正在運行進程，只在內存資源出現不足時，Android會嘗試停止一些進程從而釋放足夠的資源給其他新的進程使用， 也能保證用戶正在訪問的當前進程有足夠的資源去及時地響應用戶的事件。
我們可以將一些組件運行在其他進程中，並且可以為任意的進程添加線程。組件運行在哪個進程中是在manifest文件里設置的，其中<Activity>，<Service>，<receiver>和<provider>都有一個process屬性來指定該組件運行在哪個進程之中。我們可以設置這個屬性，使得每個組件運行在它們自己的進程中，或是幾個組件共同享用一個進程，或是不共同享用。<application>元素也有一個process屬性，用來指定所有的組件的默認屬性。
Android中的所有組件都在指定的進程中的主線程中實例化的，對組件的系統調用也是由主線程發出的。每個實例不會建立新的線程。對系統調用進行響應的方法——例如負責執行用戶動作的View.onKeyDown()和組件的生命周期函數——都是運行在這個主線程中的。這意味著當系統調用這個組件時，這個組件不能長時間的阻塞主線程。例如進行網路操作時或是更新UI時，如果運行時間較長，就不能直接在主線程中運行，因為這樣會阻塞這個進程中其他的組件，我們可以將這樣的組件分配到新建的線程中或是其他的線程中運行。
Android會根據進程中運行的組件類別以及組件的狀態來判斷該進程的重要性，Android會首先停止那些不重要的進程。按照重要性從高到低一共有五個級別：
1.1前台進程
前台進程是用戶當前正在使用的進程。只有一些前台進程可以在任何時候都存在。他們是最後一個被結束的，當內存低到根本連他們都不能運行的時候。一般來說， 在這種情況下，設備會進行內存調度，中止一些前台進程來保持對用戶交互的響應。
1.2可見進程
可見進程不包含前台的組件但是會在屏幕上顯示一個可見的進程是的重要程度很高，除非前台進程需要獲取它的資源，不然不會被中止。
1.3服務進程
運行著一個通過startService() 方法啟動的service，這個service不屬於上面提到的2種更高重要性的。service所在的進程雖然對用戶不是直接可見的，但是他們執行了用戶非常關注的任務（比如播放mp3，從網路下載數據）。只要前台進程和可見進程有足夠的內存，系統不會回收他們。
1.4後台進程
運行著一個對用戶不可見的activity（調用過 onStop() 方法).這些進程對用戶體驗沒有直接的影響，可以在服務進程、可見進程、前台進 程需要內存的時候回收。通常，系統中會有很多不可見進程在運行，他們被保存在LRU (least recently used) 列表中，以便內存不足的時候被第一時間回收。如果一個activity正 確的執行了它的生命周期，關閉這個進程對於用戶體驗沒有太大的影響。
1.5空進程
未運行任何程序組件。運行這些進程的唯一原因是作為一個緩存，縮短下次程序需要重新使用的啟動時間。系統經常中止這些進程，這樣可以調節程序緩存和系統緩存的平衡。
單線程模型
線程在代碼是使用標準的java Thread對象來建立，那麼在Android系統中提供了一系列方便的類來管理線程——Looper用來在一個線程中執行消息循環，Handler用來處理消息，HandlerThread創建帶有消息循環的線程。具體可以看下面的詳細介紹。
當一個程序第一次啟動時，Android會同時啟動一個對應的主線程（Main Thread），主線程主要負責處理與UI相關的事件，如用戶的按鍵事件，用戶接觸屏幕的事件以及屏幕繪圖事件，並把相關的事件分發到對應的組件進行處理。所以主線程通常又被叫做UI線程。
在開發Android應用時必須遵守單線程模型的原則： Android UI操作並不是線程安全的並且這些操作必須在UI線程中執行。
2.1 子線程更新UI Android的UI是單線程(Single-threaded)的。
為了避免拖住GUI，一些較費時的對象應該交給獨立的線程去執行。如果幕後的線程來執行UI對象，Android就會發出錯誤訊息 。以後遇到這樣的異常拋出時就要知道怎麼回事了！
2.2 Message Queue
在單線程模型下，為了解決類似的問題，Android設計了一個Message Queue(消息隊列)， 線程間可以通過該Message Queue並結合Handler和Looper組件進行信息交換。下面將對它們進行分別介紹：
2..3 Message 消息
理解為線程間交流的信息，處理數據後台線程需要更新UI，則發送Message內含一些數據給UI線程。
2.4. Handler 處理者
是Message的主要處理者，負責Message的發送，Message內容的執行處理。後台線程就是通過傳進來的Handler對象引用來sendMessage(Message)。而使用Handler，需要implement 該類的 handleMessage(Message) 方法，它是處理這些Message的操作內容，例如Update UI。通常需要子類化Handler來實現handleMessage方法。
2.5. Message Queue 消息隊列
用來存放通過Handler發布的消息，按照先進先出執行。 每個message queue都會有一個對應的Handler。Handler會向message queue通過兩種方法發送消息：sendMessage或post。這兩種消息都會插在message queue隊尾並按先進先出執行。但通過這兩種方法發送的消息執行的方式略有不同：通過sendMessage發送的是一個message對象,會被Handler的handleMessage()函數處理；而通過post方法發送的是一個runnable對象，則會自己執行。
2.6 Looper Looper是每條線程里的Message Queue的管家。
Android沒有Global的Message Queue，而Android會自動替主線程(UI線程)建立Message Queue，但在子線程里並沒有建立Message Queue。所以調用Looper.getMainLooper()得到的主線程的Looper不為NULL，但調用Looper.myLooper()得到當前線程的Looper就有可能為NULL。
從以上幾點，不難看出Android進程和線程的二者的區別所在。
⑥ Android線程優先順序和進程oom_adj
在處理app啟動速度的時候，可以設置主線程的優先順序，保證主線程佔用的cpu足夠久。進程的oom_adj，決定了當內存不夠的時候，lmk會根據oom_adj的大小依次釋放內存。
android中對線程等級劃分如下：
設置線程的優先順序分為：android 提供的api和java sdk自帶的api
注意： 要使用android提供的api設置，用java提供的作用不夠顯著
作用: 可以在主線程設置主線層等級；在Glide載入圖片的時候設置低優先順序。當圖片量很大的時候可以降低載入圖片線程的等級
android內存不夠了，會觸發oom機制，lowMemoryKiller會根據每個進程的oom_adj的等級，依次殺死進程，釋放內存。
lom會根據free的內存的值，來判斷kill掉哪個等級下的進程。例如當空閑內存只有64M了。會kill掉oom_adj 為12-15的進程
真實案例：應用A跳到第三方應用B，在第三方應用B中播放視頻，載入大量圖片，導致返回的時候，應用A走了SplashActivity。通過logcat發現A應用被kill掉了
⑦ Android開發之路-多線程
多線程作為Android開發中相對而言較為高階的知識，其中用到相關的知識點是非常的多，所以在我們需要進行設計或者寫多線程的代碼就必須要進行相對謹慎的處理，這樣就由必要對其要有著比較系統化的認知
我們一般將Android應用分成為兩種：主線程和工作線程；主線程主要是用來進行初始化UI，而工作線程主要是進行耗時操作，例如讀取資料庫，網路連接等
Android系統是以進程為單位來對應用程序資源進行限制，這個問題的可以解釋為：一個進程最多能夠開幾個線程？最好能開幾個？但實則這個是沒有上限這一說，主要是因為資源的限制
Android中關於主線程的理解：Android的主線程是UI線程，在Android中，四大組件運行在主線程中，在主線程中做耗時操作會導致程序出現卡頓甚至出現ANR異常，一個.
在一個程序中，這些獨立運行的程序片斷叫作「線程」(Thread)，利用它編程的概念就叫作「多線程處理」。多線程處理一個常見的例子就是用戶界面。
線程總的來就是進程的一個實體，是CPU進行分派和調度的基本單位，擁有著比進程更小且能夠獨立運行的基本單位，線程本身基本上是不擁有系統資源，僅擁有一點在運行過程中必須擁有的資源，但它可與同屬一個進程中的其他進程進行共享其所擁有的所有資源
線程狀態有些地方將之分為5中狀態，而且在Java Jdk中線程被其定義為6中狀態，我們可以對其進行類比
普遍定義的5中狀態：新建，就緒，運行，阻塞， 死亡
Java Jdk 定義狀態
線程阻塞是指在某一時刻的某一個線程在進行運行一段代碼的情況下，突然另一個線程也要進行運行，但在運行過程中，那個線程執行完全運行之前，另一個線程是不可能獲取到CPU的執行權，就會導致線路阻塞的出現
死鎖也稱之為抱死，意思就是說一個進程鎖定了另外一個進程所需要的頁或表是，但第二個進程同時又鎖定了第一個進程所需的一頁，這樣就會出現死鎖現象
簡要介紹實現線程的三種方式：繼承Thread，實現runnable，實現callable。這里有一點需要注意的是，實現callable是與線程池相關聯的而callable很重要的一個特性是其帶有返回值。當我們只需實現單線程時實現runnable更加利於線程程序的拓展
在線程開啟之前進行調用 thread.setDaemon(true); 將thread設定成當前線程中的守護線程 使用案例
線程讓步【yield方法】讓當前線程釋放CPU資源，讓其他線程搶占
這種具體某個對象鎖 wait & notify 方法與Condition 的 await以及signal方法類似； 全面這種方法的阻塞等待都可以是釋放鎖，而且在喚醒後，這種線程都是能夠獲取鎖資源的，而這個門栓就跟閥門類似
⑧ Android進程間和線程間通信方式
進程：是具有一定獨立功能的程序關於某個數據集合上的一次運行活動，進程是系統進行資源分配和調度的一個獨立單位。
線程：是進程的一個實體,是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位。線程自己基本上不擁有系統資源,只擁有一些在運行中必不可少的資源(如程序計數器,一組寄存器和棧)，但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源。
區別：
（1）、一個程序至少有一個進程，一個進程至少有一個線程；
（2）、線程的劃分尺度小於進程，使得多線程程序的並發性高；
（3）、進程在執行過程中擁有獨立的內存單元，而多個線程共享內存，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉。
---------------------
一、Android進程間通信方式
1.Bundle
由於Activity，Service，Receiver都是可以通過Intent來攜帶Bundle傳輸數據的，所以我們可以在一個進程中通過Intent將攜帶數據的Bundle發送到另一個進程的組件。
缺點：無法傳輸Bundle不支持的數據類型。
2.ContentProvider
ContentProvider是Android四大組件之一，以表格的方式來儲存數據，提供給外界，即Content Provider可以跨進程訪問其他應用程序中的數據。用法是繼承ContentProvider，實現onCreate,query,update,insert,delete和getType方法，onCreate是負責創建時做一些初始化的工作，增刪查改的方法就是對數據的查詢和修改，getType是返回一個String，表示Uri請求的類型。注冊完後就可以使用ContentResolver去請求指定的Uri。
3.文件
兩個進程可以到同一個文件去交換數據，我們不僅可以保存文本文件，還可以將對象持久化到文件，從另一個文件恢復。要注意的是，當並發讀/寫時可能會出現並發的問題。
4.Broadcast
Broadcast可以向android系統中所有應用程序發送廣播，而需要跨進程通訊的應用程序可以監聽這些廣播。
5.AIDL方式
Service和Content Provider類似，也可以訪問其他應用程序中的數據，Content Provider返回的是Cursor對象，而Service返回的是Java對象，這種可以跨進程通訊的服務叫AIDL服務。
AIDL通過定義服務端暴露的介面，以提供給客戶端來調用，AIDL使伺服器可以並行處理，而Messenger封裝了AIDL之後只能串列運行，所以Messenger一般用作消息傳遞。
6.Messenger
Messenger是基於AIDL實現的，服務端（被動方）提供一個Service來處理客戶端（主動方）連接，維護一個Handler來創建Messenger，在onBind時返回Messenger的binder。
雙方用Messenger來發送數據，用Handler來處理數據。Messenger處理數據依靠Handler，所以是串列的，也就是說，Handler接到多個message時，就要排隊依次處理。
7.Socket
Socket方法是通過網路來進行數據交換，注意的是要在子線程請求，不然會堵塞主線程。客戶端和服務端建立連接之後即可不斷傳輸數據，比較適合實時的數據傳輸
二、Android線程間通信方式
一般說線程間通信主要是指主線程（也叫UI線程）和子線程之間的通信，主要有以下兩種方式：
1.AsyncTask機制
AsyncTask，非同步任務，也就是說在UI線程運行的時候，可以在後台的執行一些非同步的操作；AsyncTask可以很容易且正確地使用UI線程，AsyncTask允許進行後台操作，並在不顯示使用工作線程或Handler機制的情況下，將結果反饋給UI線程。但是AsyncTask只能用於短時間的操作（最多幾秒就應該結束的操作），如果需要長時間運行在後台，就不適合使用AsyncTask了，只能去使用Java提供的其他API來實現。
2.Handler機制
Handler，繼承自Object類，用來發送和處理Message對象或Runnable對象；Handler在創建時會與當前所在的線程的Looper對象相關聯(如果當前線程的Looper為空或不存在，則會拋出異常，此時需要在線程中主動調用Looper.prepare()來創建一個Looper對象)。使用Handler的主要作用就是在後面的過程中發送和處理Message對象和讓其他的線程完成某一個動作（如在工作線程中通過Handler對象發送一個Message對象，讓UI線程進行UI的更新，然後UI線程就會在MessageQueue中得到這個Message對象（取出Message對象是由其相關聯的Looper對象完成的），並作出相應的響應）。
三、Android兩個子線程之間通信
面試的過程中，有些面試官可能會問Android子線程之間的通信方式，由於絕大部分程序員主要關注的是Android主線程和子線程之間的通信，所以這個問題很容易讓人懵逼。
主線程和子線程之間的通信可以通過主線程中的handler把子線程中的message發給主線程中的looper，或者，主線程中的handler通過post向looper中發送一個runnable。但looper默認存在於main線程中，子線程中沒有Looper，該怎麼辦呢？其實原理很簡單，把looper綁定到子線程中，並且創建一個handler。在另一個線程中通過這個handler發送消息，就可以實現子線程之間的通信了。
子線程創建handler的兩種方式：
方式一：給子線程創建Looper對象：
new Thread(new Runnable() {
public void run() {
Looper.prepare(); // 給這個Thread創建Looper對象，一個Thead只有一個Looper對象
Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
Toast.makeText(getApplicationContext(), "handleMessage", Toast.LENGTH_LONG).show();
}
};
handler.sendEmptyMessage(1);
Looper.loop(); // 不斷遍歷MessageQueue中是否有消息
};
}).start();
---------------------
方式二：獲取主線程的looper，或者說是UI線程的looper：
new Thread(new Runnable() {
public void run() {
Handler handler = new Handler(Looper.getMainLooper()){ // 區別在這！！！
@Override
public void handleMessage(Message msg) {
Toast.makeText(getApplicationContext(), "handleMessage", Toast.LENGTH_LONG).show();
}
};
handler.sendEmptyMessage(1);
};
}).start();
---------------------
⑨ Android 進程和線程的區別
·有一段程序供其執行
·擁有專用的系統堆棧空間
·在內存中有對應的進程式控制制塊
·擁有獨立的用戶存儲空間
·進程之間不能進行自由的信息交互（別問我，問就是Android規定的）
·每個進程必須包含一個線程
·進程間的切換開銷比較大，線程創建和終止比進程快，進程間無法進行自由的資源交換，同進程內的線程可以自由交換
我們可以將Android系統比做一個大公司，進程相當於某個部門的經理，他有自己要做到項目（有一段程序供其執行，在內存中有對應的進程式控制制塊），擁有自己部門的辦公場地（擁有獨立的用戶存儲空間）。
線程就相當於每個部門的員工，員工得依賴於經理提供的工作環境才能夠進行工作（線程必須依賴於進程），而經理手下必須得有一個員工（要不然分配的工作交給誰來做），我們都知道在一個大公司下每個部門和每個部門溝通是比較困難的，但是一個部門之間的員工溝通相對容易許多（同進程下的線程共享資源）。
參考： https://blog.csdn.net/u012221046/article/details/78010365
⑩ Android進程與線程區別
所以下來特地去查了以下資料，先說說線程：
（1）在Android APP中，只允許有一個主線程，進行UI的渲染等等，但是不能進行耗時操作（網路交互等等），否則會造成ANR，就是線程阻塞卡死，未響應。
（2）除了主線程之外，耗時操作都應該規范到子線程中,線程之間會有相應的通信方式，但相互獨立。
（3）然後看了一下所查資料：
線程是進程的一個實體,是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位。線程比進程更小，基本上不擁有系統資源，故對它的調度所用資源小，能更高效的提高系統內多個程序間並發執行的。 嗯，從大的說就是這樣。
在平時的Android開發過程中，基本上都會用到線程handler，thread等等，具體的實現方法我就不在這里寫了。
進程：
根據所查資料：是一個具有獨立功能的程序關於某個數據集合的一次運行活動。進程是系統進行資源分配和調度的一個獨立單位。可以申請和擁有系統資源，是一個動態的概念，是一個活動的實體，是一個「執行中的程序」。不只是程序的代碼，還包括當前的活動。
這應該是一個比較大的概念，存在於一個系統中，與線程的區別是：
1、子進程和父進程有不同的代碼和數據空間，而多個線程則共享數據空間，每個線程有自己的執行堆棧和程序計數器為其執行上下文。
2、進程間相互獨立，同一進程的各線程間共享。某進程內的線程在其它進程不可見。
3、進程間通信IPC，線程間可以直接讀寫進程數據段（如全局變數）來進行通信——需要進程同步和互斥手段的輔助，以保證數據的一致性。
4、線程上下文切換比進程上下文切換要快得多。