内核中的同步—生产者-消费者并发实例

随着人们生活水平的提高，每天早餐基本是牛奶、面包。在牛奶生产的环节中，生产厂家必须和经销商保持良好的沟通才能使效益最大化，具体说就是生产一批就卖一批，并且只有卖完了，才能生产下一批，这样才能达到供需平衡，否则就有可能造成浪费（供过于求）或者物资短缺（供不应求）。假设现在有一个牛奶生产厂家，它有一个经销商，并且由于资金不足，只有一个仓库。牛奶生产厂家首先生产一批牛奶，并存放在仓库里，然后通知经销商来批发。经销商卖完牛奶后，打电话再订购下一批牛奶。牛奶生产厂家接到订单后，才开始生产下一批牛奶。

一、问题分析

在上述问题中，牛奶生产厂家相当于生产者，经销商相当于消费者，仓库则为公共缓冲区。问题属于单一生产者，单一消费者，单一公共缓冲区。这属于典型的进程同步问题。生产者和消费者为不同的线程，公共缓冲区则为临界区。在同一时刻，只能有一个线程访问临界区。

二、实现机制

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/semaphore.h>
#include <linux/delay.h>
#include <linux/kthread.h>
#include <linux/sched.h> 
#include <linux/err.h>

#define PRODUCT_NUMS 10

static struct semaphore sem_producer;
static struct semaphore sem_consumer;
static struct task_struct *producer_task = NULL;
static struct task_struct *consumer_task = NULL;
static char product[12];
static atomic_t num;
static int id = 1;
static int consume_num = 1;

/**
*    生产者线程：该函数代表牛奶生产厂家，负责生产10批牛奶。
*    从代码中可以看出，它的执行受制于sem_producer信号量，当该信号量无法获取时，
*    它将进入睡眠状态，直到信号量可用，它才能继续执行，并且释放sem_consumer
*    信号量。
*/
static int producer(void *p)
{
    int i;
    char *product = (char *)p;
        
    atomic_inc(&num);
    printk("producer [%d] start...\n", current->pid);
    for(i = 0; i < PRODUCT_NUMS; ++i) {
        down(&sem_producer);
        snprintf(product, 12, "2019-08-%d", id++);
        printk("producer [%d] produce %s\n", current->pid, product);
        up(&sem_consumer);
    }
    printk("producer [%d] end...\n", current->pid);
    
    return 0;
}

/**
*    消费者线程：该函数代表牛奶经销商，负责批发并销售牛奶。
*    只有生产厂家生产了牛奶，下发了批发单，经销商才能批发牛奶，批发之后进行零售。
*    当其零售完后，再向牛奶生产厂家下订货单。
*/
static int consumer(void *p)
{
    char *product = (char *)p;
    
    printk("consumer [%d] start...\n", current->pid);
    for(;;){
        msleep(100);
        down_interruptible(&sem_consumer);
        if(consume_num >= PRODUCT_NUMS * atomic_read(&num))
            break;
        printk("consumer [%d] consume %s\n", current->pid, product);
        consume_num++;
        memset(product, 0, 12);
        up(&sem_producer);
    }
    
    printk("consumer [%d] end...\n", current->pid);
    
    return 0;
}

static int __init proccon_init(void)
{
    int err;
    
    printk(KERN_INFO "init producer and consumer.\n");
    sema_init(&sem_producer, 1);
    sema_init(&sem_consumer, 1);
    atomic_set(&num, 0);
    producer_task = kthread_create(producer, product, "producer_task");
    if(IS_ERR(producer_task)){
        printk(KERN_ERR "Unable to create producer thread.\n");
        err = PTR_ERR(producer_task);
        producer_task = NULL;
        return err;
    }

    consumer_task = kthread_create(consumer, product, "consumer_task");
    if(IS_ERR(consumer_task)){
        printk(KERN_ERR "Unable to create consumer thread.\n");
        err = PTR_ERR(consumer_task);
        consumer_task = NULL;
        return err;
    }
    
    wake_up_process(producer_task);
    wake_up_process(consumer_task);
    
    return 0;
    
}

static void __exit proccon_exit(void)
{
    printk(KERN_INFO "exit producer and consumer.\n");
    if(producer_task){
        kthread_stop(producer_task);
        producer_task = NULL;
    }
    
    if(consumer_task){
        kthread_stop(consumer_task);
        consumer_task = NULL;
    }
}

module_init(proccon_init);
module_exit(proccon_exit);

MODULE_LICENSE("GPL");
MODULE_VERSION("v1.0");
MODULE_AUTHOR("xz@vichip.com.cn");
2、Makefile

ifeq ($(KERNELRELEASE),)
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
#$(warning "11111111111111111111111)
all:
        $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
        $(MAKE) -C $(KERNELDIR) M=$(PWD) clean
else
        obj-m := test.o

3、输出日志

<6>[ 1349.142436] init producer and consumer.
<4>[ 1349.142543] producer [3690] start...
<4>[ 1349.142545] consumer [3691] start...
<4>[ 1349.142553] producer [3690] produce 2019-08-1
<4>[ 1349.243633] consumer [3691] consume 2019-08-1
<4>[ 1349.243646] producer [3690] produce 2019-08-2
<4>[ 1349.347627] consumer [3691] consume 2019-08-2
<4>[ 1349.347637] producer [3690] produce 2019-08-3
<4>[ 1349.451610] consumer [3691] consume 2019-08-3
<4>[ 1349.451620] producer [3690] produce 2019-08-4
<4>[ 1349.555608] consumer [3691] consume 2019-08-4
<4>[ 1349.555619] producer [3690] produce 2019-08-5
<4>[ 1349.659601] consumer [3691] consume 2019-08-5
<4>[ 1349.659611] producer [3690] produce 2019-08-6
<4>[ 1349.763593] consumer [3691] consume 2019-08-6
<4>[ 1349.763603] producer [3690] produce 2019-08-7
<4>[ 1349.867587] consumer [3691] consume 2019-08-7
<4>[ 1349.867597] producer [3690] produce 2019-08-8
<4>[ 1349.971624] consumer [3691] consume 2019-08-8
<4>[ 1349.971636] producer [3690] produce 2019-08-9
<4>[ 1350.075616] consumer [3691] consume 2019-08-9
<4>[ 1350.075629] producer [3690] produce 2019-08-10
<4>[ 1350.075632] producer [3690] end...
<4>[ 1350.179609] consumer [3691] end...

三、总结

从结果可以看出，生产者线程首先执行生产一批产品，然后等待消费者线程消费产品。只有消费者消费后，生产者才能进行生产。生产者严格按照生产顺序生产，消费者也严格按照消费顺序消费。