Activity的四種啟動模式，activity四種模式

Activity的四種啟動模式，activity四種模式

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

? 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，沒有的話就創建。