Linux内核编程--信号量机制

semget函数
int semget(key_t key, int nsems, int semflg);
--功能：用来创建和访问一个信号量集
--参数:
key：信号集的key值
nsems：信号集中信号量的个数
semflg：由九个权限标志构成，他们的用法和创建文件时使用的mode模式标志是一样的
--返回值：
成功返回一个非负整数，即该信号集的标识码，失败返回-，并且更新errno

int sem_init(sem_t *sem, int pshared, unsigned int value);
参数说明:
a. sem为指向未初始化信号量结构的一个指针
b. pshared参数表示这个信号量是在进程的线程之间共享，还是在进程之间共享。
    如果pshared的值为0，那么这个信号量会在进程的线程之间共享，并且应该位于对所有线程都可见的某个地址
    如果pshared非零，那么这个信号量将在进程之间共享，并且应该位于共享内存的某个区域，(因为fork创建的子进程会继承父进程的内存映射，所以它也可以获取信号量)。
    任何可以访问共享内存区域的进程都可以使用sem_post、sem_wait等对这个信号量进行操作。
c. value指定信号量的初始值
功能:
初始化信号量
返回值:成功返回0，失败返回-1

int sem_destroy(sem_t *sem);
参数说明:
sem为通过sem_init(3)初始化的信号量
功能:
释放信号量
返回值:成功返回0，失败返回-1

int sem_post(sem_t *sem);
参数说明:
sem为通过sem_init初始化的信号量
功能:
sem_post函数的作用是给信号量的值加上一个“1”，它是一个“原子操作”－－－即同时对同一个信号量做加“1”操作的两个线程是不会冲突的；
信号量的值永远会正确地加一个“2”－－因为有两个线程试图改变它。
返回值:成功返回0，失败返回-1

int sem_wait(sem_t *sem);
参数说明:
sem为通过sem_init初始化的信号量
功能:
sem_wait函数也是一个原子操作，它的作用是从信号量的值减去一个“1”，但它永远会先等待该信号量为一个非零值才开始做减法。
也就是说，如果你对一个值为2的信号量调用sem_wait(),线程将会继续执行,信号量的值将减到1。如果对一个值为0的信号量调用sem_wait()，
这个函数就会地等待直到有其它线程增加了这个值使它不再是0为止。如果有两个线程都在sem_wait()中等待同一个信号量变成非零值，
那么当它被第三个线程增加 一个“1”时，等待线程中只有一个能够对信号量做减法并继续执行，另一个还将处于等待状态。
返回值:成功返回0，失败返回-1

#include <pthread.h>
#include <semaphore.h>

sem_t mutex;

void *my_thread(void *arg){
    while(1){
        sem_wait(&mutex);
        //some process code
        sem_post(&mutex);
    }
}

int main(){
    pthread_t thread_1, thread_2;

    sem_init(&mutex, 0 ,1);
    pthread_create(&thread_1, NULL, &my_thread, NULL);
    pthread_create(&thread_2, NULL, &my_thread, NULL);
    pthread_join(thread_1, NULL);
    pthread_join(thread_2, NULL);
    sem_destroy(&mutex);
}

#include <pthread.h>
#include <semaphore.h>
#include <stdlib.h>
#include <stdio.h>

#define MaxItems 5
#define BufferSize 5

sem_t empty;
sem_t full;
int in = 0;
int out = 0;
int buffer[BufferSize];
pthread_mutex_t mutex;

void *producer(void *pno)
{   
    int i;
    int item;
    for(i = 0; i < MaxItems; i++) {
        item = rand();
        sem_wait(&empty);
        pthread_mutex_lock(&mutex);
        buffer[in] = item;
        printf("Producer %d: Insert Item %d at %d\n", *((int *)pno),buffer[in],in);
        in = (in+1)%BufferSize;
        pthread_mutex_unlock(&mutex);
        sem_post(&full);
    }
}
void *consumer(void *cno)
{   
    int i;
    for(i = 0; i < MaxItems; i++) {
        sem_wait(&full);
        pthread_mutex_lock(&mutex);
        int item = buffer[out];
        printf("Consumer %d: Remove Item %d from %d\n",*((int *)cno),item, out);
        out = (out+1)%BufferSize;
        pthread_mutex_unlock(&mutex);
        sem_post(&empty);
    }
}

int main()
{   
    pthread_t pro[5],con[5];
    pthread_mutex_init(&mutex, NULL);
    sem_init(&empty,0,BufferSize);
    sem_init(&full,0,0);
    int i;
    int a[5] = {1,2,3,4,5};

    for(i = 0; i < 5; i++) {
        pthread_create(&pro[i], NULL, (void *)producer, (void *)&a[i]);
    }
    for(i = 0; i < 5; i++) {
        pthread_create(&con[i], NULL, (void *)consumer, (void *)&a[i]);
    }

    for(i = 0; i < 5; i++) {
        pthread_join(pro[i], NULL);
    }
    for(i = 0; i < 5; i++) {
        pthread_join(con[i], NULL);
    }
    pthread_mutex_destroy(&mutex);
    sem_destroy(&empty);
    sem_destroy(&full);
    return 0;
    
}

gcc sem_test.c -lpthread -o sem_test
./sem_test

semaphore offer1=0; //桌上组合一的数量
semaphore offer2=0; //桌上组合二的数量
semaphore offer3=0; //桌上组合三的数量
semaphore finish=0; //抽烟是否完成
int i=0; //用于实现三个吸烟者轮流吸烟

//供应者进程
provider(){
    while(1){
        if(i==0){
            将组合一放桌上
            V(offer1); //提醒一号吸烟者吸烟
        }else if(i==1){
            将组合二放桌上
            V(offer2); //提醒二号吸烟者吸烟
        }else{
            将组合三放桌上
            V(offer3); //提醒三号吸烟者吸烟
        }
        i=(i+1)%3; //实现让三个吸烟者轮流吸烟
        P(finish); //等待吸烟者吸烟完成后继续放组合
    }
}

//一号吸烟者进程
smoker1(){
    while(1){
        P(offer1); //等待组合一放到桌上
        从桌上拿走组合一，吸烟
        V(finish); //提醒供应者提供新组合
    }
}

//二号吸烟者进程
smoker2(){
    while(1){
        P(offer2); //等待组合二放到桌上
        从桌上拿走组合二，吸烟
        V(finish); //提醒供应者提供新组合
    }
}

//三号吸烟者进程
smoker3(){
    while(1){
        P(offer3); //等待组合三放到桌上
        从桌上拿走组合三，吸烟
        V(finish); //提醒供应者提供新组合
    }
}

#include <stdio.h>
#include <sys/types.h>
#include <semaphore.h>

int table_used = 1;
int generated_item[2];
int generated = 0;

char *item[] = {"tubaco", "paper", "matches"};
sem_t table;

//供应者进程
void *agent(void *arg)
{
    int i,j,k=0;
    while(1)
    {
        sleep(1);
        sem_wait(&table);
        if (table_used == 1)
        {
            i = k;
            j = i + 1;
            if (j == 3)
                j = 0;
            k = j;
            
            //模拟三种不同的组合
            //[0,1] --> 吸烟者2抽烟
            //[1,2] --> 吸烟者0抽烟
            //[2,0] --> 吸烟者1抽烟
            generated_item[0] = i;
            generated_item[1] = j;

            printf("agent is produced %s,%s\n", item[i], item[j]);
            generated = 1;
            table_used = 0;
        }
        sem_post(&table);
    }
}

void *smoker(int i)
{
    while(1)
    {
        sleep(1);
        sem_wait(&table);
        if (table_used == 0)
        {
            if(generated && generated_item[0] != i && generated_item[1] != i)
            {
                printf("smoker%d completed his smoking\n", i);
                //释放桌子的空间
                table_used = 1;
                generated = 0;
            }
        }
        sem_post(&table);
    }
}

main()
{
    pthread_t smk_0, smk_1, smk_2, agent;
    sem_init(&table,0,1);
    pthread_create(&agent, 0, agent, 0);
    pthread_create(&smk_0, 0, smoker, 0);
    pthread_create(&smk_1, 0, smoker, 1);
    pthread_create(&smk_2, 0, smoker, 2);
    while(1);
}