OS实验：进程管理与死锁

最新推荐文章于 2022-05-19 10:00:45 发布
最新推荐文章于 2022-05-19 10:00:45 发布
阅读量751 收藏 13
点赞数 3
分类专栏： OS 实验 文章标签： linux 操作系统 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwwzq_/article/details/116029735
版权

进程管理与死锁

一. 实验目的

  1. 理解进程/线程的概念和应用编程过程
  2. 理解进程/线程的同步机制和应用编程

二. 实验内容

  1. 在Linux下创建一队父子进程
  2. 在Linux下创建两个线程A和B，循环输出数据或字符串
  3. 在Linux下创建父子进程，实验wait同步函数，理解父子进程同步
  4. 在Linux下利用线程实现“生产者-消费者”同步控制
  5. 在Linux 下模拟哲学家 就餐，提供死锁和非死锁解法

三. 实验过程

3.1 在Linux 下创建一对父子进程

  • 分别输出各自的进程号，父进程号和特别的提示字符串信息
  • 让父进程提前结束或后结束，观察子进程的父进程ID
  • 使用PS命令查看进程列表信息，核对进程号，父进程号

要创建子进程，需要用到 fork() 函数，该函数的函数原型声明在 unistd.h 中

    pid_t fork(void);

返回值:
如果成功，父进程中，将返回子进程的pid（pid>0)；子进程中，将返回0 (pid =0）。
如果失败，父进程中，会返回-1，而子进程不会被创建。并且设置errno的值来指出这个错误。

由 fork 创建的新进程被称为子进程。该函数被调用一次，但返回两次。两次返回的区别是子进程的返回值是0，而父进程的返回值则是新进程（子进程）的进程 id。子进程可以调用getpid()来获取自己的pid；也可以调用getppid()来获取父进程的id。
fork之后，操作系统会复制一个与父进程完全相同的子进程，虽说是父子关系，但是在操作系统看来，他们更像兄弟关系，这2个进程共享代码空间，但是数据空间是互相独立的，子进程数据空间中的内容是父进程的完整拷贝，指令指针也完全相同，子进程拥有父进程当前运行到的位置

创建一个c文件 使用命令vim fork.c，输入以下代码

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>

void main()
{

    pid_t pid;

    fprintf(stdout, "I am the first process, my pid is %d, my parent pid is %d\n", getpid(), getppid());

    pid = fork();
    if (0 == pid)
        fprintf(stdout, "I am the child procress, my pid value is %d, but my real pid is %d, my parent pid is %d\n", pid, getpid(), getppid());
    else
        fprintf(stdout, "I am the parent process, my child pid is %d, my pid is %d, my parent pid is %d\n", pid, getpid(), getppid());
		// 让该线程睡眠一会，从而使用ps 命令查看线程时，该线程没有结束
		// 睡眠50s
        sleep(50);
}

编译gcc -o fork.out fork.c
输出结果
在这里插入图片描述
我们运行的 ./fork.out 本身也是一个进程，它的pid是5833，ppid是2765（它的parent是bash）
使用fork()函数后创建的子进程的pid是5834，ppid是5833
使用命令ps -ef
在这里插入图片描述
第二列是pid，第三列是ppid（父进程的pid）。可以发现进程号和父进程号是符合的。
为了观察 让父进程提前结束或后结束，观察子进程的父进程ID

让父进程提前结束

修改 fork.c文件（也可以再创建一个）

 #include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
 
int main(int argc, char *argv[]) {
    printf("start program %s, pid: %d, ppid: %d \n", argv[0], getpid(), getppid());
    pid_t pid = fork();
    if (-1 == pid) {
        printf("fork process failed. errno: %u, error: %s\n", errno, strerror(errno));
        exit(-1);
    }   
    if (pid > 0) { // parent 
        printf("parent process\n");
        sleep(1);
/** 标记一、wait 等待子进程结束*/
//      int status;
//      wait(&status);
    } else { // child 
        printf("child process, pid: %d, ppid: %d\n", getpid(), getppid());
        for (int i = 0; i < 5; i++) {
            printf("child sleep %ds\n", i); 
            sleep(1);
        }   
        printf("##child process, pid: %d, ppid: %d\n", getpid(), getppid());
    }   
    return 0;
}

再次编译 gcc -o fork.out fork.c
运行./fork.out
输出结果
在这里插入图片描述
发现父线程先关闭后，子线程的ppid由6040 变为了 1892
在这里插入图片描述
1892对应命令 /lib/systemd/systemd/ --user 代表systemd进程，这里有人可能会疑惑为什么不是init进程（ppid不是1）。
其实systemd 是 init 的现代替代品。绝大多数linux发行版（ubuntu, fedora, centos, arch 等等）已经用systemd替换了传统的init。systemd 担任的角色非常多，其中之一负责管理用户会话，也就是作为用户图形界面的父进程进行管理。systemd --user 会调用 prctl，接替全局的init进程的职责，处理所有孤儿进程。
如果在tty界面下实验，可以按ctrl + alt + F3打开tty界面，再次运行该程序，发现父进程先结束后，子进程的ppid变为了符合预期的1.也就是被init进程接管了。 之后可以使用ctrl + alt +F2返回图形界面。
在这里插入图片描述

让父进程后结束

把“标志一”的wait代码删除注释，使用以下代码

     /** 标记一、wait 等待子进程结束 */
    int status;
    wait(&status);

同样步骤编译运行后结果显示为
在这里插入图片描述
wait函数的作用是等待子进程结束，并获取子进程结束的状态，所以父进程wait等待子进程结束后才继续运行退出，故子进程的ppid一直是原来fork它的父进程的pid，一直是6232.

3.2 在Linux下创建两个线程A和B，循环输出数据或字符串

  • 使用pthread线程库
  • 线程A递增输出1-1000； 线程B递减输出1000-1。为避免输出太快，每隔0.2s（可自行调节）输出一个数。
  • 输出数据时，同时输出A或B以标识是哪个线程输出的，并注意格式化输出信息。

线程相关函数 pthread_xxx 都在头文件 pthread.h里。

函数 pthread_create()：用于创建线程

      int pthread_create(pthread_t *restrict thread,
                          const pthread_attr_t *restrict attr,
                          void *(*start_routine)(void *),
                          void *restrict arg);
  • thread： 返回的线程句柄
  • attr ： 指定线程属性
  • start_routine ： 线程函数入口地址
  • arg ： 线程函数参数

函数 pthread_join： 用于等待目标线程终止

      int pthread_join(pthread_t thread, void **retval);
  • thread ：目标线程
  • retval ：NULL即可

创建一个c文件（如trial2.c），并输入以下代码

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <time.h>
#include <errno.h>   

// sleep xx毫秒
int msleep(long msec)
{
    struct timespec ts;
    int res;

    if (msec < 0)
    {
        errno = EINVAL;
        return -1;
    }

    ts.tv_sec = msec / 1000;
    ts.tv_nsec = (msec % 1000) * 1000000;

    do {
        res = nanosleep(&ts, &ts);
    } while (res && errno == EINTR);

    return res;
}
//打印 1~1000
void * print1()
{
    int  i = 0;
    while (i <= 1000)
    {
        printf("A:%d\n", i);
        i++;
        // 间隔0.2秒
        msleep(200);
    }
}

//打印1000~1
void * print2()
{
    int i = 1000;
    while (i > 0)
    {
        printf("B:%d\n", i);
        i--;
        // 间隔0.2秒
        msleep(200);
    }
}

int main()
{
    pthread_t thread1;
    pthread_t thread2;
    int hThread1 = pthread_create(&thread1, NULL, print1, NULL);
    int hThread2 = pthread_create(&thread2, NULL, print2, NULL);
    if (hThread1 != 0)
    {
        printf("hThread1 err");
    }
    else if (hThread2 != 0)
    {
        printf("hThread2 err!");
    }

    pthread_join(thread1, NULL); // 
    pthread_join(thread2, NULL); // 
    return 0;
}

msleep() 函数参考Is there an alternative sleep function in C to milliseconds?
输入指令gcc -o trial2.out trial2.c -pthread进行编译，再输入./trial2.out运行
在这里插入图片描述

其中注意是 -pthread 而不是 -plthread，解释可见Undefined reference to pthread_create in Linux和Compiling Threaded Programs
可参考以下表格
在这里插入图片描述

3.3 在Linux下创建父子进程，实验wait同步函数，理解父子进程同步

  • 子进程休眠5秒，父进程不休眠。子进程用exit返回参数
  • 父进程调用wait等待子进程先结束，并分析子进程返回参数
  • 父进程输出子进程的返回信息

wait函数 ：用于等待一个子进程停止或终止（随机的一个子进程）

    #include <sys/wait.h>

    pid_t wait(int *stat_loc);
  • stat_loc: 存储子进程结束时的返回值

创建新文件（如trial3.c)，并且输入以下代码

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
 
int main(int argc, char *argv[]) {
    printf("start program %s, pid: %d, ppid: %d \n", argv[0], getpid(), getppid());
    pid_t pid = fork();
    if (-1 == pid) {
        printf("fork process failed. errno: %u, error: %s\n", errno, strerror(errno));
        exit(-1);
    }  
    if (pid > 0) { // parent 
        int status;
 		wait(&status);
 		printf("child process return %d\n",status);
    } else { // child 
    	// 子进程休眠5s
        sleep(5);
        // 子进程返回 0
        exit(0);
    }   
    return 0;
}

使用命令gcc -o trial3.out trial3.c -pthread编译，再使用命令./trial3.out运行
显示以下结果，可以发现父进程输出了子进程的返回信息 0
在这里插入图片描述

3.4 在Linux下利用线程实现“生产者-消费者”同步控制

  • 使用数组（10个元素） 代替缓冲区。2个输入线程产生产品（随机数）存到数组中；3个输出线程从数组中取数输出
  • Linux使用 互斥锁对象 和 轻量级信号对象 ，主要函数 ：sem_wait() ,sem_post() ,pthread_mutex_lock() ,pthread_mutex_unlock()
  • 生产者1的数据： 1000-1999（每个数据随机间隔100ms-1s），生产者2的数据： 2000-2999（每个数据随机间隔100ms-1s）
  • 消费者每休眠100ms-1s的随机时间消费一个数据
  • 屏幕打印（或日志文件记录）每个数据的生产和消费记录

3.4.1 使用信号量

信号量相关函数 在头文件 semaphore.h中

sem_init()：动态初始化一个信号量

       #include <semaphore.h>
       int sem_init(sem_t *sem, int pshared, unsigned int value);
  • sem :想要初始化的信号量
  • pshared ：表明信号量是进程间共享，还是一个进程内的线程共享。若为0，则，一个进程内的线程共享，否则进程间共享。
  • value: 信号量初始值

sem_wait : 即P操作

int sem_wait(sem_t *sem);
  • sem : 指定操作的信号量

sem_post :即V操作

int sem_post(sem_t *sem);
  • sem : 指定操作的信号量

sem_destory ：销毁指定信号量

 int sem_destroy(sem_t *sem);
  • sem : 指定操作的信号量

创建文件（如trial4.c），输入以下代码

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<semaphore.h>
#include<pthread.h>
#include<time.h>
#include <errno.h>    

#define BUFFER_SIZE               10          // size of buffer

 

// p_sem : produce semaphore 
// indicate that the number of producer threads that can run at the same time
// == unfilled buffer space

// c_sem : consume semaphore
// indicare that the number of consumer threads that can run at the same time
// == filled buffer space
sem_t p_sem, c_sem;

// s is used to achieve mutex
sem_t s;
// declare buffer
int buffer[BUFFER_SIZE];

// 
int in =0,out = 0;

 
int msleep(long msec);
void delay();
void * producer1(void *arg);
void * producer2(void *arg);  
void * consumer(void *arg);

int main()
{
    // init semaphore p_sem and c_sem
    sem_init(&p_sem,0,BUFFER_SIZE);
  
    sem_init(&c_sem,0,0);
    
    // init semaphore s
    sem_init(&s,0,1);
    

    srand((unsigned)time(NULL));
    
    pthread_t pro1,pro2;
    pthread_t con1,con2,con3;
    
     
     
    pthread_create(&pro1,NULL,producer1,NULL);
    pthread_create(&pro2,NULL,producer2,NULL);
    
    pthread_create(&con1,NULL,consumer,NULL);
    pthread_create(&con2,NULL,consumer,NULL);
    pthread_create(&con3,NULL,consumer,NULL);
    
    
    pthread_join(pro1,NULL);
    pthread_join(pro2,NULL);
    pthread_join(con1,NULL);
    pthread_join(con2,NULL);
    pthread_join(con3,NULL);
    
    sem_destroy(&p_sem);
    sem_destroy(&c_sem);
    sem_destroy(&s);
    
    return 0;
}


// produce(consume) delay
void delay()                                       
{
    long interval = rand()%901+100;
    msleep(interval);
}
 
void * producer1(void *arg)          //生产者线程
{
    //printf("producer1");
    int data;
    while(1)
    {
       // printf("producer1xxx");

        
        // produce date
        // produce1(); 
        data = rand()%1000 + 1000;
        printf("produce data %d\n",data);
        
        sem_wait(&p_sem);//生产信号量减一
        sem_wait(&s);
        // put the data(v) item into the buffer
        buffer[in] = data;
        in = (in + 1) % BUFFER_SIZE ;
        sem_post(&s);
        
        // consume semaphore plus one
        sem_post(&c_sem);
        
        delay();
    }
}

void * producer2(void *arg)          //生产者线程
{
    //printf("producer2\n");
    int data;
    while(1)
    {
        //printf("producer2xxx\n");
      
        
        // produce data
        // produce2(); 
        data = rand()%1000 + 2000;
        printf("produce data %d\n",data);
        
        
        sem_wait(&p_sem);//生产信号量减一
        sem_wait(&s);
        // put the data(v) item into the buffer
        buffer[in] = data;
        in = (in + 1) % BUFFER_SIZE ;
        sem_post(&s);
        
        // consume semaphore plus one
        sem_post(&c_sem);
        
        delay();
    }
}
 
void * consumer(void *arg)               //消费者线程
{
    //printf("consumer");
    int data;
    while(1)
    {
        sem_wait(&c_sem); //消费者信号量减一  
  
        sem_wait(&s);  
        data= buffer[out];
        out = (out +1) % BUFFER_SIZE;
        sem_post(&s);
  
        sem_post(&p_sem);//生产者信号量加一 
        
        //consum();
         printf("consume data %d\n",data);
         
         delay();
    }
}
 


// sleep thread 'msec' millisecond
int msleep(long msec)
{
    struct timespec ts;
    int res;
    
    if (msec < 0)
    {
        // EINVAL : Invalid argument
        errno = EINVAL;
        return -1;
    }

    ts.tv_sec = msec / 1000;
    ts.tv_nsec = (msec % 1000) * 1000000;

    do {
        res = nanosleep(&ts, &ts);
    } while (res && errno == EINTR);
    // EINTR: Interrupted function call
    // when Interruption of system calls and library functions 

    return res;
}

使用命令gcc -o trial4.out trial4.c -pthread编译，再使用命令./trial4.out运行
在这里插入图片描述

3.4.2 使用条件变量+互斥锁

函数pthread_cond_init() : 初始化一个条件变量

     int pthread_cond_init(pthread_cond_t *restrict cond,
           const pthread_condattr_t *restrict attr);
           
	pthread_cond_t cond = PTHREAD_COND_INITIALIZER; // 静态初始化
  • cond：想要初始化的条件变量的地址
  • attr ：指明条件变量的属性。若为NULL，则使用默认属性。

函数pthread_cond_destroy() :销毁一个条件变量

int pthread_cond_destroy(pthread_cond_t *cond);
  • cond: 想要销毁的条件变量的地址

函数pthread_cond_signal: 唤醒一个阻塞在条件变量的线程

int pthread_cond_signal(pthread_cond_t *cond);
  • cond: 指定条件变量的地址

函数pthread_cond_wait:阻塞调用该函数的线程，并释放指定互斥锁

      int pthread_cond_wait(pthread_cond_t *restrict cond,
           pthread_mutex_t *restrict mutex);
  • cond : 指定条件变量的地址
  • mutex ： 指定的互斥锁

函数pthread_mutex_init:初始化一个互斥锁

       int pthread_mutex_init(pthread_mutex_t *restrict mutex,
           const pthread_mutexattr_t *restrict attr);
       pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 静态初始化，默认属性
  • mutex：想要初始化的互斥锁的地址
  • attr ：指明互斥锁的属性。若为NULL，则使用默认属性。

函数pthread_mutex_destroy:销毁一个互斥锁

 	int pthread_mutex_destroy(pthread_mutex_t *mutex);
  • mutex: 指定互斥锁的地址

函数pthread_mutex_lock:获取锁
函数pthread_mutex_unlock:释放锁

       int pthread_mutex_lock(pthread_mutex_t *mutex);
       int pthread_mutex_unlock(pthread_mutex_t *mutex);
  • mutex : 指定互斥锁的地址
    代码如下
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<semaphore.h>
#include<pthread.h>
#include<time.h>
#include <errno.h>    

#define BUFFER_SIZE               10          // size of buffer
#define PRODUCER_NUM    2

// declare buffer
int buffer[BUFFER_SIZE];

// 
int in =0,out = 0;

pthread_mutex_t lock;
pthread_cond_t consume_cond,produce_cond;

int msleep(long msec);
void delay();
void * producer(void *arg);  
void * consumer(void *arg);

int main()
{
    pthread_mutex_init(&lock, 0);
    pthread_cond_init(&consume_cond,0);
    pthread_cond_init(&produce_cond,0);
    srand((unsigned)time(NULL));
    
    pthread_t pro1,pro2;
    pthread_t con1,con2,con3;

    int producer_args[PRODUCER_NUM] = {1000,2000};
    
     
     
    pthread_create(&pro1,NULL,producer,producer_args);
    pthread_create(&pro2,NULL,producer,(producer_args+1));
    
    pthread_create(&con1,NULL,consumer,NULL);
    pthread_create(&con2,NULL,consumer,NULL);
    pthread_create(&con3,NULL,consumer,NULL);
    
    
    pthread_join(pro1,NULL);
    pthread_join(pro2,NULL);
    pthread_join(con1,NULL);
    pthread_join(con2,NULL);
    pthread_join(con3,NULL);
    

    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&consume_cond);
    pthread_cond_destroy(&produce_cond);

    
    return 0;
}


// produce(consume) delay
void delay()                                       
{
    long interval = rand()%901+100;
    msleep(interval);
}
 
void * producer(void *arg)          //生产者线程
{
    int range = *(int *) arg;
    //printf("producer1");
    int data;
    while(1)
    {
        // produce date
        // produce1(); 
        data = rand()%1000 + range;
        printf("produce data %d\n",data);
        
        pthread_mutex_lock(&lock);
        while((in+1)%BUFFER_SIZE == out)
            {
                pthread_cond_wait(&produce_cond, &lock);
            }
        // put the data(v) item into the buffer
        buffer[in] = data;
        in = (in + 1) % BUFFER_SIZE ;
        pthread_cond_signal(&consume_cond);
        pthread_mutex_unlock(&lock);
    
        
        delay();
    }
}

 
void * consumer(void *arg)               //消费者线程
{
    //printf("consumer");
    int data;
    while(1)
    {
        // sem_wait(&c_sem); //消费者信号量减一  
  
        // sem_wait(&s);  
        // data= buffer[out];
        // out = (out +1) % BUFFER_SIZE;
        // sem_post(&s);
  
        // sem_post(&p_sem);//生产者信号量加一 

        pthread_mutex_lock(&lock);
        while(in == out)
        {
            pthread_cond_wait(&consume_cond,&lock);
        }
        data= buffer[out];
        out = (out +1) % BUFFER_SIZE;

        pthread_cond_signal(&produce_cond);
        pthread_mutex_unlock(&lock);
        
        //consum();
         printf("consume data %d\n",data);
         
         delay();
    }
    return NULL;
}
 


// sleep thread 'msec' millisecond
int msleep(long msec)
{
    struct timespec ts;
    int res;
    
    if (msec < 0)
    {
        // EINVAL : Invalid argument
        errno = EINVAL;
        return -1;
    }

    ts.tv_sec = msec / 1000;
    ts.tv_nsec = (msec % 1000) * 1000000;

    do {
        res = nanosleep(&ts, &ts);
    } while (res && errno == EINTR);
    // EINTR: Interrupted function call
    // when Interruption of system calls and library functions 

    return res;
}

3.5 在Linux下利用信号机制实现进程通信

  • 父进程创建子进程，并让子进程进入死循环
  • 子进程每隔2秒输出“I am Child Process，alive!\n"
  • 父进程询问用户”To terminate Child Process.Yes or No?"
  • 若用户回答Y，向子进程发送 用户信号 ，让子进程结束
  • 函数：kill(),signal(),利用用户信号，编写信号处理函数

关于信号机制，可参考signale(2) 、signale(7)和Linux 信号（signal）
现在简单说一下信号机制的基本使用

3.5.1 信号注册

signal() 函数

#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);

signum是信号的编号，handler是一个函数指针，就是该线程收到该信号时回调的函数。

3.5.2 信号发送

kill（）函数

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);

pid 是信号的接受者的pid，sig是发送的信号的类型。

3.5.3 信号类型

在这里插入图片描述

需要注意的是 SIGKILL 和 SIGSTOP无法被捕捉和忽略。

3.5.4 代码实现

代码如下

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <signal.h>

void handler(int signum)
{
    if(signum == SIGINT)
    {
        printf("Bye,World!\n");
        exit(0);
    }
    else 
    {
        printf("error signal\n");
    }
}
 
int main(int argc, char *argv[]) {
    printf("start program %s, pid: %d, ppid: %d \n", argv[0], getpid(), getppid());
    pid_t pid = fork();
    if (-1 == pid) {
        printf("fork process failed. errno: %u, error: %s\n", errno, strerror(errno));
        exit(-1);
    }   
    if (pid == 0) { // child 
        signal(SIGINT,handler);
        while(1)
        {
            printf("I am Child Process, alive!\n");
            sleep(2);
        }

    } else { // parent 
        char c;
        while(1)
        {
            printf("To terminate Child Process.Yes(Y) or No(N)?\n");
            scanf("\n%c",&c);
            if(c == 'N')
            {
                sleep(2);
            }
            else if (c == 'Y'){
                kill(pid,SIGINT);
                break;
            }
            else {
                printf("wrong inout ,please input Y or N\n");
            }
        }

    }   
    return 0;
}

3.6 在Linux 下模拟哲学家 就餐，提供死锁和非死锁解法

信号量实现的死锁解法

// use semaphore 
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<semaphore.h>
#include<pthread.h>
#include<time.h>
#include <errno.h>    

sem_t chopstick[5] ;
// sem_t room ;

int msleep(long msec);
void think(int );
void eat(int );
void * philosppher(void *);

// 哲学家逆时针坐着

int main () 
{   

    srand((unsigned)time(NULL)); 

    //sem_init(&room,0,4);

    for(int i = 0;i < 5;i++)
    {
        sem_init(chopstick + i,0,1);
    }

    pthread_t phi_thread[5] ;
    int thread_args[5] = {0,1,2,3,4};

    for (int i = 0; i < 5; i++)
    {
        pthread_create(phi_thread+i,NULL,philosppher,thread_args+i);
    }

    for(int i = 0; i < 5; i++)
    {
        pthread_join(phi_thread[i],NULL);
    }


    // sem_destroy(&room);

    for(int i = 0;i < 5;i++)
    {
        sem_destroy(chopstick+i);
    }

    return 0;
}

void * philosppher (void * arg)
{
    int i = *(int *)arg;
    while(1)
    {
        think(i);

        // sem_wait(&room); // 一次只允许四位哲学家进入餐厅
        sem_wait(chopstick + i); // 取左手边的筷子
        sem_wait(chopstick + ((i+1)%5)); // 取右手边的筷子
        eat(i);
        sem_post(chopstick + ((i+1)%5)); // 放下右手边的筷子
        sem_post(chopstick + i); // 放下左手筷子
        // sem_post(&room);
    }
}

void think(int i)
{
    printf("philosopher %d is thinking\n",i);
    long interval = rand()%401+100;
    msleep(interval);

}

void eat(int i)
{
    printf("philosopher %d is eating\n",i);
    long interval = rand()%401+100;
    msleep(interval);
}

// sleep thread 'msec' millisecond
int msleep(long msec)
{
    struct timespec ts;
    int res;
    
    if (msec < 0)
    {
        // EINVAL : Invalid argument
        errno = EINVAL;
        return -1;
    }

    ts.tv_sec = msec / 1000;
    ts.tv_nsec = (msec % 1000) * 1000000;

    do {
        res = nanosleep(&ts, &ts);
    } while (res && errno == EINTR);
    // EINTR: Interrupted function call
    // when Interruption of system calls and library functions 

    return res;
}

信号量实现非死锁解法

// use semaphore  no deadlock
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<semaphore.h>
#include<pthread.h>
#include<time.h>
#include <errno.h>    


#define N 5
#define LEFT (i-1)%N // i的左邻居编号   
#define RIGHT (i+1)%N // i的右邻居编号 
#define THINKING 0
#define HUNGRY 1
#define EATING 2

int state[5]; // 记录每一位哲学家的状态
sem_t s[5] ;
sem_t mutex; // 互斥信号量


int msleep(long msec);
void think(int );
void eat(int );
void * philosppher(void *);
void test(int);
void get_chopsticks(int );
void release_chopsticks(int );
// 哲学家逆时针坐着

int main () 
{   

    srand((unsigned)time(NULL)); 

    //sem_init(&room,0,4);

    for(int i = 0;i < 5;i++)
    {
        sem_init(s + i,0,0);
    }
    
    sem_init(&mutex,0,1);

    pthread_t phi_thread[5] ;
    int thread_args[5] = {0,1,2,3,4};

    for (int i = 0; i < 5; i++)
    {
        pthread_create(phi_thread+i,NULL,philosppher,thread_args+i);
    }

    for(int i = 0; i < 5; i++)
    {
        pthread_join(phi_thread[i],NULL);
    }


    // sem_destroy(&room);

    sem_destroy(&mutex);
    for(int i = 0;i < 5;i++)
    {
        sem_destroy(s+i);
    }

    return 0;
}

void * philosppher (void * arg)
{
    int i = *(int *)arg;
    while(1)
    {
        think(i);
        get_chopsticks(i);
        eat(i);
        release_chopsticks(i);


    }
}
void get_chopsticks(int i)
{
    sem_wait(&mutex); // 进入临界区
    state[i] = HUNGRY;  // 设置哲学家状态为饥饿
    test(i);          // 尝试获得两把筷子
    sem_post(&mutex); // 出临界区    
    sem_wait(s+i);    // 如果得不到需要的筷子就阻塞
}

void release_chopsticks(int i)
{
    sem_wait(&mutex);  
    state[i] = THINKING;
    test(LEFT);
    test(RIGHT);
    sem_post(&mutex);
}

void think(int i)
{
    printf("philosopher %d is thinking\n",i);
    long interval = rand()%401+100;
    msleep(interval);

}

void eat(int i)
{
    printf("philosopher %d is eating\n",i);
    long interval = rand()%401+100;
    msleep(interval);
}

// sleep thread 'msec' millisecond
int msleep(long msec)
{
    struct timespec ts;
    int res;
    
    if (msec < 0)
    {
        // EINVAL : Invalid argument
        errno = EINVAL;
        return -1;
    }

    ts.tv_sec = msec / 1000;
    ts.tv_nsec = (msec % 1000) * 1000000;

    do {
        res = nanosleep(&ts, &ts);
    } while (res && errno == EINTR);
    // EINTR: Interrupted function call
    // when Interruption of system calls and library functions 

    return res;
}
void test(int i) {   
    if (state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING) {   
        state[i] = EATING ;   
        sem_post(s+i) ;          
    }   
}

条件变量+互斥锁

// use conditonal variable and mutex
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<semaphore.h>
#include<pthread.h>
#include<time.h>
#include <errno.h>    
#include <stdbool.h>



pthread_cond_t ChopstickReady[5];  // 用于同步的条件变量
bool chopstick[5] = {1,1,1,1,1};  // 每个筷子的可用状态
pthread_mutex_t lock;

int msleep(long msec);
void think(int );
void eat(int );
void * philosppher(void *);
void get_chopsticks(int pid);
void release_chopsticks(int pid);

// 哲学家逆时针坐着

int main () 
{   


    srand((unsigned)time(NULL)); 

    // 初始化互斥锁和条件变量

    pthread_mutex_init(&lock,0);
    for (int i=0;i<5;i++)
    {
        pthread_cond_init(ChopstickReady+i,0);
    }

    pthread_t phi_thread[5] ;
    int thread_args[5] = {0,1,2,3,4};

    for (int i = 0; i < 5; i++)
    {
        pthread_create(phi_thread+i,NULL,philosppher,thread_args+i);
    }

    for(int i = 0; i < 5; i++)
    {
        pthread_join(phi_thread[i],NULL);
    }


    pthread_mutex_destroy(&lock);
    for (int i=0;i<5;i++)
    {
        pthread_cond_destroy(ChopstickReady+i);
    }
    

    return 0;
}

void * philosppher (void * arg)
{
    int i = *(int *)arg;
    while(1)
    {
        think(i);   // 思考
        get_chopsticks(i); // 拿筷子
        eat(i); // 吃饭
        release_chopsticks(i); // 放下筷子
    }
}

void think(int i)
{
    printf("philosopher %d is thinking\n",i);
    long interval = rand()%401+100;
    msleep(interval);

}

void eat(int i)
{
    printf("philosopher %d is eating\n",i);
    long interval = rand()%401+100;
    msleep(interval);
}

// sleep thread 'msec' millisecond
int msleep(long msec)
{
    struct timespec ts;
    int res;
    
    if (msec < 0)
    {
        // EINVAL : Invalid argument
        errno = EINVAL;
        return -1;
    }

    ts.tv_sec = msec / 1000;
    ts.tv_nsec = (msec % 1000) * 1000000;

    do {
        res = nanosleep(&ts, &ts);
    } while (res && errno == EINTR);
    // EINTR: Interrupted function call
    // when Interruption of system calls and library functions 

    return res;
}

void get_chopsticks(int pid)
{
    int left = pid;
    int right = (pid + 1) % 5;

    pthread_mutex_lock(&lock);
   
    // 获取左手筷子
    while (!chopstick[left])
    {
        pthread_cond_wait(ChopstickReady + left,&lock);
    }
    chopstick[left] = false;
    
    // 获取右手筷子
    while (!chopstick[right])
    {
        pthread_cond_wait(ChopstickReady + right,&lock);
    }
    chopstick[right] = false;
    pthread_mutex_unlock(&lock);

}
void release_chopsticks(int pid)
{
    int left = pid;
    int right = (pid +1) % 5;

    pthread_mutex_lock(&lock);

    // 释放左手筷子

    // 当没有人在等待左手的筷子
    if(!(pthread_cond_signal(ChopstickReady + left)))
    {
        chopstick[left] = true;
    }

    // 当没有人在等待右手的筷子
    if(!(pthread_cond_signal(ChopstickReady + right)))
    {
        chopstick[right] = true;
    }

    pthread_mutex_unlock(&lock);

}

参考资料：

WWWzq_
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统：死锁实验报告
10-20
操作系统实验报告：死锁 银行家算法源代码和运行结果的截图。
操作系统 | 实验三 进程死锁
猫天意的博客
05-15 3801
编制模拟银行家算法的程序，并以下面给出的例子验证所编写的程序的正确性。 某系统有A、B、C、D4类资源共5个进程（PO、P1、P2、P3、P4）共享，各进程对资源的需求和分配情况如下表所示。各进程对资源的需求和分配情况表： 现在系统中A、B、C、D4类资源分别还剩1、5、2、0个，请按银行家算法回答下列问题：变量 描述 int available[100]; 可利用资源数组 int max[50][100]; 最大需求矩阵 int allocation[50][100]; 分配矩阵 int need[50
【操作系统】2、进程管理与死锁
Workshop of Wenjie.Yin
02-03 1045
1、进程 所谓进程，可以认为是一个程序及其正在运行的过程。相对来说，程序是一个静态的概念，而进程是一个动态的概念，更加强调程序运行的过程和状态。一般一个进程至少要包含几个内容，即程序代码、程序处理的数据、CPU寄存器的值、堆和栈以及进程所占用的系统资源。 进程的概念所以和程序相区分，关键在于进程具有三个特性，即动态性、独立性和并发性。所谓动态性，指的是进程表示动态执行的程序，每时每刻进程的状态
操作系统之进程与线程6——死锁处理
kyang_823的博客
08-04 225
死锁，进程和线程实验报告
03-02
死锁，进程和线程的实验报告，都是在red hat 9下实际运行过可行的代码，这份是完成以后写的实验报告，里面还有截图
OS.rar_进程同步实验
09-21
这个"OS.rar_进程同步实验"旨在帮助初学者深入理解这一概念。 进程同步是操作系统设计的重要组成部分，它涉及到当两个或多个进程需要共享资源时如何协调它们的执行顺序。在并发执行的环境中，进程可能会同时访问...
操作系统OS第2次实验报告.doc，实验二：进程和线程的创建
11-13
在本次实验中，我们关注的是操作系统中的进程和线程管理，以及它们之间的同步与互斥机制。 首先，实验一涉及了进程的创建。在Linux环境下，通过编写程序`an_ch2_1a`和`an_ch2_1b`，我们体验了如何在C语言中使用系统...
os 进程的控制与调度c++
最新发布
12-13
OS 进程控制与调度是操作系统中一个重要的概念，涉及到进程的创建、执行、同步、通信和死锁等问题。本实验的目的是通过编写和调试进程调度的模拟程序，以加深对进程调度算法的理解。 进程控制 在操作系统中，进程...
操作系统实验——进程创建与进程间通信
06-05
在实践中，需要注意进程同步与互斥问题，以防止数据竞争和死锁等问题。同时，良好的错误处理和调试技巧也是必不可少的，这对于解决可能出现的问题至关重要。 总之，操作系统实验中的进程创建与进程间通信是一个很好...
OS.rar_多进程os
09-21
在"OS.rar_多进程os"这个压缩包中，包含的是一系列关于操作系统，特别是多进程操作系统的实验和练习。这个压缩包的使用者可以深入理解操作系统中多进程并发的基本概念、原理以及实现方式。 多进程是指在一个操作...
操作系统死锁实验银行家算法
06-02
这是操作系统中一个避免死锁的经典算法，为c#改写
操作系统实验三 预防进程死锁的银行家算法
02-03
操作系统实验三 预防进程死锁的银行家算法（内含源代码和详细实验报告），详细介绍：http://blog.csdn.net/xunciy/article/details/79239096
OS——死锁
知识应该被分享。
06-16 205
文章目录死锁(Deadlock)资源死锁参考资料 死锁(Deadlock) 在计算机系统中有很多独占性的资源，在任一时刻它们都只能被一个进程使用。因此，操作系统都具有授权一个进程（临时）排他地访问某一种或多种资源的能力。 软硬件资源都有可能出现死锁。大部分死锁都和资源有关，那什么是资源？ 资源 什么是资源？ 资源就是随着时间的推移，必须能获得、使用、以及释放的任何东西，包括硬件和软件。 资源的分类 资源可分为两类：可抢占的(preemptable)和不可抢占的。 可抢占的：资源在别的进程手中，可强抢，
OS之实验二 进程管理
feng_zhiyu的博客
05-28 1960
实验目的 1．加深对进程概念的理解，明确进程与程序的区别； 2．进一步认识并发执行的实质； 3. 分析进程争用资源的现象，学习解决进程互斥的方法； 4. 了解Linux系统中进程通信的基本原理...
操作系统学习笔记——第二章 进程管理 和 第三章 死锁
Alliswell_WP
04-18 343
在学习操作系统时总结了笔记，并分享出来，特别是蓝色和红色字体。有问题请及时联系博主：Alliswell_WP，转载请注明出处。 参考书：《操作系统》谌卫军等，清华大学出版社，2012年5月参考视频：清航全套计算机专业课视频 目录 第二章 进程管理 1.进程(Process) 2.线程(Thread) 3.进程间通信 4.经典的IPC问题 5.进程调度 第三章 死锁 第二章 进程管理(进程...
OS进程调度实验
longtails的博客
05-08 1068
OS进程调度实验　模拟优先级时间片调度
OS之进程管理
Helloirbd的博客
09-26 176
什么是进程？ 程序的执行（顺序执行、并发执行） 顺序执行 外部有序和内部有序 举个栗子   int main(){        a;        b; } int main(){        c;        d; }//a b c b分别表示执行语句 像这样对于顺序执行，执行的顺序只能为abcd，cdab 顺序执行的特征： 顺序性、封闭性、可再现性 封闭性：执行结果不受外...
OS模拟进程调度实验
Yuuki__Asuna的博客
05-19 384
多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。因而引起进程调度。本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。
王道_OS进程管理
LYY_Blog
09-25 381
进程与线程 进程概念 特征 描述程序和控制程序并发执行，实现OS的并发性和共享性 描述进程基本情况和运行状态，控制管理进程——>PCB（进程存在的唯一标志） 进程实体（进程映像）：程序段、数据段、PCB【静态】——>进程是动态的 资源分配和调度的基本单位，拥有资源的基本单位 动态性、并发性、独立性、异步性、结构性 【程序的封闭性：进程执行的结果只取决于进程本身，进程执行速度不受外界影响。失去封闭性后，不同速度下执行结果不同。】 进程状态 转换 就绪态无处理机有资源 运行态有处理机有资源 ​ 就绪
操作系统实验：进程通信、死锁与内存管理详解
通过这份试卷，学习者可以复习操作系统中的关键概念，如进程通信、死锁预防、虚拟内存管理和磁盘存储管理，这些都是设计和实现高效操作系统所必备的知识。理解这些问题的答案有助于提升软件设计方案师在操作系统领域...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值