给力星

Web Developer

实验六 线程及其同步—哲学家问题的线程版_Unix环境高级编程

实验六哲学家问题的线程版,本科生跟研究生的实验内容是一样的,但要求不一样。本科生要求用信号量来实现,比较简单,研究生用的是条件变量和互斥量来实现。

实验描述

目的:学习线程的编程和同步。

要求:

1、程序语法

philosopher_th <N> [ -t <time> ]

N是哲学家的个数(N >= 2)。time是哲学家进餐和沉思的持续时间值,缺省为2秒。
2、哲学家的编号为0 ~ N-1,分别用N个线程独立模拟。
3、程序的输出要简洁,例如,当编号为3的哲学家在进餐时,就打印:
philosopher 3 is eating
而当他在沉思时,则打印:
philosopher 3 is thinking
不要输出其他任何信息。
4、使用pthread的semaphore.h提供的信号量同步线程。(本科生要求)
4、仅使用一个条件变量以及一个与其捆绑的锁来同步线程。(研究生要求)
5、程序一直运行,直到人为地终止它(如按Ctrl-C或Ctrl-\)。不允许出现僵尸进程。

本科生实验思路

用semaphore.h提供的信号量来解决的话,这个实验就跟实验四几乎一样了,就只是同步机制不一样而已,可以说,只要替换下相应的同步函数(如用 sem_wait() 替代 lock() ),再稍做修改,这实验就完成了…

所以并没用什么可以讲的,注意下这个实验是可以指定哲学家的数量,以及注意线程的最大限制数量就行了。《实验指导》里是这么说的:注意,Linux系统对线程的处理与进程类似,因此,你能创建的线程数目与进程数目的总和,不能大于系统对你的限制,具体说就是20个。

完整代码

编译时需加上参数 -lpthread ,即:

gcc philosopher_th.c error2e.c -lpthread -o philosopher_th

参数 -lpthread 在使用 pthread 线程包的系统时是必须的。

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

static sem_t *forks;    // 信号量表示叉子状态
static N;       // 哲学家的个数
static int nsecs = 2;

/* 显示时间,方便查看结果,提交时应删除 */
static char now[80];
char* getTime() {
    time_t tim;
    struct tm *at;
    time(&tim);
    at=localtime(&tim);
    strftime(now, 79, "%H:%M:%S", at);
    return now;
}

/*
 * 拿叉子的定义
 * 如果哲学家中同时存在左撇子和右撇子,则哲学家问题有解
 */
void takeFork(int i) {
    if(i == N-1) {  // 人为设定第N-1位哲学家是右撇子
        sem_wait(&forks[0]);
        sem_wait(&forks[i]);
    } else {        // 其他是左撇子
        sem_wait(&forks[i]);
        sem_wait(&forks[i+1]);
    }
}

/* 放下叉子 */
void putFork(int i) {
    if(i == N-1) {
        sem_post(&forks[0]);
        sem_post(&forks[i]);
    }
    else {
        sem_post(&forks[i]);
        sem_post(&forks[i+1]);
    }
}


void thinking(int i, int nsecs) {
    printf("philosopher %d is thinking\t%s\n", i, getTime());
    sleep(nsecs);
}
void eating(int i, int nsecs) {
    printf("philosopher %d is eating\t\t%s\n", i, getTime());
    sleep(nsecs);
}

/* 哲学家行为 */
void* philosopher(void *n) {
    int i = (int)n;
    while(1) {
        thinking(i, nsecs);     // 哲学家i思考nsecs秒
        takeFork(i);            // 哲学家i拿起叉子
        eating(i, nsecs);       // 哲学家i进餐nsecs秒
        putFork(i);         // 哲学家i放下叉子
    }
}

int main(int argc, char * argv[]) {
    int i;
    pthread_t tpid;
    int status;

    /* 处理输入 */
    if ( (argc != 2 && argc != 4) || (argc == 4 && (strcmp(argv[2], "-t")) != 0)) {
        err_quit("useage: philosopher_th <N> [ -t <time> ]");
    }
    N = atoi(argv[1]);
    if (N < 2 || N > 20) {
        err_quit("N is the number of philosopher, N >= 2 && N <= 20");
    }
    if (argc == 4) {
        nsecs = atoi(argv[3]);
    }

    /* 分配N个信号量 */
    forks = (sem_t *) malloc( N * sizeof(sem_t) );
    /* 初始化信号量 */
    for( i = 0; i < N; i++) {
        sem_init(forks + i, 0, 1);
    }

    for(i = 0; i < N; i++) {
        status = pthread_create(&tpid, NULL, philosopher, (void *) i);
        if( status < 0 ) {
             err_sys("pthread_create fail.");
        }
    }
    pthread_join(tpid, NULL);   /* 我们对线程的返回值不感兴趣,
            但是若不等待子线程的结束,则主线程的结束将导致整个进程的结束 */

}

研究生实验思路

与实验四类似,但使用的是线程同步,可以通过使用条件变量和一个互斥量来实现。同时以分离状态来创建线程,让线程终止时可以自动释放资源。

哲学家的行为可以用如下函数描述:

void* philosopher(void * arg) {
    int i = (int)arg;
    while(1) {
        thinking(i, nsecs);
        pthread_mutex_lock(&pLock);
        while(!isAvailable(i)) {
            pthread_cond_wait(&pWait, &pLock);
        }
        takeFork(i);
        pthread_mutex_unlock(&pLock);
        eating(i, nsecs);
        putFork(i);
        pthread_cond_broadcast(&pWait); // 放下叉子后,唤醒等待的线程
    }
}

先锁住互斥量,然后尝试获得叉子,如果不能获得叉子,则进入等待。此时pthread_cond_wait会自动释放互斥量的锁。而有哲学家拿起叉子,且进餐结束放下叉子后,通过pthread_cond_broadcast来唤醒等待的进程再次尝试获取叉子。

并且,使用条件变量+互斥量的话,可以简单的以数组int *pFork来表示叉子(值为1表示叉子可用),并且不必考虑左、右撇子的问题,哲学家要么拿起两把叉子,要么不拿叉子。在互斥锁的保护下,这个操作不会有竞争。

拿起叉子的代码如下:

void takeFork(int i) { 
    pFork[i] = 0;
    pFork[(i+1) % N] = 0;
}

完整代码

编译时需加上参数 -lpthread ,即:

gcc philosopher_th.c error2e.c -lpthread -o philosopher_th

参数 -lpthread 在使用 pthread 线程包的系统时是必须的。

#include "apue.h"
#include <pthread.h>

static pthread_cond_t   pWait = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t  pLock = PTHREAD_MUTEX_INITIALIZER;

int N = 0;
int nsecs = 2;
int *pFork; // 01 array presents the forks; 1 -> available

int isAvailable(int i) {
    if (pFork[i] && pFork[(i+1) % N])
        return 1;
    else
        return 0;
}

void takeFork(int i) {
    pFork[i] = 0;
    pFork[(i+1) % N] = 0;
}

void putFork(int i) {
    pFork[i] = 1;
    pFork[(i+1) % N] = 1;
}

void thinking(int i, int nsecs) {
    printf("philosopher %d is thinking\n", i);
    sleep(nsecs);
}

void eating(int i, int nsecs) {
    printf("philosopher %d is eating\n", i);
    sleep(nsecs);
}

void* philosopher(void * arg) {
    int i = (int)arg;
    while(1) {
        thinking(i, nsecs);
        pthread_mutex_lock(&pLock);
        while(!isAvailable(i)) {
            // thinking(i, 0);
            pthread_cond_wait(&pWait, &pLock);
        }
        takeFork(i);
        pthread_mutex_unlock(&pLock);
        eating(i, nsecs);
        putFork(i);
        pthread_cond_broadcast(&pWait);
    }
}

int main(int argc, char *argv[]) {
    int i, err;
    pthread_t tid[20];
    pthread_attr_t attr;

    /* 处理输入 */
    if ( (argc != 2 && argc != 4) || (argc == 4 && (strcmp(argv[2], "-t")) != 0)) {
        err_quit("useage: philosopher_th <N> [ -t <time> ]");
    }
    N = atoi(argv[1]);
    if (N < 2 || N > 20) {
        err_quit("N is the number of philosopher, N >= 2 && N <= 20");
    }
    if (argc == 4) {
        nsecs = atoi(argv[3]);
    }

    /* 初始化 */
    pFork = (int *)malloc(N*sizeof(int));
    for (i = 0; i < N; i++) {
        pFork[i] = 1;
    }

    err = pthread_attr_init(&attr); // detach
    if (err != 0)
        err_quit("pthread arr init error");
    err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    if (err != 0)
        err_quit("set detachstate error");
    for (i = 0; i < N; i++) {
        err = pthread_create(&tid[i], &attr, philosopher, (void *)(long int)i);
        if (err != 0)
            err_quit("can't create thread: %s\n", strerror(err));
    }
    pause();
    return 0;
}