欧美后进式猛烈XX00免费视频,国产毛片毛多水多的特级毛片,亚洲日本va午夜在线影院

什么是進程

進程是一個具有獨立功能的程序關于某個數據集合的一次運行活動。

進程是一個“執行中的程序”。程序是一個沒有生命的實體，只有處理器賦予程序生命時，它才能成為一個活動的實體，我們稱其為進程。

通常在一個進程中可以包含若干個線程，它們可以利用進程所擁有的資源。

進程與線程的區別

進程是系統進行資源分配和調度的一個獨立單位
線程是進程的一個實體, 是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程自己基本上不擁有系統資源。它可與同屬一個進程的其他的線程共享進程所擁有的全部資源。
一個線程可以創建和撤銷另一個線程，同一個進程中的多個線程之間可以并發執行。

進程和線程的主要差別在于它們是不同的操作系統資源管理方式。進程有獨立的地址空間，一個進程崩潰后，在保護模式下不會對其它進程產生影響，而線程只是一個進程中的不同執行路徑。線程有自己的堆棧和局部變量，但線程之間沒有單獨的地址空間，一個線程死掉就等于整個進程死掉，所以多進程的程序要比多線程的程序健壯，但在進程切換時，耗費資源較大，效率要差一些。但對于一些要求同時進行并且又要共享某些變量的并發操作，只能用線程，不能用進程。

進程的級別

前臺進程
前臺進程是用戶當前正在使用的進程。他們是最后一個被結束的。
屬于前臺進程的幾種情況：

這個進程運行著一個正在和用戶交互的Activity（這個Activity的onResume()方法被調用）。

這個進程里有綁定到當前正在和用戶交互的Activity的service。

這個進程里有一個service對象，這個service對象正在執行一個它的生命周期的回調函數(onCreate(), onStart(), onDestroy())

這個進程里有一個正在調用onReceive()方法的BroadCastReiver對象。

可見進程
屬于可見進程的情況：

進程中含有一個不位于前臺的Activity，但是仍然對用戶是可見的，即處于onPause階段。

進程里有一個綁定到一個可見的Activity的Service。

服務進程
運行著一個通過startService() 方法啟動的service。service所在的進程雖然對用戶不是直接可見的，但是他們執行了用戶非常關注的任務（比如播放mp3，從網絡下載數據）。只要前臺進程和可見進程有足夠的內存，系統不會回收他們。
后臺進程
運行著一個對用戶不可見的activity（調用過 onStop() 方法)
空進程
沒有任何程序在運行的進程。運行這些進程的唯一原因是作為一個緩存，縮短下次程序需要重新使用的啟動時間。系統經常中止這些進程，這樣可以調節程序緩存和系統緩存的平衡。

多進程使用

1.使用多進程的好處？

分擔主進程的內存壓力。Android系統對單個進程可使用的內存是有限制的，使用多進程，可以擴大單個App可使用的內存峰值，從而優化程序性能。
進程間互相隔離，更安全。

2.使用多進程的缺點？

多占了系統的內存空間，很容易沾滿而導致卡頓，同時也消耗用戶的電量。
在Android中，如果有新進程創建，由于進程本身需要一個Application，所以如果將應用中某個service聲明為單獨的進程時，當走到startService時，發現service是新進程，所以會新建一個進程放service，但service又需要一個Application，所以Application會再次執行一遍onCreate()。
優化：只在主應用進程初始化時，才執行全局初始化代碼（參考Raymond_qi_kang

//以下是判斷只有主進程初始化時，才進行 “全局初始化”
public class ApplicationTest extends Application {
 @Override
 public void onCreate() {
     super.onCreate();
     ActivityManager activityManager = (ActivityManager) getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE);
     //獲得進程列表
     List<ActivityManager.RunningAppProcessInfo> processList = activityManager.getRunningAppProcesses();
     //獲得當前pid
     int pid = android.os.Process.myPid();
     Log.i(MessengerService.TAG, "PID：" +pid);
     //判斷當前pid屬于哪個進程
     for (ActivityManager.RunningAppProcessInfo process : processList) {
         if (pid == process.pid){
             //找到了所屬進程，判斷進程名是否為 主進程名（默認為包名）
             Log.i(MessengerService.TAG, "進程名：" + process.processName);
             if (process.processName.equals(getPackageName())) {
                 Log.i(MessengerService.TAG, "主進程：全局初始化，只執行一次");
             }
         }
     }
 }
}

不同進程之間內存不能共享，最大的弊端是他們之間通信麻煩，不能將公用數據放在Application中，堆棧信息、文件操作也是獨立的，如果他們之間傳遞的數據不大并且是可序列化的，可以考慮通過Bundle傳遞，如果數據量較大，則需要通過AIDL或者文件操作來實現。

3.如何添加新的進程？
在Manifest中對四大組件（Activity，Service，Broadcast Receiver，ContentProvider）添加process屬性.

多進程間通信（IPC）

多進程通信主要使用兩種方法：
1.Messenger
2.AIDL（Android Interface Definition Language）

何時使用Messenger？何時使用AIDL？
1.Messenger: 多進程 +單線程
2.AIDL: 多進程 + 多線程

使用Messenger進行通信

使用Messenger的步驟:

Service需要實現一個Hanlder，用以處理從客戶端收到的消息

用該Handler創建一個Messenger對象，Messenger對象內部會引用該Handler對象

用創建好的Messenger對象獲得一個IBinder實例，并且將該IBinder通過Service的onBind方法返回給各個客戶端

建立一個應用ServiceApp, 其中只有一個MyService類，沒有其他Activity，也就是說ServiceApp沒有任何UI界面。ServiceApp的manifest.xml文件如下所示:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.ispring2.serviceapp" >

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="ServiceApp">

        <service
            android:name=".MyService"
            android:enabled="true"
            android:exported="true" >
           // 聲明為可被其他App調用的
            <intent-filter>
                <action android:name="com.ispring2.action.MYSERVICE" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </service>
    </application>

</manifest>

ServiceApp中MyService的代碼如下所示:

public class MyService extends Service {

    private static final int RECEIVE_MESSAGE_CODE = 0x0001;

    private static final int SEND_MESSAGE_CODE = 0x0002;

    //clientMessenger表示的是客戶端的Messenger，可以通過來自于客戶端的Message的replyTo屬性獲得，
    //其內部指向了客戶端的ClientHandler實例，可以用clientMessenger向客戶端發送消息
    private Messenger clientMessenger = null;

    //serviceMessenger是Service自身的Messenger，其內部指向了ServiceHandler的實例
    //客戶端可以通過IBinder構建Service端的Messenger，從而向Service發送消息，
    //并由ServiceHandler接收并處理來自于客戶端的消息
    //用實現的Handler創建一個Messenger對象，Messenger對象內部會引用該Handler對象
    private Messenger serviceMessenger = new Messenger(new ServiceHandler());
    
    //Service需要實現一個Hanlder，用以處理從客戶端收到的消息
    //MyService用ServiceHandler接收并處理來自于客戶端的消息
    private class ServiceHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            Log.i("DemoLog", "ServiceHandler -> handleMessage");
            if(msg.what == RECEIVE_MESSAGE_CODE){
                Bundle data = msg.getData();
                if(data != null){
                    String str = data.getString("msg");
                    Log.i("DemoLog", "MyService收到客戶端如下信息: " + str);
                }
                //通過Message的replyTo獲取到客戶端自身的Messenger，
                //Service可以通過它向客戶端發送消息
                clientMessenger = msg.replyTo;
                if(clientMessenger != null){
                    Log.i("DemoLog", "MyService向客戶端回信");
                    Message msgToClient = Message.obtain();
                    msgToClient.what = SEND_MESSAGE_CODE;
                    //可以通過Bundle發送跨進程的信息
                    Bundle bundle = new Bundle();
                    bundle.putString("msg", "你好，客戶端，我是MyService");
                    msgToClient.setData(bundle);
                    try{
                        clientMessenger.send(msgToClient);
                    }catch (RemoteException e){
                        e.printStackTrace();
                        Log.e("DemoLog", "MyService向客戶端發送信息失敗: " + e.getMessage());
                    }
                }
            }
        }
    }

    @Override
    public void onCreate() {
        Log.i("DemoLog", "MyService -> onCreate");
        super.onCreate();
    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.i("DemoLog", "MyServivce -> onBind");
        //獲取Service自身Messenger所對應的IBinder，并將其發送共享給所有客戶端
        return serviceMessenger.getBinder();
    }

    @Override
    public void onDestroy() {
        Log.i("DemoLog", "MyService -> onDestroy");
        clientMessenger = null;
        super.onDestroy();
    }
}

客戶端通過收到的IBinder對象實例化一個Messenger對象，該Messenger內部指向指向Service中的Handler。客戶端通過該Messenger對象就可以向Service中的Hanlder發送消息。

Service中的Hanlder收到消息后，在Handler中的handleMessage方法中處理消息。

通過上面的第4步與第5步，就完成了客戶端向Service發送消息并且Service接收到消息的單向通信過程，即客戶端 -> Service。
如果要實現Service向客戶端回消息的通信過程，即Service -> 客戶端，那么前提是在客戶端中也需要像Service一樣內部維護有一個指向Handler的Messenger。當在第四步中客戶端向Service發送信息時，將Message的replyTo屬性設置為客戶端自己的Messenger。這樣在第5步Service在Handler的handleMessage中處理收到的消息時，可以通過Message的Messenger再向客戶端發送Message，這樣客戶端內維護的Handler對象就會收到來自于Service的Message，從而完成Service向客戶端發送消息且客戶端接收到消息的通信過程。

新建一個ClientApp, 該App是客戶端，用于調用服務

public class MainActivity extends Activity {

    private static final int SEND_MESSAGE_CODE = 0x0001;

    private static final int RECEIVE_MESSAGE_CODE = 0x0002;

    private boolean isBound = false;

    //用于啟動MyService的Intent對應的action
    private final String SERVICE_ACTION = "com.ispring2.action.MYSERVICE";

    //serviceMessenger表示的是Service端的Messenger，其內部指向了MyService的ServiceHandler實例
    //可以用serviceMessenger向MyService發送消息
    private Messenger serviceMessenger = null;

    //clientMessenger是客戶端自身的Messenger，內部指向了ClientHandler的實例
    //MyService可以通過Message的replyTo得到clientMessenger，從而MyService可以向客戶端發送消息，
    //并由ClientHandler接收并處理來自于Service的消息
    private Messenger clientMessenger = new Messenger(new ClientHandler());

    //客戶端用ClientHandler接收并處理來自于Service的消息
    private class ClientHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            Log.i("DemoLog", "ClientHandler -> handleMessage");
            if(msg.what == RECEIVE_MESSAGE_CODE){
                Bundle data = msg.getData();
                if(data != null){
                    String str = data.getString("msg");
                    Log.i("DemoLog", "客戶端收到Service的消息: " + str);
                }
            }
        }
    }

    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder binder) {
            //客戶端與Service建立連接
            Log.i("DemoLog", "客戶端 onServiceConnected");

            //我們可以通過從Service的onBind方法中返回的IBinder初始化一個指向Service端的Messenger
            serviceMessenger = new Messenger(binder);
            isBound = true;

            Message msg = Message.obtain();
            msg.what = SEND_MESSAGE_CODE;

            //此處跨進程Message通信不能將msg.obj設置為non-Parcelable的對象，應該使用Bundle
            //msg.obj = "你好，MyService，我是客戶端";
            Bundle data = new Bundle();
            data.putString("msg", "你好，MyService，我是客戶端");
            msg.setData(data);

            //需要將Message的replyTo設置為客戶端的clientMessenger，
            //以便Service可以通過它向客戶端發送消息
            msg.replyTo = clientMessenger;
            try {
                Log.i("DemoLog", "客戶端向service發送信息");
                serviceMessenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
                Log.i("DemoLog", "客戶端向service發送消息失敗: " + e.getMessage());
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            //客戶端與Service失去連接
            serviceMessenger = null;
            isBound = false;
            Log.i("DemoLog", "客戶端 onServiceDisconnected");
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

使用AIDL

AIDL實現步驟：

在目錄main先新建aidl文件夾，在文件夾下新建一個aidl文件

新建好aidl文件后點擊build或run，在debug中生成最終的aidl文件

interface IMyAidlInterface {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
    /* 添加自定義接口方法*/
    void printLog(String msg);
}

新建service，并在其中實現aidl接口中的方法，通過Binder把接口實例傳出去

public class AidlService extends Service {

    IMyAidlInterface.Stub mStub = new IMyAidlInterface.Stub() {
        @Override
        public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

        }
        @Override
        public void printLog(String msg) throws RemoteException {
            Log.i("printLog", "the messager is " + msg);
        }
    };

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mStub;
    }
}

綁定Service，通過binder獲得接口實例引用

    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {

            //獲得Service實現的Aidl接口對象
            mAidlInterface = IMyAidlInterface.Stub.asInterface(service);

            try {
                //調用接口，執行跨進程方法
               mAidlInterface.printLog("使用aidl");
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
}

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

android多進程

android多進程

什么是進程

進程與線程的區別

進程的級別

多進程使用

多進程間通信（IPC）

使用Messenger進行通信

使用AIDL

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

android多進程

什么是進程

進程與線程的區別

進程的級別

多進程使用

多進程間通信（IPC）

使用Messenger進行通信

使用AIDL

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频