RT-Thread-15天rt-thread入门学习 - 第十二天（生产者-消费者问题）RT-Thread问答社区

15天rt-thread入门学习 - 第十二天（生产者-消费者问题）

发布于 2018-05-28 13:14:05 浏览：1882 订阅该版

* 本帖最后由 coolbor 于 2018-5-28 13:27 编辑 *

主要内容：
1、什么是生产者-消费者问题

生产者  ----  产 品  ----  消费者
   
   同步与互斥的问题

2、生活中的生产者-消费者问题
 
 -------
				 | |
	工 人		 |仓库| 销售员
				 -------
 
3、例程源码解析：使用RT-Thread任务间同步的相关机制给出一个生产者-消费者问题解决模型
 ------------------------------------------------------------------
 定义：
 /* 定义最大5个元素能够被产生 */
 #define MAXSEM 5
 /* 用于放置生产的整数数组 */
 rt_uint32_t array[MAXSEM]; 
 /* 指向生产者、消费者在array数组中的读写位置 */
 static rt_uint32_t set, get; 
 /* 指向线程控制块的指针 */
 static rt_thread_t producer_tid = RT_NULL;
 static rt_thread_t consumer_tid = RT_NULL;
 struct rt_semaphore sem_lock;//解决互斥问题
 struct rt_semaphore sem_empty, sem_full;//解决同步问题
 ------------------------------------------------------------------
 初始化：
 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);
 ------------------------------------------------------------------
 创建任务：
 生产者
 producer_tid = rt_thread_create("producer",
 producer_thread_entry, RT_NULL, /* 线程入口是producer_thread_entry, 入口参数是RT_NULL */
 THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
 消费者
 consumer_tid = rt_thread_create("consumer",
 consumer_thread_entry, RT_NULL, /* 线程入口是consumer_thread_entry, 入口参数是RT_NULL */
 THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);
 ------------------------------------------------------------------
 生产者行为：
 /* 获取一个空位 */
 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);
 ------------------------------------------------------------------
 消费者行为：
 /* 获取一个满位 */
 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 ", (get % MAXSEM), array[get % MAXSEM]);
 get++;
 rt_sem_release(&sem_lock);
 /* 释放一个空位 */
 rt_sem_release(&sem_empty);
 /* 生产者生产到10个数目，停止，消费者线程相应停止 */
 if (get == 10) break;
 =================================================================
作业：
1、使用互斥量替换sem_lock，查看程序运行结果。
-------------------------------------------------------------------
修改后的程序：
```#include <rtthread.h>

#define THREAD_PRIORITY       6
#define THREAD_STACK_SIZE     512
#define THREAD_TIMESLICE      5

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

/* 用于放置生产的整数数组 */
rt_uint32_t array[MAXSEM];
/* 指向生产者、消费者在array数组中的读写位置 */
static rt_uint32_t set, get;

/* 指向线程控制块的指针 */
static rt_thread_t producer_tid = RT_NULL;
static rt_thread_t consumer_tid = RT_NULL;

//struct rt_semaphore sem_lock;
struct rt_mutex mutex_lock;
struct rt_semaphore sem_empty, sem_full;

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

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

/* 修改array内容，上锁 */
 //rt_sem_take(&sem_lock, RT_WAITING_FOREVER);
 rt_mutex_take(&mutex_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_mutex_release(&mutex_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;

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

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

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

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

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

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

int mutex_producer_consumer_init()
{
    /* 初始化3个信号量 */
    //rt_sem_init(&sem_lock, "lock",     1,      RT_IPC_FLAG_FIFO);
    rt_mutex_init(&mutex_lock, "smutex", 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);

/* 创建线程1 */
    producer_tid = rt_thread_create("producer",
                                    producer_thread_entry, RT_NULL, /* 线程入口是producer_thread_entry, 入口参数是RT_NULL */
                                    THREAD_STACK_SIZE, THREAD_PRIORITY - 1, THREAD_TIMESLICE);
    if (producer_tid != RT_NULL)
        rt_thread_startup(producer_tid);

/* 创建线程2 */
    consumer_tid = rt_thread_create("consumer",
                                    consumer_thread_entry, RT_NULL, /* 线程入口是consumer_thread_entry, 入口参数是RT_NULL */
                                    THREAD_STACK_SIZE, THREAD_PRIORITY + 1, THREAD_TIMESLICE);
    if (consumer_tid != RT_NULL)
        rt_thread_startup(consumer_tid);

return 0;
}
/* 如果设置了RT_SAMPLES_AUTORUN，则加入到初始化线程中自动运行 */
#if defined (RT_SAMPLES_AUTORUN) && defined(RT_USING_COMPONENTS_INIT)
    INIT_APP_EXPORT(mutex_producer_consumer_init);
#endif
/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(mutex_producer_consumer_init, producer_consumer sample);```
-------------------------------------------------------------------
运行结果：
``` \ | /
- RT -     Thread Operating System
 / | \     3.0.4 build May 21 2018
 2006 - 2018 Copyright by rt-thread team
msh >mutex_pr
mutex_producer_consumer_init
msh >mutex_producer_consumer_init
the producer generates a number: 1
the consumer[0] get a number: 1
msh >the producer generates a number: 2
the consumer[1] get a number: 2
the producer generates a number: 3
the consumer[2] get a number: 3
the producer generates a number: 4
the consumer[3] get a number: 4
the producer generates a number: 5
the consumer[4] get a number: 5
the producer generates a number: 6
the consumer[0] get a number: 6
the producer generates a number: 7
the consumer[1] get a number: 7
the producer generates a number: 8
the consumer[2] get a number: 8
the producer generates a number: 9
the consumer[3] get a number: 9
the producer generates a number: 10
the consumer[4] get a number: 10
the consumer[0] sum is 55 
 the consumer[32] exit!
the producer exit!```