c - 意外的信号量行为，线程在 sem_wait() 之外执行

Question

我一直试图围绕 C 中的信号量概念进行思考，但我取得了一些有限的成功。据我了解，在 C 中，如果信号量的值为 0，则 sem_wait() 应导致该线程阻塞，直到该信号量的值不再为 0。

我的问题是:我写了一些非常快速的示例代码(如下)，我不知道为什么，但是一旦创建了线程，它们似乎执行 sem_wait() 之外的代码，即使信号量的值似乎是0. 我不知道为什么会这样。

编辑:根据 Perception 的建议，我检查了 sem_wait() 的返回值，似乎将 errno 设置为“操作超时”。据我所知，除非我使用 sem_timedwait()，否则这不应该发生。还在挖...

编辑2:哎呀。应该更仔细地阅读我的输出。它实际上将其设置为“功能未实现”。

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

// vars
int jobsInQueue, currentJob;
sem_t *semaphore;
pthread_t threads[10];
int runningThreads = 0;

// prototypes
void *do_work(void *arg);
void add_job();

int main()
{
    // i for the for loop used to create the threads
    int i;

    // counter for jobs in the queue
    jobsInQueue = 0;

    // indicator for the current job
    currentJob = 0;

    // indicator for whether we have reached the limit imposed in the while loop used for adding jobs
    int reachedlimit = 0;

    // create the semaphore
    semaphore = sem_open("semaphore", O_CREAT, 0600, 0);

    // get the value of the semaphore and temporarily store it in reachedlimit
    sem_getvalue(semaphore, &reachedlimit);

    // print off the value of the semaphore.  I think I'm crazy because the threads are executing code
    // before the semaphore is posted to, but this appears to be zero...
    fprintf(stderr, "semaphore: %d", reachedlimit);
    fflush(stderr);

    // set reachedlimit back to zero because we expect it to be zero below
    reachedlimit = 0;

    for(i = 0; i < 10; ++i)
    {
        // create a pthread
        pthread_create(&threads[i], NULL, &do_work, (void *)i);

        // increment the number of running threads
        runningThreads++;
    }

    // sleep for a couple of seconds just as separator space
    sleep(2);

    // while there are threads running
    while(runningThreads > 0)
    {
        // sleep for a tenth of a second
        usleep(100000);

        // after that, if there are 1000 or more jobs in the queue, we've reached the number of total jobs we want
        if(jobsInQueue >= 1000) reachedlimit = 1;

        // if we haven't reached that, then add another job
        if(reachedlimit == 0) add_job();

        // print that we're still sleeping and the number of jobs in the queue.
        fprintf(stderr, "Still sleeping. Jobs in queue: %d\n", jobsInQueue);
        fflush(stderr);
    }
}

void *do_work(void *arg)
{
    // when the thread is created, print this thread's number to the console
    fprintf(stderr, "I am thread %d.\n", (int)arg);
    fflush(stderr);

    // then loop infinitely doing the following...
    while(1)
    {
        // wait until the semaphore's value is no longer zero <-- doesn't seem to do this
        sem_wait(semaphore);

        // if we are on the 1000th job, terminate the thread
        if (currentJob >= 1000) {
            runningThreads--;
            fprintf(stderr, "Thread %d terminated", (int)arg);
            fflush(stderr);
            pthread_exit((void *)1);
        }

        // otherwise, increment the current job counter
        currentJob++;

        // tell the console that this thread took a job
        fprintf(stderr, "Thread %d: I took a job.: %d\n", (int)arg, currentJob);
        fflush(stderr);

        // subtract one from the count of jobs in the queue
        jobsInQueue--;

        // sleep for at least one second before taking another job
        sleep(1);
    }

    // this will never happen because the while loop will never be broken
    runningThreads--;
    return NULL;
}

void add_job()
{
    // increment the count of jobs in the queue
    jobsInQueue++;

    // print that a job has been added
    fprintf(stderr, "Job added\n");
    fflush(stderr);

    // post to the semaphore, which should essentially release the job for "processing" if I understand correctly.
    sem_post(semaphore);
}

一些示例输出:

semaphore: 0
I am thread 0.
I am thread 1.
Thread 0: I took a job.: 1
I am thread 2.
I am thread 3.
Thread 1: I took a job.: 2
I am thread 4.
I am thread 5.
I am thread 6.
Thread 2: I took a job.: 3
I am thread 7.
I am thread 8.
Thread 3: I took a job.: 4
I am thread 9.
Thread 4: I took a job.: 5
Thread 5: I took a job.: 6
Thread 6: I took a job.: 7
Thread 7: I took a job.: 8
Thread 8: I took a job.: 9
Thread 9: I took a job.: 10
Thread 0: I took a job.: 12
Thread 4: I took a job.: 11
Thread 5: I took a job.: 13
Thread 6: I took a job.: 14
Thread 1: I took a job.: 15
Thread 8: I took a job.: 17
Thread 3: I took a job.: 16
Thread 7: I took a job.: 18
Thread 2: I took a job.: 19
Thread 9: I took a job.: 20
Thread 0: I took a job.: 21
Thread 1: I took a job.: 22
Thread 8: I took a job.: 23
Thread 3: I took a job.: 24
Thread 5: I took a job.: 25
Thread 7: I took a job.: 26
Thread 6: I took a job.: 27
Thread 2: I took a job.: 29
Thread 4: I took a job.: 28
Thread 9: I took a job.: 30
Job added
Still sleeping. Jobs in queue: -29
Job added
Still sleeping. Jobs in queue: -28
Job added
Still sleeping. Jobs in queue: -27
Job added
Still sleeping. Jobs in queue: -26
Job added
Still sleeping. Jobs in queue: -25
Job added
Still sleeping. Jobs in queue: -24
Job added
Still sleeping. Jobs in queue: -23
Job added
Still sleeping. Jobs in queue: -22
Job added
Still sleeping. Jobs in queue: -21
Thread 3: I took a job.: 31
Thread 0: I took a job.: 32
Thread 5: I took a job.: 33
Thread 2: I took a job.: 34
Thread 1: I took a job.: 35
Thread 7: I took a job.: 36
Thread 9: I took a job.: 37
Thread 8: I took a job.: 38
Thread 6: I took a job.: 39
Thread 4: I took a job.: 40
Job added
Still sleeping. Jobs in queue: -30
Job added
Still sleeping. Jobs in queue: -29
Job added
Still sleeping. Jobs in queue: -28
Job added
Still sleeping. Jobs in queue: -27
Job added
Still sleeping. Jobs in queue: -26
Job added
Still sleeping. Jobs in queue: -25

Answer 1

除非您明确取消链接，否则信号量会在进程终止后持续存在。您看到的行为是由于线程拉动旧作业 sem_post 'd 到信号量的前一个过程。您的 sem_getvalue如果调用确实有效，调用将显示那些旧作业的存在，但它失败了，并且您没有注意到，因为您没有检查 sem_getvalue的返回值。 “函数未实现” errno 值实际上来自 sem_getvalue ，不是 sem_wait .

添加

sem_unlink("semaphore");

在您调用 sem_open 之前并且奇怪的行为会消失。