关于android进程间通信（handler、messenger、AIDL）

最新推荐文章于 2022-07-26 00:07:04 发布

crazymaple213

最新推荐文章于 2022-07-26 00:07:04 发布

阅读量3.8k

点赞数 1

分类专栏： android 文章标签： android AIDL Messenger 进程通信

本文链接：https://blog.csdn.net/crazymaple213/article/details/50352995

版权

android 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

关于进程间通信，首先需要思考几个问题：

1.进程间通信适用什么场合？

2.进程和线程区别是什么？

3.Handler用于线程间通信，可以实现进程间通信吗?

4.跨进程通信messager

5.跨进程通信AIDL

就按照上边的步骤我们去开始了解并且熟悉进程间通信。

1.进程间通信

进程间通信就是在不同进程之间传播或交换信息，那么不同进程之间存在着什么双方都可以访问的介质呢？进程的用户空间是互相独立的，一般而言是不能互相访问的，唯一的例外是共享内存区。但是，系统空间却是“公共场所”，所以内核显然可以提供这样的条件。除此以外，那就是双方都可以访问的外设了。

进程间通信（IPC，Interprocess communication）是一组编程接口，让程序员能够协调不同的程序进程，使之能在一个操作系统里同时运行。这使得一个程序能够在同一时间里处理许多用户的要求。因为即使只有一个用户发出要求，也可能导致一个操作系统中多个进程的运行，进程之间必须互相通话。IPC接口就提供了这种可能性。每个 IPC方法均有它自己的优点和局限性，因此，对于单个程序而言使用所有的IPC方法是不常见的。

进程通信使用场合：

1）数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几兆字节之间。

2）共享数据：多个进程想要操作共享数据，一个进程对共享数据的修改，别的进程应该立刻看到。

3）通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。

4）资源共享：多个进程之间共享同样的资源。为了作到这一点，需要内核提供锁和同步机制。

5）进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

进程通过与内核及其它进程之间的互相通信来协调它们的行为。

综上所述，对于android开发人员来说，就是你开发了两个app，要数据共享，而又不能对其他app共享，比如账号密码。

2.进程和线程

进程是具有一定独立功能的程序，是系统进行资源分配和调度的一个独立单位。

线程是进程中的一个实体，是cpu分配资源和调度的基本单位

一个程序至少有一个进程，一个进程至少有一个线程，线程的划分尺度小于进程。

进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

3.Handler

主要接受子线程发送的数据，并用此数据配合主线程更新UI

handler可以分发Message对象和Runnable对象到主线程中，每个Handler实例，都会绑定到创建他的线程中(一般是位于主线程)，它有两个作用：

(1)安排消息或Runnable 在某个主线程中某个地方执行；

(2)安排一个动作在不同的线程中执行

使用：

首先，我们定义两个service，一个默认进程，一个在remote进程。

默认进程service

public class ThreadHandlerService extends Service {
    public ThreadHandlerService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        return new ThreadLocalBinder();
    }


    public void sayHi(){
        Toast.makeText(ThreadHandlerService.this, "Hi，I'm thread service!", Toast.LENGTH_SHORT).show();
    }

    public class ThreadLocalBinder extends Binder{

        public ThreadHandlerService getService(){

            return ThreadHandlerService.this;
        }
    }
}

remote service

<span style="font-size:18px;">public class ProHandlerService extends Service {
    public ProHandlerService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        return new ProLocalBinder();
    }


    public void sayHi(){
        Toast.makeText(ProHandlerService.this, "Hi，I'm pro service!", Toast.LENGTH_SHORT).show();
    }

    public class ProLocalBinder extends Binder{

        public ProHandlerService getService(){

            return ProHandlerService.this;
        }
    }
}</span>

他们的代码基本相似，区别不在这里，而是在配置文件

<span style="font-size:18px;"><service
            android:name=".service.ThreadHandlerService"
            android:enabled="true"
            android:exported="true" />
        <service
            android:name=".service.ProHandlerService"
            android:enabled="true"
            android:exported="true"
            android:process=":remote" /></span>

接下来我们创建两个activity去绑定这两个service，进行连接

public class ThreadConHandlerActivity extends AppCompatActivity {

    private ServiceConnection serviceConnection;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_thread_con);
        initVIew();
    }

    private void initVIew() {
        serviceConnection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                Log.d("", "service connected");
                ThreadHandlerService threadHandlerService = ((ThreadHandlerService.ThreadLocalBinder)service).getService();
                threadHandlerService.sayHi();
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
                Log.d("", "service disconnected");
            }
        };
    }

    @Override
    protected void onStart() {
        super.onStart();
        Intent service = new Intent(this.getApplicationContext(),ThreadHandlerService.class);
        this.bindService(service, serviceConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        this.unbindService(serviceConnection);
    }
}

你会发现handler是无法在跨进程的线程中传递message的。原因？下篇博文介绍，这里就不重点说了。

4.Messenger

Messager实现IPC通信，底层使用了AIDL方式。和AIDL方式不同的是，Messager方式是利用Handler形式处理，因此，它是线程安全的，这也表示它不支持并发处理；而AIDL方式是非线程安全的，支持并发处理，因此，我们使用AIDL方式时需要保证代码的线程安全。

大部分情况下，我们应用中不需要并发处理,只需要使用Messager方式

接入代码：

service

public class ProConMessagerService extends Service {

    public static final int MSG_SAY_HELLO = 1;

    public ProConMessagerService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        return messenger.getBinder();
    }



    Handler incomingHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            if(msg.replyTo != null){
                Message msg_client = this.obtainMessage();
                msg_client.what = ProConMessagerActivity.SAY_HELLO_TO_CLIENT;
                msg_client.replyTo = messenger;
                try {
                    ((Messenger) msg.replyTo).send(msg_client);
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            switch (msg.what) {
                case MSG_SAY_HELLO:
//                    Toast.makeText(ProConMessagerService.this.getApplicationContext(), "Hello World Remote Service!",
//                            Toast.LENGTH_SHORT).show();
                    break;
                default:
                    super.handleMessage(msg);
            }
        }

    };

    Messenger messenger =new Messenger(incomingHandler);

}

activity

public class ProConMessagerActivity extends AppCompatActivity {

    String TAG = "ProConMessagerActivity";
    private ServiceConnection mSc;
    public static final int SAY_HELLO_TO_CLIENT = 1;
    private ListView remoteLv;
    private MessageAdapter messageAdapter;
    private List<MessageInfo> list = new ArrayList<MessageInfo>();
    private int count =0;
    Messenger messenger_reciever = new Messenger(new IncomingHandler());

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_pro_con_messager);
        initView();
    }
    private void initView() {
        remoteLv = (ListView)findViewById(R.id.activity_pro_con_messager_lv);
        messageAdapter = new MessageAdapter(this);
        remoteLv.setAdapter(messageAdapter);
        mSc = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                MessageInfo info = new MessageInfo();
                info.setSender("system");
                info.setReceiver("server,client");
                info.setContent("Hello,service connected");
                info.setCreateTime(String.valueOf(System.currentTimeMillis()));
                list.add(info);
                messageAdapter.setList(list);
                Messenger messenger = new Messenger(service);
                Message msg = new Message();
                msg.what = ProConMessagerService.MSG_SAY_HELLO;
                msg.replyTo = messenger_reciever;
                try {
                    messenger.send(msg);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {
                // 在同service的连接意外丢失时调用这个．比如当service崩溃了或被强杀了．当客户端解除绑定时，这个方法不会被调用．
                Log.d(TAG, "service disconnected");
                MessageInfo info = new MessageInfo();
                info.setSender("system");
                info.setReceiver("server,client");
                info.setContent("Hello,service disconnected");
                info.setCreateTime(String.valueOf(System.currentTimeMillis()));
                list.add(info);
                messageAdapter.setList(list);
            }
        };
    }

    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case SAY_HELLO_TO_CLIENT:
                    MessageInfo info = new MessageInfo();
                    info.setSender("client");
                    info.setReceiver("server");
                    info.setContent("Hello,Server");
                    info.setCreateTime(String.valueOf(System.currentTimeMillis()));
                    list.add(info);
                    messageAdapter.setList(list);
//                    Toast.makeText(ProConMessagerActivity.this.getApplicationContext(), "Hello World Remote Client!",
//                            Toast.LENGTH_SHORT).show();
                    Message msgToServer = new Message();
                    msgToServer.what = ProConMessagerService.MSG_SAY_HELLO;
                    msgToServer.replyTo = messenger_reciever;
                    try {
                        if(count<5){
                            count++;
                            ((Messenger) (msg.replyTo)).send(msgToServer);
                            info = new MessageInfo();
                            info.setSender("server");
                            info.setReceiver("client");
                            info.setContent("Hello,Client!" );
                            info.setCreateTime(String.valueOf(System.currentTimeMillis()));
                            list.add(info);
                            messageAdapter.setList(list);
                        }else{
                            try {
                                ProConMessagerActivity. this.unbindService(mSc);
                                Log.d(TAG, "service disconnected");
                                info = new MessageInfo();
                                info.setSender("system");
                                info.setReceiver("server,client");
                                info.setContent("Hello,service disconnected");
                                info.setCreateTime(String.valueOf(System.currentTimeMillis()));
                                list.add(info);
                                messageAdapter.setList(list);
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }

                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }


    @Override
    protected void onStart() {
        super.onStart();
        Log.d(TAG, this.getApplicationContext().getPackageCodePath());
        Intent service = new Intent(this.getApplicationContext(),ProConMessagerService.class);
        this.bindService(service, mSc, Context.BIND_AUTO_CREATE);
    }


    @Override
    protected void onPause() {
        super.onPause();
        try {
            this.unbindService(mSc);
            Log.d(TAG, "service disconnected");
            MessageInfo info = new MessageInfo();
            info.setSender("system");
            info.setReceiver("server,client");
            info.setContent("Hello,service disconnected");
            info.setCreateTime(String.valueOf(System.currentTimeMillis()));
            list.add(info);
            messageAdapter.setList(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5.AIDL

AIDL（Android Interface Definition Language）是一种接口定义语言，编译器通过*.aidl文件的描述信息生成符合通信协议的Java代码，我们无需自己去写这段繁杂的代码，只需要在需要的时候调用即可，通过这种方式我们就可以完成进程间的通信工作。

首先，你需要熟悉一下AIDL的使用，

server端：

创建.aidl文件

实现接口（如果你是使用android studio，发现找不到接口类，你可以先clean下）

client端：

copy server端的aidl到client端aidl下，包名用server端的。

调用远端接口的步骤：

1. 声明.aidl文件中定义的接口类型的变量。

2. 实现ServiceConnection

3. 调用Context.bindService()，传递ServiceConnection的实现

4. 在ServiceConnection.onServiceConnected()方法中会接收到IBinder对象，调用YourInterfaceName.Stub.asInterface((IBinder)service)将返回值转换为YourInterface类型

5. 调用接口中定义的方法。应该总是捕获连接被打断时抛出的DeadObjectException异常，这是远端方法唯一的异常。

6. 调用Context.unbindService()断开连接

贴上部分代码：

public class ProConAidlActivity extends AppCompatActivity implements View.OnClickListener{

    private Button bindBtn,greetBtn,unbindBtn;

    private IPerson person;
    private ServiceConnection mSc;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_pro_con_aidl);
        initView();
    }

    private void initView() {
        bindBtn = (Button)findViewById(R.id.activity_pro_con_aidl_bind);
        greetBtn = (Button)findViewById(R.id.activity_pro_con_aidl_greet);
        unbindBtn = (Button)findViewById(R.id.activity_pro_con_aidl_unbind);
        bindBtn.setOnClickListener(this);
        greetBtn.setOnClickListener(this);
        unbindBtn.setOnClickListener(this);
        bindBtn.setEnabled(true);
        greetBtn.setEnabled(false);
        unbindBtn.setEnabled(false);
        mSc = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                person = IPerson.Stub.asInterface(service);
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {

            }
        };
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.activity_pro_con_aidl_bind:
                Intent intent = new Intent("android.intent.action.AIDLService");
                bindService(intent, mSc, Context.BIND_AUTO_CREATE);
                Log.e("","service connected!");
                bindBtn.setEnabled(false);
                greetBtn.setEnabled(true);
                unbindBtn.setEnabled(true);
                break;
            case R.id.activity_pro_con_aidl_greet:
                try {
                    String retVal = person.greet("aidl ,no do no die");
                    Toast.makeText(ProConAidlActivity.this, retVal, Toast.LENGTH_SHORT).show();
                } catch (RemoteException e) {
                    Toast.makeText(ProConAidlActivity.this, "error", Toast.LENGTH_SHORT).show();
                }
                break;
            case R.id.activity_pro_con_aidl_unbind:
                unbindService(mSc);
                Log.e("", "service disconnected!");
                bindBtn.setEnabled(true);
                greetBtn.setEnabled(false);
                unbindBtn.setEnabled(false);
                break;
        }
    }
}

项目下载地址：下载页面

crazymaple213

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
关于android进程间通信（handler、messenger、AIDL）

关于进程间通信，首先需要思考几个问题： 1.进程间通信适用什么场合？2.进程和线程区别是什么？3.Handler用于线程间通信，可以实现进程间通信吗?4.跨进程通信messager5.跨进程通信AIDL就按照上边的步骤我们去开始了解并且熟悉进程间通信。1.进程间通信进程间通信就是在不同进程之间传播或交换信息，那么不同进程之间存在着
复制链接

扫一扫