Activity的四種加載(啓動)模式:
通常情況下，一個應用有一個Task，這個Task就是爲了完成某個工作的一系列Activity的集合。而這些Activity又被組織成了堆棧的形式。
當一個Activity啓動時，就會把它壓入該Task的堆棧，而當用戶在該Activity中按返回鍵，或者代碼中finish掉時，就會將它從該Task的堆棧中彈出。如果我們沒有特別的需求，我們的應用就會呈現出如下圖所示的情形
然而，事實上我們的需求遠沒有我們想的那麼簡單。有時候，你可能希望在開啓一個Activity時，重新開啓一個Task；有時你可能希望將已經存在的一個Activity放到棧頂，而不是重新創建一個...
Android爲了使我們能夠打破默認的堆棧的先後出的模式，提供了兩個種方式：一種是在AndroidManifest.xml定義Activity時指定它的加載模式，另一種是在用Intent開啓一個Activity時，在Intent中加入標誌。如果兩種方式都用了，則後者的優先級更高。
兩種方式的差別在於，前者在於描述自己，向別的Acttivity等聲明你們如何來加載我；而後者則是動態的，指出我要求你（要啓動的Activity）如何來加載。本文的重點在於研究在AndroidManifest.xml中聲明加載模式。
Android爲我們定義了四種加載模式，分別是：standard、singleTop、singleTask和singleInstance。
“拿來主義”——standard模式
我們寫一段代碼來測試一下standard加載模式，如下
AndroidManifest.xml裏Activity的設置如下：
<activity
android:name=".Activity1" android:launchMode="standard" android:label="@string/app_name"> <intent-filter> <action
android:name="android.intent.action.MAIN" /> <category
android:name="android.intent.category.LAUNCHER" /> </intent-filter></activity> |
Activity1的代碼如下：
public class Activity1extends Activity
{ @Override public void onCreate(Bundle
savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } /**當點擊Activity時，啓動另一個Activity1*/ @Override public boolean onTouchEvent(MotionEvent
event) { Intent
intent = new Intent(this,
Activity1.class); startActivity(intent); return super.onTouchEvent(event); } } |
然後我們啓動程序，開啓Activity1，然後點擊Acitivity1，啓動另一個Activity1，然後再點擊，再點擊，再點擊... 之後我們點返回鍵。
發生了什麼事情？沒錯，我們按返回鍵返回一個又一個相同的Activity1。
standard是Activity默認的加載模式，這種方式用一個詞來形容的話就是“拿來主義”。使用這種模式的Activity向所有使用它的Task聲明：“我這裏的這種Activity多着呢，誰需要的話我就給誰”。所以當一個Task請求加載這個Activity時，該Task直接實例化該Activity，並把它放到棧頂。
因此我們的例子就出現了這樣的堆棧結構（假設我們點擊了4次）：
| Activity1 |
| Activity1 |
| Activity1 |
| Activity1 |
| Activity1 |
我們設想一個情形：我們要做一個圖片瀏覽器，第一個界面是圖片列表界面（假設爲PictureListActivity），第二個界面是瀏覽該張圖片（假設爲PictureViewActivity）。在PictureViewActivity中可以startActivity啓動瀏覽界面瀏覽上一張和下一張。
如果每一張圖片的瀏覽啓動一個PictureViewActivity（當然你可能不是採用這種方式來瀏覽上一張和下一張，這裏只是舉個例子），如果採用standard模式的話，就會出現多個PictureViewActivity在堆棧中堆疊的情形。下面介紹的singleTop便可以解決這個問題。
“拒絕堆疊”——singleTop模式
我們將上面的例子稍加改動，AndroidManifest.xml中Acitivity1的launchMode改爲singleTop，Activity1的代碼修改如下：
public class Activity1extends Activity
{ @Override public void onCreate(Bundle
savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); //Activity1創建時顯示Toast Toast.makeText(this,"onCreate
called!",
Toast.LENGTH_SHORT).show(); } @Override protected void onNewIntent(Intent
intent) { setTitle("I
am Activity1 too, but I called onNewIntent!"); super.onNewIntent(intent); } //點擊進入加載Activity1 @Override public boolean onTouchEvent(MotionEvent
event) { Intent
intent = new Intent(this,
Activity1.class); startActivity(intent); return super.onTouchEvent(event); } } |
同樣，我們啓動程序，開啓Activity1，然後點擊Acitivity1，啓動另一個Activity1，然後再點擊，再點擊，再點擊... 之後我們點返回鍵。
結果，Activity1第一次創建時，顯示一個Toast提示，onCreate被調用，當再次點擊時，onCreate沒有被調用相反是進入了onNewIntent函數。當按返回鍵時，直接退出了該應用，可見，堆棧中只存在一個Acitivity1。
可見，當activity被設置爲singleTop的加載模式時，如果堆棧的頂部已經存在了該Activity，那麼，它便不會重新創建，而是調用onNewIntent。如果，該Activity存在，但不是在頂部，那麼該Activity依然要重新創建，請讀者自行驗證。
因此singleTop模式的思想便是“拒絕堆疊”！
以上說的兩種加載模式，Activity均可以實例化多次，而下面講的兩個加載模式就只可以實例化一次。
“獨立門戶”——singleTask模式
我們首先測試一下，在本應用內調用singleTask模式的Activity會出現什麼情況。
我們寫兩個Activity（Activity1和Activity2），相互調用，其中Activity1爲singleTask模式。AndroidManifest.xml如下：
<application
android:icon="@drawable/icon" android:label="@string/app_name"> <activity
android:name=".Activity1" android:launchMode="singleTask" android:label="@string/app_name"> </activity> <activity
android:name=".Activity2"> <intent-filter> <action
android:name="android.intent.action.MAIN" /> <category
android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity></application> |
兩個Activity的代碼如下：
/**Activity1的代碼*/public class Activity1extends Activity
{ private static final String
TAG = "Activity1"; @Override public void onCreate(Bundle
savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Log.e(TAG,"Activity1
onCreate! HashCode=" +this.hashCode()
+ "
TaskId=" +
getTaskId()); } @Override protected void onNewIntent(Intent
intent) { Log.e(TAG,"Activity1
onNewIntent! HashCode="+this.hashCode()
+ "
TaskId=" +
getTaskId()); super.onNewIntent(intent); } @Override protected void onDestroy()
{ Log.e("Activity1","Activity1
onDestroy! HashCode="+this.hashCode()+"TaskId="+getTaskId()); super.onDestroy(); } /**點擊進入Activity2*/ @Override public boolean onTouchEvent(MotionEvent
event) { Intent
intent = new Intent(this,
Activity2.class); startActivity(intent); return super.onTouchEvent(event); } }/**Activity2的代碼*/public class Activity2extends Activity
{ private static final String
TAG = "Activity2"; @Override protected void onCreate(Bundle
savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main2); Log.e(TAG,"Activity2
onCreated! HashCode=" +this.hashCode()
+ "
TaskId="+getTaskId()); } @Override protected void onDestroy()
{ Log.e(TAG,"Activity2
onDestroy! HashCode="+this.hashCode()+"
TaskId="+getTaskId()); super.onDestroy(); } /**點擊進入Activity1*/ @Override public boolean onTouchEvent(MotionEvent
event) { Intent
intent = new Intent(this,
Activity1.class); startActivity(intent); return super.onTouchEvent(event); } } |
從代碼中我們可以看出，每當兩個Activity創建、銷燬以及onNewIntent時，都會打印該Activity的HashCode和所在的Task id。
我們的操作步驟是這樣的，打開應用程序，默認啓動Activity2，點擊Activity2，進入Activity1，再點擊Activity1進入Activity2，再點擊Activity2進入Activity1，然後按返回鍵，直到返回到Home。
暈了吧，好寫個順序來形象的表示下：Activity2->Activity1(singleTask)->Activity2->Activity1(singleTask)。^_^
進入Activity2，然後到Activity1，我們看Log信息爲：
03-01 14:50:08.144: ERROR/Activity2(371): Activity2 onCreated! HashCode=1156067168 TaskId=7
03-01 14:50:13.923: ERROR/Activity1(371): Activity1 onCreate! HashCode=1156107384 TaskId=7
我們看到，當本應用啓動singleTask的Activity（Activity1）時，Activity1並沒用另外啓用一個任務。而是在原來的任務中創建了它。
再從Activity1進入Activity2，然後再進入Activity1，這個過程，我們再看log信息：
03-01 14:53:50.823: ERROR/Activity2(371): Activity2 onCreated! HashCode=1156128904 TaskId=7
03-01 14:53:58.154: ERROR/Activity1(371): Activity1 onNewIntent! HashCode=1156107384 TaskId=7
03-01 14:53:58.394: ERROR/Activity2(371): Activity2 onDestroy! HashCode=1156128904 TaskId=7
從這個Log信息我們可以得到這個結論：當singleTask模式的Activity啓動時，如果發現在某個Task中已經存在，那麼它會先將該Activity（Activity1）上部的Activity（Activity2）銷燬，然後調用它（Activity1）的onNewIntent函數。
我們下面來研究一下當singleTask的Activity被其他應用調用時的情況。
爲了使Activity1能夠被其他應用程序調用，我們在AndroidManifest.xml中加入action，如下：
<activity
android:name=".Activity1" android:launchMode="singleTask" android:label="@string/app_name"> <intent-filter> <action
android:name="com.winuxxan.singleTask" /> <category
android:name="android.intent.category.DEFAULT" /> </intent-filter></activity> |
然後我們另外創建一個工程，創建一個Activity在初始化的時候啓動Activity1，代碼如下：
public class MyActivityextends Activity
{ @Override public void onCreate(Bundle
savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Log.e("MyActivity","TaskId=" +
getTaskId()); Intent
intent = new Intent("com.winuxxan.singleTask"); startActivity(intent); } } |
我們的操作方法是，MyActivity->Activity1->Activity2->Activity1，之後我們按Home鍵，然後再從Home重新進入MyActivity所在的應用。
首先看MyActivity->Activity1這個過程，我們查看Log信息如下：
03-01 15:04:25.784: ERROR/MyActivity(429): TaskId=9
03-01 15:04:26.244: ERROR/Activity1(401): Activity1 onCreate! HashCode=1156107632 TaskId=10
從這個Log信息我們可以看出：當某個應用調用其他應用裏聲明的singleTask模式的Activity時，它會重新創建一個Task，然後將該Activity實例化並壓入堆棧。
接着我們看Activity1和Activity2的相互切換，log信息如下：
03-01 15:04:47.524: ERROR/Activity2(401): Activity2 onCreated! HashCode=1156128104 TaskId=10
03-01 15:04:50.674: ERROR/Activity1(401): Activity1 onNewIntent! HashCode=1156107632 TaskId=10
03-01 15:04:50.994: ERROR/Activity2(401): Activity2 onDestroy! HashCode=1156128104 TaskId=10
和我們所期望的那樣，如果Activity發現已經存在時，會銷燬其上的Activity，然後調用onNewIntent。
之後，我們按Home鍵，返回桌面，然後，再次進入該應用，我們神奇的發現，我們進入的是MyActivity界面，taskId爲10的所有Activity不知了蹤影！
這是因爲，該應用對應的task的id爲9，所以，進入後之後MyActivity在該task中，所以最後顯示的是MyActivity。我的以上Activity1的代碼實際上是不好的習慣，因爲Activity1很可能會成爲一個孤島，所以建議，如果該Activity的類型不是LAUNCHER,最好不要設爲singleTask。
那麼singleTask的這些特性有什麼用處？我們舉一個例子，瀏覽器就是一個singleTask的例子，啓動一個瀏覽器，在Android中是一個比較沉重的過程，它需要做很多初始化的工作，並且會有不小的內存開銷。如果有多個應用都來請求打開網頁，那麼系統就不會不堪重負。因此，如果瀏覽器採用singleTask模式，如果有多個請求打開網頁的請求，都會在一個Task中響應，這樣就會避免以上的情況。
“孤獨寂寞”——singleInstance模式
我們現在來研究最後一個加載模式，singgleInstance，測試很簡單，我們只要在singleTask測試的例子中，將Activity1的模式改爲singleInstance模式即可。
我們首先進行同一應用內部的測試。
首先Activity2->Activity1，觀察log信息：
03-01 15:41:59.283: ERROR/Activity2(488): Activity2 onCreated! HashCode=1156067168 TaskId=12
03-01 15:42:04.103: ERROR/Activity1(488): Activity1 onCreate! HashCode=1156107520 TaskId=13
我們發現，當採用singleInstance模式時，啓動時創建了一個新的Task，並將Activity1實例化加入到該Task中。
然後我們Activity1->Activity2->Activity1，觀察log信息：
03-01 15:43:52.214: ERROR/Activity2(488): Activity2 onCreated! HashCode=1156127728 TaskId=12
03-01 15:43:56.804: ERROR/Activity1(488): Activity1 onNewIntent! HashCode=1156107520 TaskId=13
我們通過該log信息可以得出結論：singleInstance的Activity（Activity1）不允許其他的Activity（Activity2）加入到自己的Task中，它是的內心容不下另一個人，它是一個孤獨寂寞的人。 當Activity1發現已經存在一個Task中包含自己的實例時，它會調用自己的onNewIntent。
然後，我們同樣也測試一下，如果其它應用程序調用Activity1會出現什麼樣的情況：
MyActivity->Activity1, 觀察log信息：
03-01 15:50:21.134: ERROR/MyActivity(556): TaskId=16
03-01 15:50:21.484: ERROR/Activity1(534): Activity1 onCreate! HashCode=1156107344 TaskId=17
不出意料，Activity1重新創建了一個Task，並將自己的實例入棧。
Activity1->Activity2->Activity1->Activity2, 我們觀察log信息：
03-01 15:50:36.484: ERROR/Activity2(534): Activity2 onCreated! HashCode=1156128056 TaskId=18
03-01 15:50:46.114: ERROR/Activity1(534): Activity1 onNewIntent! HashCode=1156107344 TaskId=17
我們從該過程可以看出：如果從其它應用程序調用singleInstance模式的Activity（Activity1），從該Activity開啓其他Activity（Activity2）時，會創建一個新的Task（task id爲18的那個），實際上，如果包含該Activity（Activity2）的Task已經運行的話，他會在該運行的Task中重新創建。
OK，上面囉嗦了那麼多，如果這部分不是很清楚的人，可能已經頭昏腦脹了。那我們總結一下吧，這總該看看了吧。
“拿來主義”standard模式。哪裏需要調用我我就去哪裏，可以多次實例化，可以幾個相同的Activity重疊。
“拒絕堆疊”singleTop模式。可以多次實例化，但是不可以多個相同的Activity重疊，當堆棧的頂部爲相同的Activity時，會調用onNewIntent函數。
“獨立門戶”singleTask模式。同一個應用中調用該Activity時，如果該Activity沒有被實例化，會在本應用程序的Task內實例化，如果已經實例化，會將Task中其上的Activity銷燬後，調用onNewIntent；其它應用程序調用該Activity時，如果該Activity沒有被實例化，會創建新的Task並實例化後入棧，如果已經實例化，會銷燬其上的Activity，並調用onNewIntent。一句話，singleTask就是“獨立門戶”，在自己的Task裏，並且啓動時不允許其他Activity凌駕於自己之上。
“孤獨寂寞”singleInstance模式。加載該Activity時如果沒有實例化，他會創建新的Task後，實例化入棧，如果已經存在，直接調用onNewIntent，該Activity的Task中不允許啓動其它的Activity，任何從該Activity啓動的其他Activity都將被放到其他task中，先檢查是否有本應用的task，沒有的話就創建。
