关于线程的问题：注释掉第15条语句，由于线程2（20）比线程1（18）优先级低，那么线程2还能执行么？

发布于 2009-09-05 08:32:04 浏览：8186 订阅该版

1、void consumer_thread_entry(void *parameter)
2、{
3、   rt_uint32_t no,sum;
4、   no=(rt_uint32_t)parameter;
5、   while(1)
6、   {
7、      rt_sem_take(&sem_full,RT_WAITING_FOREVER);
8、	  rt_sem_take(&sem_lock,RT_WAITING_FOREVER);
9、	  sum+=array[get%MAXSEM];
10、      rt_kprintf("The consumer[%d} get anumber: %d<br>",no,array[get%MAXSEM]);
11、	  get++;
12、	  rt_sem_release(&sem_lock);
13、	  rt_sem_release(&sem_empty);
14、	  if(get==100) break;
           //注释掉下面的一句话，由于线程2比线程1优先级低，那么线程2还能执行么？
15、	 // rt_thread_delay(10);
16、	}
17、	rt_kprintf("The consumer[%d] sum is %d <br>",no,sum);
18、	rt_kprintf("The consumer[%d] exit!<br>",no);
19、}
20、int application_tread_init(void)
21、{
22、  rt_thread_t p,s;
23、  rt_sem_init(&sem_lock,"lock", 1,RT_IPC_FLAG_FIFO);
24、  rt_sem_init(&sem_empty,"empty",MAXSEM,RT_IPC_FLAG_FIFO);
25、  rt_sem_init(&sem_full,"full",0,RT_IPC_FLAG_FIFO);
26、  p=rt_thread_create("p",producer_thread_entry,RT_NULL,1024,18,10);
27、  rt_thread_startup(p);
28、  s=rt_thread_create("s1",consumer_thread_entry,(void*)1,1024,18,5);
29、  if(s!=RT_NULL) rt_thread_startup(s);
30、  s=rt_thread_create("s2",consumer_thread_entry,(void*)2,1024,20,5);
31、  if(s!=RT_NULL) rt_thread_startup(s);

32、   return 0;
33、}

11 个回答

xfocus 2009-09-05

这家伙很懒，什么也没写！

找到出处了

RT-Thread Programming Guide, Release 0.3.0
22 Chapter 3. 快速入门

3.6 生产者消费者问题
生产者消费者问题是操作系统中的一个经典问题，在嵌入式操作系统中也经常能够遇到，
例如串口中接收到数据，然后由一个任务统一的进行数据的处理：串口产生数据，任务作
为一个消费者消费数据。
在下面的例子中，将用RT-Thread的编程模式来实现一个生产者、消费者问题的解决代
码。

```

#include <rtthread.h>

/* 定义最大5个元素能够被产生 */
    #define MAXSEM 5

/* 用于放置生产的整数数组 */
    rt_uint32_t array[MAXSEM];

struct rt_semaphore sem_lock;
    struct rt_semaphore sem_empty, sem_full;
    /* 指向生产者、消费者在array数组中的读写位置 */
    static rt_uint32_t set, get;

/* 生成者线程入口 */
    void producer_thread_entry(void* parameter)
    {
        int cnt = 0;

/* 运行100次 */
        while( cnt < 100)
        {
            /* 获取一个空位 */
            rt_sem_take(&sem_empty, RT_WAITING_FOREVER);

/* 修改array内容，上锁 */
            rt_sem_take(&sem_lock, RT_WAITING_FOREVER);
            array[set%MAXSEM] = cnt + 1;
            rt_kprintf("the producer generates a number: %d
", array[set%MAXSEM]);
            set++;
            rt_sem_release(&sem_lock);

/* 发布一个满位 */
            rt_sem_release(&sem_full);
            cnt++;

/* 暂停一段时间 */
            rt_thread_delay(50);
        }

rt_kprintf("the producer exit!
");
    }

/* 消费者线程入口 */
    void consumer_thread_entry(void* parameter)
    {
        rt_uint32_t no;
        rt_uint32_t sum;

/* 第n个线程，由入口参数传进来 */
        no = (rt_uint32_t)parameter;

while(1)
        {
            /* 获取一个满位 */
            rt_sem_take(&sem_full, RT_WAITING_FOREVER);

/* 临界区，上锁进行操作 */
            rt_sem_take(&sem_lock, RT_WAITING_FOREVER);
            sum += array[get%MAXSEM];
            rt_kprintf("the consumer[%d] get a number: %d
", no, array[get%MAXSEM] );
            get++;
            rt_sem_release(&sem_lock);

/* 释放一个空位 */
            rt_sem_release(&sem_empty);

/* 生产者生产到100个数目，停止，消费者线程相应停止 */
            if (get == 100) break;

/* 暂停一小会时间 */
            rt_thread_delay(10);
        }

rt_kprintf("the consumer[%d] sum is %d 
 ", no, sum);
        rt_kprintf("the consumer[%d] exit!
");
    }

/**
     * This function will be invoked to initalize user application when system startup.
     */
    int rt_application_init()
    {
        rt_thread_t p, s;

/* 初始3个信号量 */
        rt_sem_init(&sem_lock , "lock",     1,      RT_IPC_FLAG_FIFO);
        rt_sem_init(&sem_empty, "empty",    MAXSEM, RT_IPC_FLAG_FIFO);
        rt_sem_init(&sem_full , "full",     0,      RT_IPC_FLAG_FIFO);

/* 创建 生产者 线程 */
        p = rt_thread_create("p",
            producer_thread_entry, RT_NULL,
            1024, 18, 5);
        rt_thread_startup(p);

/* 创建 消费者 线程，入口相同，入口参数不同，优先级相同 */
        s = rt_thread_create("s1",
            consumer_thread_entry, (void *)1,
            1024, 20, 5);
        if (s != RT_NULL) rt_thread_startup(s);

s = rt_thread_create("s2",
            consumer_thread_entry, (void *)2,
            1024, 20, 5);
        if (s != RT_NULL) rt_thread_startup(s);

return 0;
    }

```

在上面的例子中，系统启动了一个生产者线程p，用于向仓库（array数组）中产生一个整
数（1 到100）；启动了两个消费者线程s1和s2，它们的入口函数是同一个，只是通过入口
参数分辨它们是第一个消费者线程还是第二个消费者线程。这两个消费者线程将同时从仓
库中获取生成的整数，然后把它打印出来。