Question

这是我正在进行的一项任务。它必须使用信号量，而不是互斥量。

#include <stdio.h> 
#include <pthread.h> 
#include <assert.h> 
#include <unistd.h> 
#include <semaphore.h> 
#include <fcntl.h>
sem_t *ab, *ac, *ad, *de, *ce, *bf, *ef; 

void *a(void *arg) {
    printf("Entering A...\n");
    sleep(1);
    printf("Exiting A...\n");
    assert(sem_post(ab)==0);
    assert(sem_post(ac)==0);
    assert(sem_post(ad)==0);
    pthread_exit((void *)99);
}

void *b(void *arg) {
    assert(sem_wait(ab)==0);
    printf("Entering B...\n");
    sleep(1);
    printf("Exiting B...\n");
    assert(sem_post(bf)==0);
    pthread_exit((void *)99);
}

void *c(void *arg) {
    assert(sem_wait(ac)==0);
    printf("Entering C...\n");
    sleep(1);
    printf("Exiting C...\n");
    assert(sem_post(ce)==0);
    pthread_exit((void *)99);
}

void *d(void *arg) {
    assert(sem_wait(ad)==0);
    printf("Entering D...\n");
    sleep(1);
    printf("Exiting D...\n");
    assert(sem_post(de)==0);
    pthread_exit((void *)99);
}

void *e(void *arg) {
    assert(sem_wait(ce)==0);
    assert(sem_wait(de)==0);
    printf("Entering E...\n");
    sleep(1);
    printf("Exiting E...\n");
    assert(sem_post(ef)==0);
    pthread_exit((void *)99);
}

void *f(void *arg) {
    assert(sem_wait(bf)==0);
    assert(sem_wait(ef)==0);
    printf("Entering F...\n");
    sleep(1);
    printf("Exiting F...\n");
    pthread_exit((void *)99);
}


int main() { 
    pthread_t _a, _b, _c, _d, _e, _f;
    int r1, r2, r3, r4, r5, r6;

    ab=sem_open("foobar", O_CREAT, 0700, 0);
    ac=sem_open("foobar", O_CREAT, 0700, 0);
    ad=sem_open("foobar", O_CREAT, 0700, 0);
    ce=sem_open("foobar", O_CREAT, 0700, 0);
    de=sem_open("foobar", O_CREAT, 0700, 0);
    ef=sem_open("foobar", O_CREAT, 0700, 0);
    bf=sem_open("foobar", O_CREAT, 0700, 0);

    /*sem_init(ab,0,1);
    sem_init(ac,0,1);
    sem_init(ad,0,1);
    sem_init(ce,0,1);
    sem_init(de,0,1);
    sem_init(ef,0,1);
    sem_init(bf,0,1);*/

    assert(pthread_create(&_a, NULL, a, &r1) == 0);
    assert(pthread_create(&_b, NULL, b, &r2) == 0);
    assert(pthread_create(&_c, NULL, c, &r3) == 0);
    assert(pthread_create(&_d, NULL, d, &r4) == 0);
    assert(pthread_create(&_e, NULL, e, &r5) == 0);
    assert(pthread_create(&_f, NULL, f, &r6) == 0);

    assert(pthread_join(_a, NULL) == 0);
    assert(pthread_join(_b, NULL) == 0);
    assert(pthread_join(_c, NULL) == 0);    
    assert(pthread_join(_d, NULL) == 0);
    assert(pthread_join(_e, NULL) == 0);
    assert(pthread_join(_f, NULL) == 0);

    assert( sem_close(ab)==0 ); 
    assert( sem_close(ac)==0 ); 
    assert( sem_close(ad)==0 ); 
    assert( sem_close(ce)==0 );
    assert( sem_close(de)==0 ); 
    assert( sem_close(bf)==0 );
    assert( sem_close(ef)==0 ); 

    return 0; 
}

这很简单，但由于某种原因，它没有以正确的顺序执行。输出远非一致但总是不正确。这是一个示例输出：

输入A ...
输入B ...＆lt; ---- sem_post（ab）尚未被召唤退出A ... 输入C ...
输入D ...
退出B ...
退出D ...
退出C ...
输入E ...
输入F ...
退出F ...
退出E ...

应该遵循以下图表：

对此有任何帮助将不胜感激，但这是一项任务，所以不要开始告诉我以完全不同的方式做到这一点并且不要直接给出答案，只需指出正确的方向。

Answer 1

你有两个问题。首先，您只有一个信号量，称为foobar，您将打开七次。第二个问题是命名的信号量是持久的 - 它们保持不变（并保持相同的值），直到你对它们调用sem_unlink()。由于您从未执行此操作，因此信号量foobar可能从您之前的程序运行开始时的值大于零。

您可以使用sem_unlink()更正这些问题，以确保信号量在创建之前不存在，并为每个信号量使用不同的名称。

或者，您应该使用未命名的信号量，这些信号量是使用sem_init()而不是sem_open()创建的。为此，您需要将ab，ac，...的声明更改为：

sem_t ab, ac, ad, de, ce, bf, ef;

然后，您将更改所有sem_post()和sem_wait()来电，以便他们使用&ab，&ac，...：

void *a(void *arg) {
    printf("Entering A...\n");
    sleep(1);
    printf("Exiting A...\n");
    assert(sem_post(&ab)==0);
    assert(sem_post(&ac)==0);
    assert(sem_post(&ad)==0);
    pthread_exit((void *)99);
}

您可以使用sem_open()替换sem_init()来电：

sem_init(&ab, 0, 0);
sem_init(&ac, 0, 0);
sem_init(&ad, 0, 0);
sem_init(&ce, 0, 0);
sem_init(&de, 0, 0);
sem_init(&ef, 0, 0);
sem_init(&bf, 0, 0);

最后用sem_close()替换sem_destroy()来电：

assert( sem_destroy(&ab)==0 );
assert( sem_destroy(&ac)==0 );
assert( sem_destroy(&ad)==0 );
assert( sem_destroy(&ce)==0 );
assert( sem_destroy(&de)==0 );
assert( sem_destroy(&bf)==0 );
assert( sem_destroy(&ef)==0 );

当我对您的代码进行上述更改时，我得到以下输出，我相信这是您所期望的：

Entering A...
Exiting A...
Entering B...
Entering C...
Entering D...
Exiting B...
Exiting C...
Exiting D...
Entering E...
Exiting E...
Entering F...
Exiting F...

Answer 2

在使用 ab 打印退出行之前，代码A未锁定。

这意味着当它从睡眠状态返回时，它可以做任何想做的事情，因为它不依赖于锁或其他任何东西。

您应该使用信号量来阻止其他线程/函数继续。 sleep（）只是让处理器放弃你指定的时间，然后就可以继续了。

注意：

你可能不必使用睡眠。如果线程无法获得锁定，线程将放弃CPU

pthreads +信号量，为什么这不能正常执行？

2 个答案: