Android UI主进程跟子进程直接相互通信

package com.example.threadcomm;

import android.R.integer;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends Activity {
 /** Called when the activity is first created. */
 // 主线程给子线程发送消息
 Button verifyButton;
 TextView textView;

private static int FROM_MAIN_MSG1 = 1;
 private static int FROM_SUB_MSG2 = 11;

// 主线程
 MainActivityHandler mainHandler;
 // 其它线程
 SubThreadHandler subThreadHandler;

private int i = 0;

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

verifyButton = (Button) findViewById(R.id.verify_button);
  textView = (TextView) findViewById(R.id.text);

textView.setText("");

verifyButton.setOnClickListener(clickListener);

// 创建子线程
  MyThread thread = new MyThread();
  thread.start();
 }

OnClickListener clickListener = new OnClickListener() {

@Override
  public void onClick(View v) {
   switch (v.getId()) {
   // 主线程给子线程发送消息
   case R.id.verify_button:
    textView.append("UI main thread: shall send message to sub-thread......\n\n");
    subThreadHandler.sendEmptyMessage(1);
    break;

default:
    break;
   }
  }
 };

// 主线程处理消息

class MainActivityHandler extends Handler {

public MainActivityHandler(Looper looper) {
   super(looper);
  }

@Override
  public void handleMessage(Message msg) {
   super.handleMessage(msg);

if (msg.what == 11) {
    textView.append("UI main thread: received message from sub-thread......\n\n");
   }
  }
 }

// 以下是子线程类和他的handler类
 class MyThread extends Thread {
  @Override
  public void run() {
   Log.e("threads_comm", "sub thread was created here......");

super.run();
   // 创建该线程的Looper对象,用于接收消息
   Looper.prepare();
   // 线程的looper创建的handler表示消息接收者是子线程
   subThreadHandler = new SubThreadHandler(Looper.myLooper());
   // 循环从MessageQueue中取消息。
   Looper.loop();
  }
 }

// 子线程的Handler

class SubThreadHandler extends Handler {
  public SubThreadHandler(Looper looper) {
   super(looper);
  }

@Override
  public void handleMessage(Message msg) {
   super.handleMessage(msg);

if (msg.what == FROM_MAIN_MSG1) {
    mainHandler = new MainActivityHandler(Looper.getMainLooper());
    textView.append("Sub-thread: received message from UI main thread, and will send message to UI main thread......\n\n");
    mainHandler.sendEmptyMessage(11);

}
  }
 }
}

对应的activity_main.xml文件:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="${relativePackage}.${activityClass}" >

<TextView
        android:id="@+id/text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello_world"
        android:layout_above="@+id/button3"
        android:layout_marginBottom="50dp"
        />

<Button
        android:id="@+id/verify_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="send"
        android:layout_centerInParent="true"
        android:background="@drawable/shape"
        />
</RelativeLayout>

时间: 2024-10-07 17:35:57

Android UI主进程跟子进程直接相互通信的相关文章

记一次WinForm程序中主进程打开子进程并传递参数的操作过程(进程间传递参数)

目标:想在WinForm程序之间传递参数.以便子进程作出相应的处理. 一种错误的方法 父进程的主程序: 1 ProcessStartInfo psi = new ProcessStartInfo(); 2 psi.FileName = "ProcessChild.exe"; 3 psi.Arguments = txtArgs.Text; 4 Process.Start(psi);//主要问题在这里 子进程的主程序: 1 txtArgs.Text = Process.GetCurrent

总结一个主进程启动子进程,删除主进程文件和目录的问题

首先,我们启动子进程的时候,要修改子进程的工作目录. ProcessStartInfo pi = new ProcessStartInfo(fileName, arguments) { WorkingDirectory = Path.GetTempPath() }; pp.StartInfo = pi; pp.Start(); 这里我把工作目录随便指定了一个地方,目的是防止子进程默认继承了主进程的工作目录.如果你省了这一个地方,只要子进程开着,那它的工作目录就和主进程的工作目录是一样的,结局就是

主进程被杀死时,如何保证子进程同时退出,而不变为孤儿进程(一)

在Python中,由于全局解释器锁GIL的存在,使得Python中的多线程并不能大大提高程序的运行效率(这里单指CPU密集型),那么在处理CPU密集型计算时,多用多进程模型来处理,而Python标准库中提供了multiprocessing库来支持多进程模型的编程.multiprocessing中提供了的Process类用于开发人员编写创建子进程,接口类似于标准库提供的threading.Thread类,还提供了进程池Pool类,减少进程创建和销毁带来开销,用以提高复用(见前文). 在多线程模型中

父进程等待子进程结束

from multiprocessing import Process import time # def task(name): # print("%s start" % name) # time.sleep(3) # # print("%s stop" % name) # # if __name__ == '__main__': # p = Process(target=task,args=("jerry",)) # p.start() #

Android ActivityThread(主线程或UI线程)简介

1. ActivityThread功能 它管理应用进程的主线程的执行(相当于普通Java程序的main入口函数),并根据AMS的要求(通过IApplicationThread接口,AMS为Client.ActivityThread.ApplicationThread为Server)负责调度和执行activities.broadcasts和其它操作. 在Android系统中,在默认情况下,一个应用程序内的各个组件(如Activity.BroadcastReceiver.Service)都会在同一个

主进程退出的时候,杀死所有子进程

一.问题背景 大家可能会遇到这样一种情况,自己编写代码的时候,主进程可能会创建很多子进程,但是此时主进程可能由于某种原因自己崩溃,或者认为通过任务管理器结束掉,这时候子进程可能就会依旧存在.下面介绍一种方法可以让到主进程无论什么原因是掉以后子进程也跟着被杀死. 二.技术点 其实也很简单,就是使用一个job内核对象. 三.代码 [cpp] view plain copy #include <Windows.h> int main(int argc, char* argv[]) { STARTUP

Android SharePreference 在主进程和次进程间共享数据不同步出错

SharedPreference作为android五大存储(网络,数据库,文件,SharedPreference,contentProvider)之中最方便使用的一个,从类名上来看就不是一个存储大数据的工具,以key/value成对的形式来存储基本数据类型,只能存储基本数据类型. 在平时的开发中偶尔会遇到SharedPreference在多进程中修改同一个值出现的问题.多进程是指在ddms中看到的不同进程,包括不同应用(不管share uid 是否相同),同一个应用中配置android:proc

主进程或者主线程是否会等待子线程或子进程的问题

1.主进程会等待所有子进程结束后才会程序结束 2.主线程也会等待所有子线程结束后才会主线程结束 3.from multiprocessing import Pool这个进程池,并不会等待所有的进程运行完成,而是主线程代码执行完成后程序就立即结束 . 所以这个进程池需要加p.close()和p.join() 4.from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor  的进程池和线程池,主进程或者主线程会等进程池内

保持Service不被Kill掉的方法--双Service守护 &amp;&amp; Android实现双进程守护

本文分为两个部分,第一部分为双Service守护,第二部分为双进程守护 第一部分: 一.Service简介:Java.lang.Object ?Android.content.Context  ?android.content.ContextWrapper  ?android.app.Service Service是应用程序Application的一个组件(component).它的作用有两点:1.用来提供一个长期在后台运行并且不与用户交互的操作,2.也可以为其他应用程序提供服务.Service