3、线程通信EventHandler使用

作者：韩茹

公司：程序咖（北京）科技有限公司

鸿蒙巴士专栏作家

一、使用场景

EventHandler开发场景

EventHandler的主要功能是将InnerEvent事件或者Runnable任务投递到其他的线程进行处理，其使用的场景包括：

• 开发者需要将InnerEvent事件投递到新的线程，按照优先级和延时进行处理。投递时，EventHandler的优先级可在IMMEDIATE、HIGH、LOW、IDLE中选择，并设置合适的delayTime。
• 开发者需要将Runnable任务投递到新的线程，并按照优先级和延时进行处理。投递时，EventHandler的优先级可在IMMEDIATE、HIGH、LOW、IDLE中选择，并设置合适的delayTime。
• 开发者需要在新创建的线程里投递事件到原线程进行处理。

EventRunner工作模式

EventRunner的工作模式可以分为托管模式和手动模式。两种模式是在调用EventRunner的create()方法时，通过选择不同的参数来实现的，详见API参考。默认为托管模式。

• 托管模式：不需要开发者调用run()和stop()方法去启动和停止EventRunner。当EventRunner实例化时，系统调用run()来启动EventRunner；当EventRunner不被引用时，系统调用stop()来停止EventRunner。
• 手动模式：需要开发者自行调用EventRunner的run()方法和stop()方法来确保线程的启动和停止。

二、EventHandler

EventHandler，允许在异步线程上发送和处理InnerEvent和Runnable对象。每个EventHandler实例都绑定一个线程，该线程有一个事件队列。线程周期性地从事件队列中检索事件，并将事件分派给EventHandler进行处理。EventHandler将事件或Runnable任务传递到线程的事件队列，并在事件或任务从事件队列中出来时执行它。

您可以使用EventHandler在不同的线程之间调度和处理事件和Runnable 对象，并将事件或Runnable 对象安排在特定的时间间隔内进行处理。

您可以使用此类中提供的方法发送同步或异步事件、延迟事件处理以及设置事件优先级。

您需要重写processEvent（ohos.eventhandler.InnerEvent）方法来处理事件。

EventHandler类的定义：

java.lang.Object

|---ohos.eventhandler.EventHandler
public class EventHandler extends Object
1
2
3
4

EventHandler的属性Priority(优先级)介绍：

EventRunner将根据优先级的高低从事件队列中获取事件或者Runnable任务进行处理。

EventHandler的主要方法介绍：

三、EventRunner

EventRunner，在当前线程中创建和管理事件队列。

调用run()方法后，EventRunner将从事件队列中连续检索事件，并将事件分派给匹配的EventHandler。然后将调用EventHandler#processEvent（InnerEvent）方法来处理事件。

EventRunner类定义。

java.lang.Object

|---ohos.eventhandler.EventRunner

public final class EventRunner extends Object
1
2
3
4
5

EventRunner的主要方法介绍：

四、InnerEvent

InnerEvent，用于定义可以发送到EventHandler的事件的结构。

InnerEvent类的定义：

public final class InnerEvent
extends Object
implements Sequenceable
1
2
3

一个InnerEvent 对象，包含了一个额外的整数字段和一个额外的对象字段来携带特定数据。

InnerEvent的属性介绍：

InnerEvent的构造函数是私有的。因此，需要调用get()方法来创建InnerEvent实例。该方法将从回收对象池中提取InnerEvent实例。

常用方法：

更多方法请查看，官方API

五、流程逻辑

5.1 EventHandler投递InnerEvent事件

EventHandler投递InnerEvent事件，并按照优先级和延时进行处理，开发步骤如下：

1. 创建EventHandler的子类，在子类中重写实现方法processEvent()来处理事件。

	 private static final int EVENT_MESSAGE_NORMAL = 1;
   private static final int EVENT_MESSAGE_DELAY = 2;
   
   private class MyEventHandler extends EventHandler {
       private MyEventHandler(EventRunner runner) {
           super(runner);
       }
       // 重写实现processEvent方法
       @Override
       public void processEvent(InnerEvent event) {
           super.processEvent(event);
           if (event == null) {
               return;
           }
           int eventId = event.eventId;
           switch (eventId) {
               case EVENT_MESSAGE_NORMAL:
                   // 待执行的操作，由开发者定义
                   break;
               case EVENT_MESSAGE_DELAY:
                   // 待执行的操作，由开发者定义
                   break;
               default:
                   break;
           }
       }
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

2. 创建EventRunner，以手动模式为例。

   EventRunner runner = EventRunner.create(false);// create()的参数是true时，则为托管模式
1

3. 创建EventHandler子类的实例。

MyEventHandler myHandler = new MyEventHandler(runner);
1

4. 获取InnerEvent事件。

   // 获取事件实例，其属性eventId, param, object由开发者确定，代码中只是示例。
   long param = 0L; 
   Object object = null; 
   InnerEvent normalInnerEvent = InnerEvent.get(EVENT_MESSAGE_NORMAL, param, object);
   InnerEvent delayInnerEvent = InnerEvent.get(EVENT_MESSAGE_DELAY, param, object);
1
2
3
4
5

5. 投递事件，投递的优先级以IMMEDIATE为例，延时选择0ms和2ms。

// 优先级IMMEDIATE，投递之后立即处理，延时为0ms，该语句等价于同步投递sendSyncEvent(event1，EventHandler.Priority.IMMEDIATE);
myHandler.sendEvent(normalInnerEvent, 0, EventHandler.Priority.IMMEDIATE);
myHandler.sendEvent(delayInnerEvent, 2, EventHandler.Priority.IMMEDIATE); // 延时2ms后立即处理
1
2
3

6. 启动和停止EventRunner，如果为托管模式，则不需要此步骤。

   runner.run();// 待执行操作runner.stop();// 开发者根据业务需要在适当时机停止EventRunner
1

5.2 EventHandler投递Runnable任务

EventHandler投递Runnable任务，并按照优先级和延时进行处理，开发步骤如下：

1. 创建EventHandler的子类，创建EventRunner，并创建EventHandler子类的实例，步骤与EventHandler投递InnerEvent场景的步骤1-3相同。

2. 创建Runnable任务。

   Runnable normalTask = new Runnable() {
       @Override
       public void run() {
           // 待执行的操作，由开发者定义
       }
   };
   Runnable delayTask = new Runnable() {
       @Override
       public void run() {
           // 待执行的操作，由开发者定义
       }
   };
1
2
3
4
5
6
7
8
9
10
11
12

3. 投递Runnable任务，投递的优先级以IMMEDIATE为例，延时选择0ms和2ms。

   // 优先级为immediate，延时0ms，该语句等价于同步投递myHandler.postSyncTask(task1，EventHandler.Priority.immediate);
   myHandler.postTask(normalTask, 0, EventHandler.Priority.IMMEDIATE);
   
   myHandler.postTask(delayTask, 2, EventHandler.Priority.IMMEDIATE);// 延时2ms后立即执行
1
2
3
4

4. 启动和停止EventRunner，如果是托管模式，则不需要此步骤。

   runner.run();
   // 待执行操作
   
   runner.stop();// 停止EventRunner
1
2
3
4

5.3 在新创建的线程里投递事件到原线程

EventHandler从新创建的线程投递事件到原线程并进行处理，开发步骤如下：

1. 创建EventHandler的子类，在子类中重写实现方法processEvent()来处理事件。

   private static final int EVENT_MESSAGE_CROSS_THREAD = 1;
   
   private class MyEventHandler extends EventHandler {
       private MyEventHandler(EventRunner runner) {
           super(runner);
       }
       // 重写实现processEvent方法
       @Override
       public void processEvent(InnerEvent event) {
           super.processEvent(event);
           if (event == null) {
               return;
           }
           int eventId = event.eventId;
           switch (eventId) {
               case EVENT_MESSAGE_CROSS_THREAD:
                   Object object = event.object;
                   if (object instanceof EventRunner) {
                       // 将原先线程的EventRunner实例投递给新创建的线程
                       EventRunner runner2 = (EventRunner) object;
                       // 将原先线程的EventRunner实例与新创建的线程的EventHandler绑定
                       EventHandler myHandler2 = new EventHandler(runner2) {
                           @Override
                           public void processEvent(InnerEvent event) {
                               // 需要在原先线程执行的操作
                           }
                       };
                       int eventId2 = 1; 
                       long param2 = 0L; 
                       Object object2 = null; 
                       InnerEvent event2 = InnerEvent.get(eventId2, param2, object2);
                       myHandler2.sendEvent(event2); // 投递事件到原先的线程
                   }
                   break;
               default:
                   break;
           }
       }
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

2. 创建EventRunner，以手动模式为例。

   EventRunner runner = EventRunner.create(false);// create()的参数是true时，则为托管模式。
1

3. 创建EventHandler子类的实例。

   MyEventHandler myHandler = new MyEventHandler(runner);
1

4. 获取InnerEvent事件。

// 获取事件实例，其属性eventId, param, object由开发者确定，代码中只是示例。
long param = 0L; 
InnerEvent event = InnerEvent.get(EVENT_MESSAGE_CROSS_THREAD, param, EventRunner.current());
1
2
3

5. 投递事件，在新线程上直接处理。

// 将与当前线程绑定的EventRunner投递到与runner创建的新线程中
myHandler.sendEvent(event);
1
2

6. 启动和停止EventRunner，如果是托管模式，则不需要此步骤。

   runner.run();// 待执行操作
   runner.stop();// 停止EventRunner
1
2

六、完整

非托管情况：

// 全局：
public static final int CODE_DOWNLOAD_FILE1 = 1;
public static final int CODE_DOWNLOAD_FILE2 = 2;
public static final int CODE_DOWNLOAD_FILE3 = 3;

// 线程A：
EventRunner runnerA = EventRunner.create(false);
runnerA.run(); // run之后一直循环卡在这里，所以需要新建一个线程run

// 线程B：
// 1.创建类继承EventHandler
public class MyEventHandler extends EventHandler {
    private MyEventHandler(EventRunner runner) {
        super(runner);
    }

    @Override
    public void processEvent(InnerEvent event) {
        super.processEvent(event);
        if (event == null) {
            return;
        }

        int eventId = event.eventId;
        switch (eventId) {
            case CODE_DOWNLOAD_FILE1: {
                // 待执行的操作，由开发者定义
                break;
            }
            case CODE_DOWNLOAD_FILE2: {
                // 待执行的操作，由开发者定义
                break;
            }
            case CODE_DOWNLOAD_FILE3: {
                // 待执行的操作，由开发者定义
                break;
            }
            default:
                break;
        }
    }
}

// 2.创建MyEventHandler实例
MyEventHandler handler = new MyEventHandler(runnerA);

// 3.向线程A发送事件
handler.sendEvent(CODE_DOWNLOAD_FILE1);
handler.sendEvent(CODE_DOWNLOAD_FILE2);
handler.sendEvent(CODE_DOWNLOAD_FILE3);

// 4.runnerA不再使用后，退出
runnerA.stop();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

托管情况：

// 全局：
public static final int CODE_DOWNLOAD_FILE1 = 1;
public static final int CODE_DOWNLOAD_FILE2 = 2;
public static final int CODE_DOWNLOAD_FILE3 = 3;

// 1.创建EventRunner A：
EventRunner runnerA = EventRunner.create("downloadRunner"); // 内部会新建一个线程

// 2.创建类继承EventHandler
public class MyEventHandler extends EventHandler {
    private MyEventHandler(EventRunner runner) {
        super(runner);
    }

    @Override
    public void processEvent(InnerEvent event) {
        super.processEvent(event);
        if (event == null) {
            return;
        }

        int eventId = event.eventId;
        switch (eventId) {
            case CODE_DOWNLOAD_FILE1: {
                // 待执行的操作，由开发者定义
                break;
            }
            case CODE_DOWNLOAD_FILE2: {
                // 待执行的操作，由开发者定义
                break;
            }
            case CODE_DOWNLOAD_FILE3: {
                // 待执行的操作，由开发者定义
                break;
            }
            default:
                break;
        }
    }
}

// 3.创建MyEventHandler实例
MyEventHandler handler = new MyEventHandler(runnerA);

// 4.向线程A发送事件
handler.sendEvent(CODE_DOWNLOAD_FILE1);
handler.sendEvent(CODE_DOWNLOAD_FILE2);
handler.sendEvent(CODE_DOWNLOAD_FILE3);

// 5.runnerA没有任何对象引入时，线程会自动回收
runnerA = null;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

###七、示例代码

1、EventHandler投递InnerEvent事件

我们现在ability_main.xml中放一个按钮：

<?xml version="1.0" encoding="utf-8"?>
<DirectionalLayout
    xmlns:ohos="http://schemas.huawei.com/res/ohos"
    ohos:height="match_parent"
    ohos:width="match_parent"
    ohos:padding="20vp"
    ohos:orientation="vertical">


    <Button
        ohos:id="$+id:btn1"
        ohos:height="match_content"
        ohos:width="match_content"
        ohos:text="EventHandler投递InnerEvent事件"
        ohos:background_element="#eeeeee"
        ohos:padding="20vp"
        ohos:multiple_lines="true"
        ohos:text_size="20fp"
        ohos:margin="10vp"
        />


</DirectionalLayout>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

然后在MainAbility中处理该按钮的点击事件，投递InnerEvent事件：

package com.example.hanrueventhandler.slice;

import com.example.hanrueventhandler.ResourceTable;
import ohos.aafwk.ability.AbilitySlice;
import ohos.aafwk.content.Intent;
import ohos.agp.components.Button;
import ohos.agp.components.Component;
import ohos.agp.components.Text;
import ohos.eventhandler.EventHandler;
import ohos.eventhandler.EventRunner;
import ohos.eventhandler.InnerEvent;
import ohos.hiviewdfx.HiLog;
import ohos.hiviewdfx.HiLogLabel;

public class MainAbilitySlice extends AbilitySlice {

    private static final int EVENT_MESSAGE_NORMAL = 1;
    private static final int EVENT_MESSAGE_DELAY = 2;
    // 定义日志标签
    private static final HiLogLabel LABEL = new HiLogLabel(HiLog.LOG_APP, 0x00201, "MY_TAG");

    @Override
    public void onStart(Intent intent) {
        super.onStart(intent);
        super.setUIContent(ResourceTable.Layout_ability_main);
        initComponent();

    }

    public void initComponent(){
        findComponentById(ResourceTable.Id_btn1).setClickedListener(component -> eventHandlerPostInnerEvent());
    }


    // 按钮1：EventHandler投递InnerEvent事件
    public void eventHandlerPostInnerEvent(){
        // 2.创建EventRunner，手动模式或者托管模式
        EventRunner runner = EventRunner.create(true);// create()的参数是true时，则为托管模式

        // 3.创建EventHandler子类的实例。
        MyEventHandler myHandler = new MyEventHandler(runner);

        // 4.获取InnerEvent事件。
        // 获取事件实例，其属性eventId, param, object由开发者确定。
        long param1 = 9527L;
        Object object1 = "我是王二狗";
        InnerEvent normalInnerEvent = InnerEvent.get(EVENT_MESSAGE_NORMAL, param1, object1);

        long param2 = 1314L;
        Object object2 = "鸿蒙巴士";
        InnerEvent delayInnerEvent = InnerEvent.get(EVENT_MESSAGE_DELAY, param2, object2);

        HiLog.info(LABEL," 。。。");


        // 5.投递事件，投递的优先级以IMMEDIATE为例，延时选择0ms和2ms
        // 优先级IMMEDIATE，投递之后立即处理，延时为0ms，该语句等价于同步投递sendSyncEvent(event1，EventHandler.Priority.IMMEDIATE);
        myHandler.sendEvent(normalInnerEvent, 0, EventHandler.Priority.IMMEDIATE); // 立即处理
        myHandler.sendEvent(delayInnerEvent, 2, EventHandler.Priority.IMMEDIATE); // 延时2ms后立即处理

        // 6.启动和停止EventRunner，如果为托管模式，则不需要此步骤。
        // runner.run();
        // 待执行操作
        // runner.stop();// 开发者根据业务需要在适当时机停止EventRunner

    }

    // 1.创建EventHandler的子类，在子类中重写实现方法processEvent()来处理事件。
    private class MyEventHandler extends EventHandler {
        private MyEventHandler(EventRunner runner) {
            super(runner);
        }
        // 重写实现processEvent方法
        @Override
        public void processEvent(InnerEvent event) {
            super.processEvent(event);
            if (event == null) {
                return;
            }
            int eventId = event.eventId;
            long param = event.param;
            Object object = event.object;
            HiLog.info(LABEL,"子线程。。。线程ID"+Thread.currentThread().getId()+",线程名称："+Thread.currentThread().getName());
            switch (eventId) {
                case EVENT_MESSAGE_NORMAL:
                    // 待执行的操作，由开发者定义
                    HiLog.info(LABEL," 子线程中要处理的操作1。。。"+param+","+ object.toString());

                    break;
                case EVENT_MESSAGE_DELAY:
                    // 待执行的操作，由开发者定义
                    HiLog.info(LABEL," 子线程中要处理的操作2。。。"+param+","+ object.toString());
                    break;
                default:
                    break;
            }
        }
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

运行程序，并点击按钮1：

2、EventHandler投递Runnable任务

我们现在ability_main.xml中，再放一个按钮：

<?xml version="1.0" encoding="utf-8"?>
<DirectionalLayout
    xmlns:ohos="http://schemas.huawei.com/res/ohos"
    ohos:height="match_parent"
    ohos:width="match_parent"
    ohos:padding="20vp"
    ohos:orientation="vertical">

		...
    <Button
        ohos:id="$+id:btn2"
        ohos:height="match_content"
        ohos:width="match_content"
        ohos:text="EventHandler投递Runnable任务"
        ohos:background_element="#eeeeee"
        ohos:multiple_lines="true"
        ohos:padding="20vp"
        ohos:text_size="20fp"
        ohos:margin="10vp"
        />


</DirectionalLayout>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

然后在MainAbility中处理该按钮的点击事件，投递Runnable任务：

    public void initComponent(){
        findComponentById(ResourceTable.Id_btn1).setClickedListener(component -> eventHandlerPostInnerEvent());
        findComponentById(ResourceTable.Id_btn2).setClickedListener(component -> eventHandlerPostRunnableTask());
    }

    // 2.EventHandler投递Runnable任务
    public void eventHandlerPostRunnableTask(){
        // 2.创建EventRunner，手动模式或者托管模式
        EventRunner runner = EventRunner.create(true);// create()的参数是true时，则为托管模式

        // 3.创建EventHandler子类的实例。
        MyEventHandler myHandler = new MyEventHandler(runner);

        // 4.创建Runnable任务。
        Runnable normalTask = new Runnable() {
            @Override
            public void run() {
                // 待执行的操作，由开发者定义
                HiLog.info(LABEL,"子线程ID："+Thread.currentThread().getId()+"，子线程名称："+Thread.currentThread().getName()+"--->Runnable的normalTask");
            }
        };
        Runnable delayTask = new Runnable() {
            @Override
            public void run() {
                // 待执行的操作，由开发者定义
                HiLog.info(LABEL,"子线程ID："+Thread.currentThread().getId()+"，子线程名称："+Thread.currentThread().getName()+"--->Runnable的delayTask");
            }
        };
        HiLog.info(LABEL," 。。。。。。");
        // 5.投递
        // 优先级为immediate，延时0ms，该语句等价于同步投递myHandler.postSyncTask(task1，EventHandler.Priority.immediate);
        myHandler.postTask(normalTask, 0, EventHandler.Priority.IMMEDIATE);

        myHandler.postTask(delayTask, 2, EventHandler.Priority.IMMEDIATE);// 延时2ms后立即执行



        // 6.启动和停止EventRunner，如果为托管模式，则不需要此步骤。
        // runner.run();
        // 待执行操作
        // runner.stop();// 停止EventRunner
    }

    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

运行程序，并点击按钮2：

3、在新创建的线程里投递事件到原线程

我们现在ability_main.xml中，再放一个按钮：

<?xml version="1.0" encoding="utf-8"?>
<DirectionalLayout
    xmlns:ohos="http://schemas.huawei.com/res/ohos"
    ohos:height="match_parent"
    ohos:width="match_parent"
    ohos:padding="20vp"
    ohos:orientation="vertical">

		...
    <Button
        ohos:id="$+id:btn3"
        ohos:height="match_content"
        ohos:width="match_content"
        ohos:text="在新创建的线程里投递事件到原线程"
        ohos:background_element="#eeeeee"
        ohos:padding="20vp"
        ohos:multiple_lines="true"
        ohos:text_size="20fp"
        ohos:margin="10vp"
        />


</DirectionalLayout>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

然后在MainAbility中处理该按钮的点击事件，在新创建的线程里投递事件到原线程：

public void initComponent(){
        findComponentById(ResourceTable.Id_btn1).setClickedListener(component -> eventHandlerPostInnerEvent());
        findComponentById(ResourceTable.Id_btn2).setClickedListener(component -> eventHandlerPostRunnableTask());
        findComponentById(ResourceTable.Id_btn3).setClickedListener(component -> postInnerEventToOriginalThread());
    }

    // 3.在新创建的线程里投递事件到原线程
    public void postInnerEventToOriginalThread(){
        // 2.创建EventRunner，手动模式或者托管模式
        EventRunner runner = EventRunner.create(true);// create()的参数是true时，则为托管模式

        // 3.创建EventHandler子类的实例。
        MyEventHandler myHandler = new MyEventHandler(runner);

        // 4.获取InnerEvent事件。
        // 获取事件实例，其属性eventId, param, object由开发者确定。
        long param = 723L;
        // 注意：这里的第三个参数Object，要传入当前线程对象。
        InnerEvent event = InnerEvent.get(EVENT_MESSAGE_CROSS_THREAD, param, EventRunner.current());

        // 5.投递事件，将与当前线程绑定的EventRunner投递到与runner创建的新线程中
        myHandler.sendEvent(event);


        // 6.启动和停止EventRunner，如果为托管模式，则不需要此步骤。
        // runner.run();
        // 待执行操作
        // runner.stop();// 开发者根据业务需要在适当时机停止EventRunner
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

然后我们在MyEventHandler中，再加一个case进行处理：

private class MyEventHandler extends EventHandler {
        private MyEventHandler(EventRunner runner) {
            super(runner);
        }
        // 重写实现processEvent方法
        @Override
        public void processEvent(InnerEvent event) {
            super.processEvent(event);
            if (event == null) {
                return;
            }
            int eventId = event.eventId;
            long param = event.param;
            Object object = event.object;
            HiLog.info(LABEL,"子线程。。。线程ID"+Thread.currentThread().getId()+",线程名称："+Thread.currentThread().getName());
            switch (eventId) {
                case EVENT_MESSAGE_NORMAL:
                    // 待执行的操作，由开发者定义
                    break;
                case EVENT_MESSAGE_DELAY:
                    // 待执行的操作，由开发者定义
                    break;
                case EVENT_MESSAGE_CROSS_THREAD:
                    if (object instanceof EventRunner) {
                        HiLog.info(LABEL," 子线程中要处理的操作3。。。"+param+","+ object.toString());
                        // 将原先线程的EventRunner实例投递给新创建的线程
                        EventRunner runner2 = (EventRunner) object;
                        // 将原先线程的EventRunner实例与新创建的线程的EventHandler绑定
                        EventHandler myHandler2 = new EventHandler(runner2) {
                            @Override
                            public void processEvent(InnerEvent event) {
                                // 需要在原先线程执行的操作
                                HiLog.info(LABEL," 原先的线程。。。"+Thread.currentThread().getId()+"，"+Thread.currentThread().getName());
                                HiLog.info(LABEL," 原先的线程。。。eventId"+event.eventId+"，param："+event.param+"，object："+event.object);
                            }
                        };
                        int eventId2 = 1;
                        long param2 = 9988L;
                        Object object2 = "我是小白菜";
                        InnerEvent event2 = InnerEvent.get(eventId2, param2, object2);
                        myHandler2.sendEvent(event2); // 投递事件到原先的线程
                    }
                    break;
                default:
                    break;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

运行程序，并点击按钮3：