系统与网络编程-(多线程)

系统与网络编程

小作业

  • 公交车停发车程序
#include <stdio.h>
#include <string.h>
#include <unistd.h>  //fork ()
#include <stdlib.h>
#include <sys/types.h> //kill()
#include <signal.h>  //signal()

pid_t pid = -1;

//司机:到站停车  --> SIGINT  ctrl+c
//      关门开车  --> SIGUSR1
void handleDriver(int sig)
{
    if (SIGINT == sig)
    {
        printf("到站了...\n");
        sleep(1);
        printf("司机开始停车...\n");
        sleep(1);
        int ret = 0;
        ret = kill(pid, SIGUSR2);  //发送信号给售票员让她开门
        if (-1 == ret)
        {
            perror("kill");
        }
    }
    else if (SIGUSR1 == sig)
    {
        printf("司机开始开车...\n");
        sleep(1);
        printf("车正在跑...\n");    
        sleep(1);
    }
}
//售票员:开门 -->SIGUSR2
void handleConductor(int sig)
{
    if (SIGUSR2 == sig)
    {
        printf("售票员开门...\n");
        sleep(1);
        printf("乘客上车...\n");
        sleep(1);
        printf("售票员关门...\n");
        sleep(1);
        kill(getppid(), SIGUSR1);  //售票员发送信号给司机开车
    }
}

int main(void)
{
    pid = fork();
    if (pid > 0)  //driver
    {
        signal(SIGINT, handleDriver);
        signal(SIGUSR1, handleDriver);
        printf("司机等待售票员做好开车准备...\n");
        while (1)
        {
            pause();
        }   
    }
    else if (0 == pid)  //conductor
    {
        signal(SIGINT, SIG_IGN);
        signal(
![Paste_Image.png](http://upload-images.jianshu.io/upload_images/3238825-425024fd6d3a07ff.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)SIGUSR2, handleConductor);
        sleep(1);
        //发送一个开车信号让其开车
        kill(getppid(), SIGUSR1);
        while (1)
        {
            pause();    
        }   
    }
    else if (-1 == pid)
    {
        perror("fork");
        return -1;
    }

    return 0;
}
Paste_Image.png

线程

  • 并发执行:看起来像同时运行,实际上在单核cpu里只有一个。将其排成进程列表,每个进程分配执行时间,执行完后挂起,下个进程开始进行。

  • 创建线程:

    • int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
      void (start_routine) (void *), void *arg);
    • 第一个参数:线程的标识,第二个参数:线程的属性,第三个参数:指定线程执行的代码,第四个参数:传给这个线程的实参。
    • 编译的时候要加上-pthread。
    #include <pthread.h>
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <unistd.h>
    void *thread_run(void *arg)
    {
        while(1)
        {
            printf("this is thread_run...\n");
            sleep(1);
        }
        return NULL;
    }
    int main()
    {
        pthread_t thread;//线程的标识
        int ret=0;
        ret=pthread_create(&thread,NULL,thread_run,NULL);
        if(ret!=0)
        {
            printf("errno:%d,error:%s\n",ret,strerror(ret));
            return -1;
        }
        while(1)
        {
            printf("this is main...\n");
            sleep(1);
        }
        return 0;
    }
    
    Paste_Image.png
  • 线程特点

    1. 一个进程创建后,创建的线程从属于该进程,不独立于进程,共享进程的所有资源
    2. 线程是最小的执行单元
    3. 若一个进程创建线程后,我们可以将该进程称之为主线程
    4. 一个进程可以创建多个线程,线程之间资源共享
    5. 若一个进程没有创建线程既可以把它看作是进程,也可以把它看做是线程
    • 使用return只能结束当前线程


      Paste_Image.png
    • exit(1)会将线程所属的进程挂掉,当然线程也会挂掉


      Paste_Image.png
  • 线程资源共享

    • 电脑会分配给每部分一段运行时间,当运行时间到了以后就会切换到下一个进程
    #include <pthread.h>
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <unistd.h>
    int g_data=0;
    void *thread_run(void *arg)
    {
        while(1)
        {
            g_data++;
            printf("this is thread_run...%d\n",g_data);
        //  sleep(1);
        }
        return NULL;
    }
    int main()
    {
        pthread_t thread;//线程的标识
        int ret=0;
        ret=pthread_create(&thread,NULL,thread_run,NULL);
        if(ret!=0)
        {
            printf("errno:%d,error:%s\n",ret,strerror(ret));
            return -1;
        }
        while(1)
        {
            g_data++;
            printf("this is main%d\n",g_data);
        //  sleep(1);
        }
        return 0;
    }
    
    Paste_Image.png
    • 解决方法:定义一个锁
    #include <pthread.h>
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <unistd.h>
    pthread_mutex_t mutex; //互斥量,锁
    int g_data=0;
    void *thread_run(void *arg)
    {
        while(1)
        {
            pthread_mutex_lock(&mutex);
            g_data++;
            printf("this is thread_run...%d\n",g_data);
            pthread_mutex_unlock(&mutex);
        //  sleep(1);
        }
        return NULL;
    }
    int main()
    {
        //初始化互斥量
        pthread_mutex_init(&mutex,NULL);//NULL:使用默认属性
        pthread_t thread;//线程的标识
        int ret=0;
        ret=pthread_create(&thread,NULL,thread_run,NULL);
        if(ret!=0)
        {
            printf("errno:%d,error:%s\n",ret,strerror(ret));
            return -1;
        }
        while(1)
        {
            g_data++;
            printf("this is main%d\n",g_data);
        //  sleep(1);
        }
        return 0;
    }
    
    Paste_Image.png
    • 实现文件读与打印的线程
    #include <stdio.h>
    #include <unistd.h>  //write()  read()
    #include <errno.h>   //errno
    #include <string.h>  //strerror()
    /*open()*/
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    
    #include <pthread.h> //pthread_create
    
    pthread_mutex_t mutex;
    
    #define NAME_LEN 32
    typedef struct Student
    {
        int iId;
        char caName[NAME_LEN];
        char cSex;
        float fScore;
    
    }Student;
    
    int myOpen(const char *pathname)
    {
        int fd  = -1;
        if (NULL != pathname)
        {
            fd = open(pathname, O_RDONLY | O_CREAT
                      , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
            if (-1 == fd)
            {
                printf("open error: %s\n", strerror(errno));
            }
        }
        return fd;
    }
    
    int g_iSign = 0;
    
    void *read_thread(void *arg)
    {
        int fd = -1;
        fd = myOpen("stu.info");
        if (-1 != fd)
        {
            int ret = -1;
            Student *pStu = (Student *)arg;
            while (1)
            {
                if (0 == g_iSign)
                {
                    pthread_mutex_lock(&mutex);
                    memset(pStu, '\0', sizeof(Student));
                    ret = read(fd, pStu, sizeof(Student));
                    if (0 == ret)
                    {
                        printf("reached the file end\n");
                        pthread_mutex_unlock(&mutex);
                        g_iSign = 1;
                        break;
                    }
                    else if (-1 == ret)
                    {
                        printf("read error:%s\n", strerror(errno));
                        pthread_mutex_unlock(&mutex);
                        g_iSign = 1;
                        break;
                    }
                    pthread_mutex_unlock(&mutex);
                    g_iSign = 1;
                }
            }
            close(fd);
        }   
    
        return NULL;
    }
    
    void *print_thread(void *arg)
    {
        Student *pStu = (Student *)arg;
        int i = 0;
        while (1)
        {
            if (1 == g_iSign)
            {
                pthread_mutex_lock(&mutex);
                if (0 == pStu->iId)
                {
                    pthread_mutex_unlock(&mutex);
                    break;
                }
            
                printf("id:%d, name:%s, sex:%c, score:%.1f\n"
                       , pStu->iId, pStu->caName
                       , pStu->cSex, pStu->fScore);
            
                pthread_mutex_unlock(&mutex);
                g_iSign = 0;
            }
        }
    
        return NULL;
    }
    
    int main(void)
    {
        pthread_mutex_init(&mutex, NULL);
    
        Student stu;
        pthread_t pthr_read;
        pthread_t pthr_show;
    
        pthread_create(&pthr_read, NULL, read_thread, &stu);
        pthread_create(&pthr_show, NULL, print_thread, &stu);
    
        pthread_join(pthr_read, NULL);
        pthread_join(pthr_show, NULL);
    
        return 0;
    }
    
  • 线程结束

    • 发送一个结束线程请求给指定的线,默认情况下线程是会同意该结束线程请求,还可以设置不同意
    • 在线程函数中调用pthread_setcancelstate来设置,不同意结束线程结束请求,阻塞线程结束请求,直到线程允许接收线程结束请求
    #include <pthread.h>
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <unistd.h>
    void *thread_run(void *arg)
    {
        //在线程函数中调用pthread_setcancelstate来设置
        //不同意结束线程结束请求,阻塞线程结束请求
        //直到线程允许接收线程结束请求
        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
        while(1)
        {
            printf("this is thread_run...\n");
            sleep(1);
        }
        return NULL;
    }
    int main()
    {
        pthread_t thread;//线程的标识
        int ret=0;
        ret=pthread_create(&thread,NULL,thread_run,NULL);
        if(ret!=0)
        {
            printf("errno:%d,error:%s\n",ret,strerror(ret));
            return -1;
        }
        sleep(3);
        //发送一个结束线程请求给指定的线程
        //默认情况下线程是会同意该结束线程请求
        //还可以设置不同意
        pthread_cancel(thread);//挂起线程
        while(1)
        {
            printf("this is main\n");
            sleep(1);
        }
        return 0;
    }
    
    Paste_Image.png

    Paste_Image.png
    • pthread_exit(NULL);
    #include <pthread.h>
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <unistd.h>
    void *thread_run(void *arg)
    {
        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
        while(1)
        {
            printf("this is thread_run...\n");
            sleep(1);
            break;
            pthread_exit(NULL);//结束所属线程
        }
        return NULL;
    }
    int main()
    {
        pthread_t thread;//线程的标识
        int ret=0;
        ret=pthread_create(&thread,NULL,thread_run,NULL);
        if(ret!=0)
        {
            printf("errno:%d,error:%s\n",ret,strerror(ret));
            return -1;
        }
        sleep(3);
        pthread_exit(NULL);//等待其他线程结束,此过程会阻塞,随后结束主函数。
        while(1)
        {
            printf("this is main\n");
            sleep(1);
        }
        return 0;
    }
    
    • pthread_join(thread,NULL);//若线程在运行,则阻塞等待,若不在运行,则立即返回
    #include <pthread.h>
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <unistd.h>
    void *thread_run(void *arg)
    {
        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
        while(1)
        {
            printf("this is thread_run...\n");
            sleep(1);
        }
        return NULL;
    }
    int main()
    {
        pthread_t thread;//线程的标识
        int ret=0;
        ret=pthread_create(&thread,NULL,thread_run,NULL);
        if(ret!=0)
        {
            printf("errno:%d,error:%s\n",ret,strerror(ret));
            return -1;
        }
        pthread_join(thread,NULL);
        while(1)
        {
            printf("this is main\n");
            sleep(1);
        }
        return 0;
    }
    
  • 信号量:

    • int sem_init(sem_t *sem, int pshared, unsigned int value);
    • 第一个是信号量,第二个是初始线程还是进程,第三个值表示满足不满足
    #include <stdio.h>
    #include <unistd.h>  //write()  read()
    #include <errno.h>   //errno
    #include <string.h>  //strerror()
    /*open()*/
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    
    #include <pthread.h> //pthread_create
    #include <semaphore.h>  
    
    pthread_mutex_t mutex;
    
    sem_t read_sem;  //整形 
    sem_t show_sem;
    
    #define NAME_LEN 32
    typedef struct Student
    {
        int iId;
        char caName[NAME_LEN];
        char cSex;
        float fScore;
    
    }Student;
    
    int myOpen(const char *pathname)
    {
        int fd  = -1;
        if (NULL != pathname)
        {
            fd = open(pathname, O_RDONLY | O_CREAT
                      , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
            if (-1 == fd)
            {
                printf("open error: %s\n", strerror(errno));
            }
        }
        return fd;
    }
    
    void *read_thread(void *arg)
    {
        int fd = -1;
        fd = myOpen("stu.info");
        if (-1 != fd)
        {
            int ret = -1;
            Student *pStu = (Student *)arg;
            while (1)
            {
                //如果read_sem大于0,接着往下执行,并且将该变量减一
                //如果read_sem等于0,则阻塞,直到该值大于0
                sem_wait(&read_sem);
                
                pthread_mutex_lock(&mutex);
                
                memset(pStu, '\0', sizeof(Student));
                ret = read(fd, pStu, sizeof(Student));
                if (0 == ret)
                {
                    printf("reached the file end\n");
                    pthread_mutex_unlock(&mutex);
                    sem_post(&show_sem);
                    break;
                }
                else if (-1 == ret)
                {
                    printf("read error:%s\n", strerror(errno));
                    pthread_mutex_unlock(&mutex);
                    sem_post(&show_sem);
                    break;
                }
                pthread_mutex_unlock(&mutex);
                //将信号量的值加一
                sem_post(&show_sem);
            }
        }
        close(fd);
    
        return NULL;
    }
    
    void *print_thread(void *arg)
    {
        Student *pStu = (Student *)arg;
        int i = 0;
        while (1)
        {
            {
                //如果show_sem大于0,接着往下执行,并且将该变量减一
                //如果show_sem等于0,则阻塞,直到该值大于0
                sem_wait(&show_sem);
                pthread_mutex_lock(&mutex);
                if (0 == pStu->iId)
                {
                    pthread_mutex_unlock(&mutex);
                    sem_post(&read_sem);
                    break;
                }
            
                printf("id:%d, name:%s, sex:%c, score:%.1f\n"
                       , pStu->iId, pStu->caName
                       , pStu->cSex, pStu->fScore);
            
                pthread_mutex_unlock(&mutex);
                //将信号量的值加一
                sem_post(&read_sem);
            }
        }
    
        return NULL;
    }
    
    int main(void)
    {
        pthread_mutex_init(&mutex, NULL);
    
        //初始化信号量
        sem_init(&read_sem, 0, 1);  //将read_sem值置为1
        sem_init(&show_sem, 0, 0);  //将show_sem值置为0
    
        Student stu;
        pthread_t pthr_read;
        pthread_t pthr_show;
    
        pthread_create(&pthr_read, NULL, read_thread, &stu);
        pthread_create(&pthr_show, NULL, print_thread, &stu);
    
        pthread_join(pthr_read, NULL);
        pthread_join(pthr_show, NULL);
    
        return 0;
    }
    

pthread_addNum

#include<pthread.h> //pthread_create()
#include<stdio.h>
#include<string.h>//strerror()
#include<errno.h> //errno
#include<stdlib.h>
int g_iData=0;
void *thread_run(void *arg)
{
    while(1)
    {
        ++g_iData;
        printf("thread :data=%d\n",g_iData);
    }
    return NULL;
}

int main()
{
    pthread_t thread;
    int ret=0;
    ret=pthread_create(&thread,NULL,thread_run,NULL);//现在线程的属性默认为NULL
    if(0!=ret)
    {
        printf("errno:%d,error:%s\n",ret,strerror(ret));
        return -1;
    }
    while(1)
    {
        ++g_iData;
        printf("main :data=%d\n",g_iData);
    }
    return 0;

}


  • g_iData=0;A线程++g_iData,如果线程A时间足够的话,则g_iData=1;B线程再执行,则变为2;
  • 若A时间片不够,虽然++了但++后的值还没有返回到g_iData里,所以B线程++后的值仍然为1
  • 如下,会出现中断的情况


    Paste_Image.png
  • 解决以上情况,则定义一个原子锁
#include<pthread.h> //pthread_create()
#include<stdio.h>
#include<string.h>//strerror()
#include<errno.h> //errno
#include<stdlib.h>
pthread_mutex_t mutex; //互斥量或者称为锁
int g_iData=0;
void *thread_run(void *arg)
{
    while(1)
    {
        //使用pthread_mutex_lock和pthread_mutex_unlock
        //使它们之间的语句合成原子操作
        pthread_mutex_lock(&mutex);
        ++g_iData;
        printf("thread :data=%d\n",g_iData);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main()
{
    
    //初始化互斥量,NULL表示使用默认属性初始化该互斥量
    pthread_mutex_init(&mutex,NULL);//使用他的默认属性进行初始化
    pthread_t thread;
    int ret=0;
    ret=pthread_create(&thread,NULL,thread_run,NULL);//现在线程的属性默认为NULL
    if(0!=ret)
    {
        printf("errno:%d,error:%s\n",ret,strerror(ret));
        return -1;
    }
    while(1)
    {
        pthread_mutex_lock(&mutex);
        ++g_iData;
        printf("main :data=%d\n",g_iData);
        pthread_mutex_unlock(&mutex);
    }
    return 0;

}

  • 这样就不会出现中断的情况

一个线程从文件读取数据,另一个线程打印出来

  • 先通过以前的代码,在文件里写入几个同学的信息

#include <stdio.h>
#include <unistd.h>  //write()  read()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <pthread.h> //pthread_create

pthread_mutex_t mutex;

#define NAME_LEN 32
typedef struct Student
{
    int iId;
    char caName[NAME_LEN];
    char cSex;
    float fScore;

}Student;

int myOpen(const char *pathname)
{
    int fd  = -1;
    if (NULL != pathname)
    {
        fd = open(pathname, O_RDONLY | O_CREAT
                  , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        if (-1 == fd)
        {
            printf("open error: %s\n", strerror(errno));
        }
    }
    return fd;
}

int g_iSign = 0;

void *read_thread(void *arg)
{
    int fd = -1;
    fd = myOpen("stu.info");
    if (-1 != fd)
    {
        int ret = -1;
        Student *pStu = (Student *)arg;
        while (1)
        {
            if (0 == g_iSign)
            {
                pthread_mutex_lock(&mutex);
                memset(pStu, '\0', sizeof(Student));
                ret = read(fd, pStu, sizeof(Student));
                if (0 == ret)
                {
                    printf("reached the file end\n");
                    pthread_mutex_unlock(&mutex);
                    g_iSign = 1;
                    break;
                }
                else if (-1 == ret)
                {
                    printf("read error:%s\n", strerror(errno));
                    pthread_mutex_unlock(&mutex);
                    g_iSign = 1;
                    break;
                }
                pthread_mutex_unlock(&mutex);
                g_iSign = 1;
            }
        }
        close(fd);
    }   

    return NULL;
}

void *print_thread(void *arg)
{
    Student *pStu = (Student *)arg;
    int i = 0;
    while (1)
    {
        if (1 == g_iSign)
        {
            pthread_mutex_lock(&mutex);
            if (0 == pStu->iId)
            {
                pthread_mutex_unlock(&mutex);
                break;
            }
        
            printf("id:%d, name:%s, sex:%c, score:%.1f\n"
                   , pStu->iId, pStu->caName
                   , pStu->cSex, pStu->fScore);
        
            pthread_mutex_unlock(&mutex);
            g_iSign = 0;
        }
    }

    return NULL;
}

int main(void)
{
    pthread_mutex_init(&mutex, NULL);

    Student stu;
    pthread_t pthr_read;
    pthread_t pthr_show;

    pthread_create(&pthr_read, NULL, read_thread, &stu);
    pthread_create(&pthr_show, NULL, print_thread, &stu);

    pthread_join(pthr_read, NULL);
    pthread_join(pthr_show, NULL);

    return 0;
}

Paste_Image.png

信号量(sem_wait)

//int sem_init();//pshared

#include <stdio.h>
#include <unistd.h>  //write()  read()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <pthread.h> //pthread_create
#include <semaphore.h>
pthread_mutex_t mutex;
sem_t read_sem;//读的信号量
sem_t print_sem;//显示的信号量
#define NAME_LEN 32
typedef struct Student
{
    int iId;
    char caName[NAME_LEN];
    char cSex;
    float fScore;

}Student;

int myOpen(const char *pathname)
{
    int fd  = -1;
    if (NULL != pathname)
    {
        fd = open(pathname, O_RDONLY | O_CREAT
                  , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        if (-1 == fd)
        {
            printf("open error: %s\n", strerror(errno));
        }
    }
    return fd;
}


void *read_thread(void *arg)
{
    int fd = -1;
    fd = myOpen("stu.info");
    if (-1 != fd)
    {
        int ret = -1;
        Student *pStu = (Student *)arg;
        while (1)
        {
            //如果read_sem大于0,接着往下执行,并且将该变量减1,如果等于0,则阻塞,直到该值大于0
            sem_wait(&read_sem);//此时read_sem=1
            pthread_mutex_lock(&mutex);
            memset(pStu, '\0', sizeof(Student));
            ret = read(fd, pStu, sizeof(Student));
            if (0 == ret)
            {
                printf("reached the file end\n");
                pthread_mutex_unlock(&mutex);
                sem_post(&print_sem);//出错了,发送这个信号
                break;
            }
            else if (-1 == ret)
            {
                printf("read error:%s\n", strerror(errno));
                pthread_mutex_unlock(&mutex);
                sem_post(&print_sem);//出错了,发送这个信号
                break;
            }
            pthread_mutex_unlock(&mutex);
            sem_post(&print_sem);//出错了,发送这个信号
        }
        close(fd);
    }   

    return NULL;
}

void *print_thread(void *arg)
{
    Student *pStu = (Student *)arg;
    int i = 0;
    while (1)
    {
        //如果print_sem大于0,接着往下执行,并且将该变量减1,如果等于0,则阻塞,直到该值大于0
        sem_wait(&print_sem);
        pthread_mutex_lock(&mutex);
        if (0 == pStu->iId)
        {
            pthread_mutex_unlock(&mutex);
            sem_post(&read_sem);
            break;
        }
        
        printf("id:%d, name:%s, sex:%c, score:%.1f\n"
                   , pStu->iId, pStu->caName
                   , pStu->cSex, pStu->fScore);
        
        pthread_mutex_unlock(&mutex);
        //将信号量的值加1
        sem_post(&read_sem);

    }

    return NULL;
}

int main(void)
{
    pthread_mutex_init(&mutex, NULL);
    
    sem_init(&read_sem,0,1);//对信号量的初始化,必须先读才能再显示,将read_sem的值置为1
    sem_init(&print_sem,0,0);//将print_sem的值置为0

    Student stu;
    pthread_t pthr_read;
    pthread_t pthr_show;

    pthread_create(&pthr_read, NULL, read_thread, &stu);
    pthread_create(&pthr_show, NULL, print_thread, &stu);

    pthread_join(pthr_read, NULL);
    pthread_join(pthr_show, NULL);

    return 0;
}


Paste_Image.png

用代码模仿5个哲学家进餐问题

  1. 创建5根筷子(5个信号量创建一组信号量)
  2. 创建5科学家
  3. 获得筷子
  4. 放下筷子
  5. 继续思考
int semop(int semid, struct sembuf *sops, unsigned nsops);

参数

  1. semid:信号集的识别码,可通过semget获取。
  2. sops:指向存储信号操作结构的数组指针,信号操作结构的原型如下
struct sembuf
{
        unsigned short sem_num; /* semaphore number */
        short sem_op; /* semaphore operation */
        short sem_flg; /* operation flags */
};

  • 这三个字段的意义分别为:
  1. sem_num:操作信号在信号集中的编号,第一个信号的编号是0。
  1. sem_op:
  • 1, 如果其值为正数,该值会加到现有的信号内含值中。
    通常用于释放所控资源的使用权;
  • 2, 如果sem_op的值为负数,而其绝对值又大于信号的现值,
    操作将会阻塞,直到信号值大于或等于sem_op的绝对值。
    通常用于获取资源的使用权;
  • 3, 如果sem_op的值为0,如果没有设置IPC_NOWAIT,
    则调用该操作的进程或者线程将暂时睡眠,直到信号量的值为0; 否则,进程或者线程不会睡眠,函数返回错误EAGAIN。
  1. sem_flg:信号操作标志,可能的选择有两种
  • 1, IPC_NOWAIT //对信号的操作不能满足时,semop()不会阻塞,
    并立即返回,同时设定错误信息。
  • 2, SEM_UNDO //程序结束时(不论正常或不正常),
    保证信号值会被重设为semop()调用前的值。
    这样做的目的在于避免程序在异常情况下结束时
    未将锁定的资源解锁,造成该资源永远锁定。
  1. nsops:信号操作结构的数量,恒大于或等于1。
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <string.h>//perror()
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#include <unistd.h>
#include <stdio.h>
union semun
{
    int val;
    struct semid_ds *buf;
    unsigned short *array;
    struct seminfo *__buf;
};

void getChopsticks(int iNum,int *semfd)
{
    int iLeft=iNum;
    int iRight=(iNum+1)%5;
    struct sembuf semope[2]={{iLeft,-1,0},
                             {iRight,-1,0}};
    semop(*semfd,semope,2);//拿筷子,获得左右两边的筷子

}
void putChopsticks(int iNum,int *semfd)
{
    
    int iLeft=iNum;
    int iRight=(iNum+1)%5;
    struct sembuf semope[2]={{iLeft,1,0},
                             {iRight,1,0}};
    semop(*semfd,semope,2);//拿筷子,获得左右两边的筷子
}
void thinkAndEat(int iNum,int *semfd)
{
    while(1)
    {
        printf("%d say:I am thinking...\n",iNum);
        /*拿筷子吃饭*/
        getChopsticks(iNum,semfd);
        sleep(1);
        printf("%d say:I am eatting...\n",iNum);
        /*放下筷子*/
        putChopsticks(iNum,semfd);
        printf("%d say:I am puting chopsticks...\n",iNum);
        sleep(1);
    }
}
int main(void)
{
    int semfd=-1;
    //获得信号量集的标识,若信号量集不存在则创建
    semfd=semget(0x1024,5,IPC_CREAT | 0777);//5,代表5个信号量
    if(-1==semfd)
    {   
        perror("semget");
        return -1;
    }
    //对信号集中的信号量进行赋值
    union semun sem;
    sem.val=1;
    int i=0;
    for(;i<5;i++)
    {
        if(-1==semctl(semfd,i,SETVAL,sem))
        {
            perror("semctl");
            return -1;
        }
    }
    //创建5个哲学家进程
    int iNum=0;//用来保存表示第几个科学家
    pid_t pid=-1;
    for(i=0;i<4;i++)
    {
        pid=fork();
        if(pid>0)//parent
        {   
            iNum=4;
        }
        else if(pid==0)//child
        {   
            iNum=i;
            break;//
        }
        else if(pid==-1)//error
        {
            return -1;
        }
    }
    thinkAndEat(iNum,&semfd);
    return 0;
}


Paste_Image.png
  • 生产者消费者问题

Paste_Image.png

link

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 206,214评论 6 481
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 88,307评论 2 382
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 152,543评论 0 341
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 55,221评论 1 279
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 64,224评论 5 371
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 49,007评论 1 284
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 38,313评论 3 399
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 36,956评论 0 259
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 43,441评论 1 300
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,925评论 2 323
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,018评论 1 333
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 33,685评论 4 322
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 39,234评论 3 307
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,240评论 0 19
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,464评论 1 261
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 45,467评论 2 352
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 42,762评论 2 345

推荐阅读更多精彩内容