rt-thread nano v3.1.5 事件集无法完成一对多的线程间同步

发布于 2022-05-06 10:46:36 浏览：615 订阅该版

假如有两个线程都需要获取某个事件bit3；
```c
#define    BIT_3    (1 << 3)
//线程A执行调用
rt_event_recv(event_handle, BIT_3, RT_EVENT_FLAG_AND|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved_a);
//线程B执行调用
rt_event_recv(event_handle, BIT_3, RT_EVENT_FLAG_AND|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved_b);
```
当事件BIT_3到来时，无法实现一对多的线程间同步。

分析rt_event_send()函数源码实现：
```c
if (!rt_list_isempty(&event->parent.suspend_thread))
{
	n = event->parent.suspend_thread.next;
	while (n != &(event->parent.suspend_thread))
	{
		thread = rt_list_entry(n, struct rt_thread, tlist);

status = -RT_ERROR;
		if (thread->event_info & RT_EVENT_FLAG_AND)
		{
			if ((thread->event_set & event->set) == thread->event_set)
			{
				status = RT_EOK;
			}
		}   //如果线程接收事件OR选项
		else if (thread->event_info & RT_EVENT_FLAG_OR)
		{
			if (thread->event_set & event->set)
			{
				thread->event_set = thread->event_set & event->set;
				status = RT_EOK;
			}
		}
		else
		{
			/* enable interrupt */
			rt_hw_interrupt_enable(level);

return -RT_EINVAL;
		}

n = n->next;

if (status == RT_EOK)
		{
			if (thread->event_info & RT_EVENT_FLAG_CLEAR)
				//不应该在这里clear事件吧？应该使用临时变量将要clear的事件先保存起来，在while循环外面在进行clear操作!!!
				event->set &= ~thread->event_set;

rt_thread_resume(thread);

need_schedule = RT_TRUE;
		}
	}
}
```
麻烦各位大神协助分析下这个问题。谢谢！

lchnu 2022-05-06

Witness, Understand, Skill

因为你的option中设置了CLEAR，所以在recv的函数中，必须要对已经发生的事件清零。这里的逻辑没有问题。

写了一段不好看的代码，简单测试了一下，也加了必要的注释，两个线程都能获取事件。祝顺利。

当然，你可以根据AB线程的具体优先级，决定到底是哪个线程中CLEAR。这种写法更简单，我不清楚你的具体需求，所以才用了下面的代码：

```c
#include <rtthread.h>

#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>

rt_event_t event_handle;

#define    EVENT_TID_A_DONE   ( 1 << 2 )
#define    EVENT_TID_B_DONE   ( 1 << 1 )
#define    BIT_0              ( 1 << 0 )

void entry_demo_a(void *parameter);
void entry_demo_b(void *parameter);

int main(void)
{
    rt_thread_t tid;

event_handle = rt_event_create("evt_demo", RT_IPC_FLAG_PRIO);

tid = rt_thread_create("ThreadA", entry_demo_a, RT_NULL, 2048, 20, 10);
    rt_thread_startup(tid);

tid = rt_thread_create("ThreadB", entry_demo_b, RT_NULL, 2048, 20, 10);
    rt_thread_startup(tid);

while(1)
    {
        rt_event_send(event_handle, BIT_0);
        rt_thread_delay(1000);
    }

return RT_EOK;
}

void entry_demo_a(void *parameter)
{
    rt_uint32_t recved;
    while(1)
    {
        /* 不清除事件，OR方式等待事件 */
        rt_event_recv(event_handle, BIT_0|EVENT_TID_A_DONE|EVENT_TID_B_DONE, RT_EVENT_FLAG_OR, RT_WAITING_FOREVER, &recved);
        /*AB均未处理事件，或者 B已处理A未处理 */
        if( (BIT_0 == recved) || ( (BIT_0 | EVENT_TID_B_DONE) == recved))
        {
            LOG_I("Thread A: Bit0 EVENT");
            rt_event_send(event_handle, EVENT_TID_A_DONE);
        }
        else if ( (BIT_0|EVENT_TID_A_DONE|EVENT_TID_B_DONE) == recved )
        {
            /* 4.0.5版本中，只提供了这一种事件的Control方式，清除所有事件 */
            rt_event_control(event_handle, RT_IPC_CMD_RESET, RT_NULL);
        }
        /* 因为第一个等待是OR关系，所以每次recv都能获取到事件，防止线程永远占用CPU */
        else
        {
            rt_thread_delay(10);
        }
      }
}

void entry_demo_b(void *parameter)
{
    rt_uint32_t recved;
    while(1)
    {
        /* 不清除事件，OR方式等待事件 */
        rt_event_recv(event_handle, BIT_0|EVENT_TID_A_DONE|EVENT_TID_B_DONE, RT_EVENT_FLAG_OR, RT_WAITING_FOREVER, &recved);
        /*AB均未处理事件，或者 A已处理B未处理 */
        if( (BIT_0 == recved) || ( (BIT_0 | EVENT_TID_A_DONE) == recved))
        {
            LOG_I("Thread B: Bit0 EVENT");
            rt_event_send(event_handle, EVENT_TID_B_DONE);
        }
        else if ( (BIT_0|EVENT_TID_A_DONE|EVENT_TID_B_DONE) == recved )
        {
            /* 4.0.5版本中，只提供了这一种事件的Control方式，清除所有事件 */
            rt_event_control(event_handle, RT_IPC_CMD_RESET, RT_NULL);
        }
        /* 因为第一个等待是OR关系，所以每次recv都能获取到事件，防止线程永远占用CPU */
        else
        {
            rt_thread_delay(10);
        }
      }
}

```

![image.png](https://oss-club.rt-thread.org/uploads/20220506/3c50b799eb3c78adbc89c51d6ce569e9.png)

lchnu 2022-05-06

Witness, Understand, Skill

如果你的A优先级高于B，则可以简化代码，在B中清除事件即可。

`不过，A线程必须要有主动放弃CPU的行为`，不然，A永远都满足运行条件，每次循环都能获取到事件。

```c
int main(void)
{
    rt_thread_t tid;

event_handle = rt_event_create("evt_demo", RT_IPC_FLAG_PRIO);

tid = rt_thread_create("ThreadA", entry_demo_a, RT_NULL, 2048, 11, 10);
    rt_thread_startup(tid);

tid = rt_thread_create("ThreadB", entry_demo_b, RT_NULL, 2048, 12, 10);
    rt_thread_startup(tid);

while(1)
    {
        rt_event_send(event_handle, BIT_0);
        rt_thread_delay(1000);
    }

return RT_EOK;
}

void entry_demo_a(void *parameter)
{
    rt_uint32_t recved;
    while(1)
    {
        rt_event_recv(event_handle, BIT_0, RT_EVENT_FLAG_OR, RT_WAITING_FOREVER, &recved);
        LOG_I("Thread A: Bit0 EVENT");
        rt_thread_delay(10);
      }
}

void entry_demo_b(void *parameter)
{
    rt_uint32_t recved;
    while(1)
    {
        rt_event_recv(event_handle, BIT_0, RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved);
        LOG_I("Thread B: Bit0 EVENT");
      }
}

```