在多Activity開發中，有可能是自己應用之間的Activity跳轉，或者夾帶其他應用的可復用Activity。可能會希望跳轉到原來某個Activity實例，而不是產生大量重復的Activity。

這需要為Activity配置特定的加載模式，而不是使用默認的加載模式。

加載模式分類及在哪里配置

Activity有四種加載模式：

• standard
• singleTop
• singleTask
• singleInstance

設置的位置在AndroidManifest.xml文件中activity元素的android:launchMode屬性：

<activity android:name="ActB"?android:launchMode="singleTask"></activity>

也可以在Eclipse ADT中圖形界面中編輯：

?

區分Activity的加載模式，通過示例一目了然。這里編寫了一個Activity A（ActA）和Activity B（ActB）循環跳轉的例子。對加載模式修改和代碼做稍微改動，就可以說明四種模式的區別。

standard

首先說standard模式，也就是默認模式，不需要配置launchMode。先只寫一個名為ActA的Activity：

package com.easymorse.activities;

import android.app.Activity;?
import android.content.Intent;?
import android.os.Bundle;?
import android.view.View;?
import android.view.View.OnClickListener;?
import android.widget.Button;?
import android.widget.LinearLayout;?
import android.widget.TextView;

public class ActA extends Activity {?
??? /** Called when the activity is first created. */?
??? @Override?
??? public void onCreate(Bundle savedInstanceState) {?
??????? super.onCreate(savedInstanceState);?
??????? TextView textView = new TextView(this);?
??????? textView.setText(this + "");?
??????? Button button = new Button(this);?
??????? button.setText("go actA");?
??????? button.setOnClickListener(new OnClickListener() {?
??????????? @Override?
??????????? public void onClick(View v) {?
??????????????? Intent intent = new Intent();?
??????????????? intent.setClass(ActA.this, ActA.class);?
??????????????? startActivity(intent);?
??????????? }?
??????? });?
??????? LinearLayout layout = new LinearLayout(this);?
??????? layout.setOrientation(LinearLayout.VERTICAL);?
??????? layout.addView(textView);?
??????? layout.addView(button);?
??????? this.setContentView(layout);?
??? }?
}

例子中都沒有用layout，免得看著羅嗦。可見是ActA –> ActA的例子。在界面中打印出對象的toString值可以根據hash code識別是否創建新ActA實例。

第一個界面：

點擊按鈕后：

可以多點幾次。發現每次都創建了該Activity的新實例。standard的加載模式就是這樣的，intent將發送給新的實例。

現在點Android設備的回退鍵，可以看到是按照剛才創建Activity實例的倒序依次出現，類似退棧的操作，而剛才操作跳轉按鈕的過程是壓棧的操作。如下圖：

?

singleTop

singleTop和standard模式，都會將intent發送新的實例（后兩種模式不發送到新的實例，如果已經有了的話）。不過，singleTop要求如果創建intent的時候棧頂已經有要創建的Activity的實例，則將intent發送給該實例，而不發送給新的實例。

還是用剛才的示例，只需將launchMode改為singleTop，就能看到區別。

運行的時候會發現，按多少遍按鈕，都是相同的ActiA實例，因為該實例在棧頂，因此不會創建新的實例。如果回退，將退出應用。

singleTop模式，可用來解決棧頂多個重復相同的Activity的問題。

如果是A Activity跳轉到B Activity，再跳轉到A Activity，行為就和standard一樣了，會在B Activity跳轉到A Activity的時候創建A Activity的新實例，因為當時的棧頂不是A Activity實例。

ActA類稍作改動：

package com.easymorse.activities;

import android.app.Activity;?
import android.content.Intent;?
import android.os.Bundle;?
import android.view.View;?
import android.view.View.OnClickListener;?
import android.widget.Button;?
import android.widget.LinearLayout;?
import android.widget.TextView;

public class ActA extends Activity {?
??? /** Called when the activity is first created. */?
??? @Override?
??? public void onCreate(Bundle savedInstanceState) {?
??????? super.onCreate(savedInstanceState);?
??????? TextView textView = new TextView(this);?
??????? textView.setText(this + "");?
??????? Button button = new Button(this);?
??????? button.setText("go actB");?
??????? button.setOnClickListener(new OnClickListener() {?
??????????? @Override?
??????????? public void onClick(View v) {?
??????????????? Intent intent = new Intent();?
??????????????? intent.setClass(ActA.this, ActB.class);?
??????????????? startActivity(intent);?
??????????? }?
??????? });?
??????? LinearLayout layout = new LinearLayout(this);?
??????? layout.setOrientation(LinearLayout.VERTICAL);?
??????? layout.addView(textView);?
??????? layout.addView(button);?
??????? this.setContentView(layout);?
??? }?
}

?

ActB類：

package com.easymorse.activities;

import android.app.Activity;?
import android.content.Intent;?
import android.os.Bundle;?
import android.view.View;?
import android.view.View.OnClickListener;?
import android.widget.Button;?
import android.widget.LinearLayout;

public class ActB extends Activity {?
??? @Override?
??? protected void onCreate(Bundle savedInstanceState) {?
??????? super.onCreate(savedInstanceState);?
???????? Button button=new Button(this);?
??????????? button.setText("go actA");?
??????????? button.setOnClickListener(new OnClickListener() {?
??????????????? @Override?
??????????????? public void onClick(View v) {?
??????????????????? Intent intent=new Intent();?
??????????????????? intent.setClass(ActB.this, ActA.class);?
??????????????????? startActivity(intent);?
??????????????? }?
??????????? });?
??????????? LinearLayout layout=new LinearLayout(this);?
??????????? layout.addView(button);?
??????????? this.setContentView(layout);?
??? }?
}

?

ActB類使用默認（standard）加載，ActA使用singleTop加載。結果類似下圖：

如果把ActA的加載模式改為standard，情況一樣。

singleTask

singleTask模式和后面的singleInstance模式都是只創建一個實例的。

當intent到來，需要創建singleTask模式Activity的時候，系統會檢查棧里面是否已經有該Activity的實例。如果有直接將intent發送給它。

把上面singleTop的實例中的ActA的launchMode改為singleTask，ActB的改為standard。那么會發現在ActA界面中按一次按鈕：

然后在ActB1界面中按按鈕，因為ActA是singleTask，會使用原來的ActA1實例。這時候棧內的情況:

?

如果多次按按鈕跳轉，會發現始終只有ActA1這一個ActA類的實例。

?

singleInstance

解釋singleInstance模式比較麻煩。

首先要說一下Task（任務）的概念。

如果是Swing或者Windows程序，可能有多個窗口可以切換，但是你無法在自己程序中復用人家的窗口。注意是直接復用人家的二進制代碼，不是你拿到人家api后的源代碼級調用。

Android可以做到，讓別人的程序直接復用你的Activity（類似桌面程序的窗口）。

Android為提供這種機制，就引入了Task的概念。Task可以認為是一個棧，可放入多個Activity。比如啟動一個應用，那么Android就創建了一個Task，然后啟動這個應用的入口Activity，就是intent-filter中配置為main和launch的那個（見一個APK文件部署產生多個應用安裝的效果）。這個Activity是根（Root）Activity，可能會在它的界面調用其他Activity，這些Activity如果按照上面那三個模式，也會在這個棧（Task）中，只是實例化的策略不同而已。

驗證的辦法是調用和打印Activity的taskId：

TextView textView2 = new TextView(this);?
textView2.setText("task id: "+this.getTaskId());

會發現，無論切換Activity，taskId是相同的。

當然也可以在這個單一的Task棧中，放入別人的Activity，比如google地圖，這樣用戶看過地圖按回退鍵的時候，會退棧回到調用地圖的Activity。對用戶來說，并不覺得在操作多個應用。這就是Task的作用。

但是，有這樣的需求，多個Task共享一個Activity（singleTask是在一個task中共享一個Activity）。

現成的例子是google地圖。比如我有一個應用是導游方面的，其中調用的google地圖Activity。那么現在我比如按home鍵，然后到應用列表中打開google地圖，你會發現顯示的就是剛才的地圖，實際上是同一個Activity。

如果使用上面三種模式，是無法實現這個需求的。google地圖應用中有多個上下文Activity，比如路線查詢等的，導游應用也有一些上下文Activity。在各自應用中回退要回退到各自的上下文Activity中。

singleInstance模式解決了這個問題（繞了這么半天才說到正題）。讓這個模式下的Activity單獨在一個task棧中。這個棧只有一個Activity。導游應用和google地圖應用發送的intent都由這個Activity接收和展示。

這里又有兩個問題：

• 如果是這種情況，多個task棧也可以看作一個應用。比如導游應用啟動地圖Activity，實際上是在導游應用task棧之上singleInstance模式創建的（如果還沒有的話，如果有就是直接顯示它）一個新棧，當這個棧里面的唯一Activity，地圖Activity回退的時候，只是把這個棧移開了，這樣就看到導游應用剛才的Activity了；
• 多個應用（Task）共享一個Activity要求這些應用都沒有退出，比如剛才強調要用home鍵從導游應用切換到地圖應用。因為，如果退出導游應用，而這時也地圖應用并未運行的話，那個單獨的地圖Activity（task）也會退出了。

如果還是拿剛才的ActA和ActB的示例，可以把ActB的模式改為singleInstance，ActA為standard，如果按一次按鈕切換到ActB，看到現象用示意圖類似這樣：

如果是第一次按鈕切換到ActB，在ActB在按按鈕切換到ActA，然后再回退，示意圖是：

另外，可以看到兩個Activity的taskId是不同的。

?

?

==========================================================================================

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的代碼如下：

?

publicclass Activity1 extendsActivity { @Override publicvoid onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } /**當點擊Activity時，啟動另一個Activity1*/ @Override publicboolean onTouchEvent(MotionEvent event) { Intent intent = newIntent(this, Activity1.class); startActivity(intent); returnsuper.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的代碼修改如下：

?

publicclass Activity1 extendsActivity { @Override publicvoid onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); //Activity1創建時顯示Toast Toast.makeText(this,"onCreate called!", Toast.LENGTH_SHORT).show(); } @Override protectedvoid onNewIntent(Intent intent) { setTitle("I am Activity1 too, but I called onNewIntent!"); super.onNewIntent(intent); } //點擊進入加載Activity1 @Override publicboolean onTouchEvent(MotionEvent event) { Intent intent = newIntent(this, Activity1.class); startActivity(intent); returnsuper.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的代碼*/ publicclass Activity1 extendsActivity { privatestatic final String TAG = "Activity1"; @Override publicvoid onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Log.e(TAG,"Activity1 onCreate! HashCode=" + this.hashCode() + " TaskId=" + getTaskId()); } @Override protectedvoid onNewIntent(Intent intent) { Log.e(TAG,"Activity1 onNewIntent! HashCode="+this.hashCode() + " TaskId=" + getTaskId()); super.onNewIntent(intent); } @Override protectedvoid onDestroy() { Log.e("Activity1","Activity1 onDestroy! HashCode="+this.hashCode()+"TaskId="+getTaskId()); super.onDestroy(); } /**點擊進入Activity2*/ @Override publicboolean onTouchEvent(MotionEvent event) { Intent intent = newIntent(this, Activity2.class); startActivity(intent); returnsuper.onTouchEvent(event); } } /**Activity2的代碼*/ publicclass Activity2 extendsActivity { privatestatic final String TAG = "Activity2"; @Override protectedvoid onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main2); Log.e(TAG,"Activity2 onCreated! HashCode=" + this.hashCode() + " TaskId="+getTaskId()); } @Override protectedvoid onDestroy() { Log.e(TAG,"Activity2 onDestroy! HashCode="+this.hashCode()+" TaskId="+getTaskId()); super.onDestroy(); } /**點擊進入Activity1*/ @Override publicboolean onTouchEvent(MotionEvent event) { Intent intent = newIntent(this, Activity1.class); startActivity(intent); returnsuper.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，代碼如下：

?

publicclass MyActivity extendsActivity { @Override publicvoid onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Log.e("MyActivity","TaskId="+ getTaskId()); Intent intent = newIntent("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，沒有的話就創建。

-------------------------------------------------------------------------------------------------------------------------------

Activity有四種加載模式：standard(默認)， singleTop， singleTask和 singleInstance。以下逐一舉例說明他們的區別：

standard：Activity的默認加載方法，即使某個Activity在Task棧中已經存在，另一個activity通過Intent跳轉到該activity，同樣會新創建一個實例壓入棧中。例如：現在棧的情況為：A B C D，在D這個Activity中通過Intent跳轉到D，那么現在的棧情況為： A B C D D 。此時如果棧頂的D通過Intent跳轉到B，則棧情況為：A B C D D B。此時如果依次按返回鍵，D? D C B A將會依次彈出棧而顯示在界面上。

singleTop：如果某個Activity的Launch mode設置成singleTop，那么當該Activity位于棧頂的時候，再通過Intent跳轉到本身這個Activity，則將不會創建一個新的實例壓入棧中。例如：現在棧的情況為：A B C D。D的Launch mode設置成了singleTop，那么在D中啟動Intent跳轉到D，那么將不會新創建一個D的實例壓入棧中，此時棧的情況依然為：A B C D。但是如果此時B的模式也是singleTop，D跳轉到B，那么則會新建一個B的實例壓入棧中，因為此時B不是位于棧頂，此時棧的情況就變成了：A B C D B。

singleTask：如果某個Activity是singleTask模式，那么Task棧中將會只有一個該Activity的實例。例如：現在棧的情況為：A B C D。B的Launch mode為singleTask，此時D通過Intent跳轉到B，則棧的情況變成了：A B。而C和D被彈出銷毀了，也就是說位于B之上的實例都被銷毀了。

singleInstance：將Activity壓入一個新建的任務棧中。例如：Task棧1的情況為：A B C。C通過Intent跳轉到D，而D的Launch mode為singleInstance，則將會新建一個Task棧2。此時Task棧1的情況還是為：A B C。Task棧2的情況為：D。此時屏幕界面顯示D的內容，如果這時D又通過Intent跳轉到D，則Task棧2中也不會新建一個D的實例，所以兩個棧的情況也不會變化。而如果D跳轉到C，則棧1的情況變成了：A B C C，因為C的Launch mode為standard，此時如果再按返回鍵，則棧1變成：A B C。也就是說現在界面還顯示C的內容，不是D。
好了，現在有一個問題就是這時這種情況下如果用戶點擊了Home鍵，則再也回不到D的即時界面了。如果想解決這個問題，可以為D在Manifest.xml文件中的聲明加上：

<intent-filter>
???????<action android:name="android.intent.action.MAIN" />
????????<category android:name="android.intent.category.LAUNCHER" />
?</intent-filter>

加上這段之后，也就是說該程序中有兩個這種聲明，另一個就是那個正常的根activity，在打成apk包安裝之后，在程序列表中能看到兩個圖標，但是如果都運行的話，在任務管理器中其實也只有一個。上面的情況點擊D的那個圖標就能回到它的即時界面（比如一個EditText，以前輸入的內容，現在回到之后依然存在）。

PS：intent-filter中?<action android:name="android.intent.action.MAIN" />和?<category android:name="android.intent.category.LAUNCHER" />兩個過濾條件缺一不可才會在程序列表中添加一個圖標，圖標下的顯示文字是android:label設定的字符串。

/

Intent的常用Flag參數：

FLAG_ACTIVITY_CLEAR_TOP：例如現在的棧情況為：A B C D 。D此時通過intent跳轉到B，如果這個intent添加FLAG_ACTIVITY_CLEAR_TOP標記，則棧情況變為：A B。如果沒有添加這個標記，則棧情況將會變成：A B C D B。也就是說，如果添加了FLAG_ACTIVITY_CLEAR_TOP標記，并且目標Activity在棧中已經存在，則將會把位于該目標activity之上的activity從棧中彈出銷毀。這跟上面把B的Launch mode設置成singleTask類似。

FLAG_ACTIVITY_NEW_TASK：例如現在棧1的情況是：A B C。C通過intent跳轉到D，并且這個intent添加了FLAG_ACTIVITY_NEW_TASK標記，如果D這個Activity在Manifest.xml中的聲明中添加了Task affinity，并且和棧1的affinity不同，系統首先會查找有沒有和D的Task affinity相同的task棧存在，如果有存在，將D壓入那個棧，如果不存在則會新建一個D的affinity的棧將其壓入。如果D的Task affinity默認沒有設置，或者和棧1的affinity相同，則會把其壓入棧1，變成：A B C D，這樣就和不加FLAG_ACTIVITY_NEW_TASK標記效果是一樣的了。??????注意如果試圖從非activity的非正常途徑啟動一個activity，比如從一個service中啟動一個activity，則intent比如要添加FLAG_ACTIVITY_NEW_TASK標記。

FLAG_ACTIVITY_NO_HISTORY：例如現在棧情況為：A B C。C通過intent跳轉到D，這個intent添加FLAG_ACTIVITY_NO_HISTORY標志，則此時界面顯示D的內容，但是它并不會壓入棧中。如果按返回鍵，返回到C，棧的情況還是：A B C。如果此時D中又跳轉到E，棧的情況變為：A B C E，此時按返回鍵會回到C，因為D根本就沒有被壓入棧中。

?FLAG_ACTIVITY_SINGLE_TOP：和上面Activity的Launch mode的singleTop類似。如果某個intent添加了這個標志，并且這個intent的目標activity就是棧頂的activity，那么將不會新建一個實例壓入棧中。

?/

Activity的主要屬性：

allowTaskReparenting：設置成true時，和Intent的FLAG_ACTIVITY_NEW_TASK標記類似。

alwaysRetainTaskStat:???如果用戶長時間將某個task移入后臺，則系統會將該task的棧內容彈出只剩下棧底的activity，此時用戶再返回，則只能看到根activity了。如果棧底的activity的這個屬性設置成true，則將阻止這一行為，從而保留所有的棧內容。

clearTaskOnLaunch：根activity的這個屬性設置成true時，和上面的alwaysRetainTaskStat的屬性為true情況搞好相反。

finishOnTaskLaunch：對于任何activity，如果它的這個屬性設置成true，則當task被放置到后臺，然后重新啟動后，該activity將不存在了。

參考：http://mypyg.iteye.com/blog/919643?

???????????http://marshal.easymorse.com/archives/2950?

???????????http://blog.csdn.net/infsafe/archive/2010/06/12/5666964.aspx

轉載于:https://www.cnblogs.com/snowberg/archive/2012/04/21/2468507.html

總結

以上是生活随笔為你收集整理的Activity四种加载模式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。