0

我正在尝试向两种类型的线程授予对共享资源的访问权限。当且仅当该线程属于同一类型时，它才能被多个线程访问。让我们考虑黑人和白人。当资源被白人使用时，黑人不能使用，反之亦然。

我尝试使用信号量来实现这一点。一旦黑人试图访问该资源，它将增加黑人的数量，如果该数字为 1，它将阻止白人访问它。

问题：当每种类型有超过 1 个线程时（在我的情况下，id 为 0 的线程从未使用过它），就会出现明显的饥饿。我试图通过添加一个额外的信号量作为队列来解决这个问题。

观察：这非常类似于读者-作者问题，除了有一个多对多的访问标准。（它可以被同一类型的多个线程使用）最近我一直在为这个问题头疼，我似乎不明白我应该如何解决这个问题。

现在，对于一些代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <wait.h>
#include <pthread.h>
#include <semaphore.h>

#define MAX_RAND 100
#define TRUE 1
#define FALSE 0

#define WHITES 3
#define BLACKS 2

#define MAX_WORLOAD 10

sem_t semaphore;
sem_t resource_semaphore;
sem_t service_queue;
volatile int resource = 0;
volatile int currentWhites = 0;
volatile int currentBlacks = 0;

typedef struct
{
    char *type;
    int *id;
} data;

void *white(void *args)
{
    data *thread_data = (data *)args;
    int id = *(thread_data->id);
    char *type = thread_data->type;

    for (int i = 0; i < MAX_WORLOAD; i++)
    {
        sem_wait(&service_queue);
        sem_wait(&semaphore);
        sem_post(&service_queue);

        currentWhites++;
        if (currentWhites == 1)
        {
            sem_wait(&resource_semaphore);
        }
        sem_post(&semaphore);

        sem_wait(&semaphore);

        currentBlacks--;
        resource = rand() % MAX_RAND;
        printf("Thread %d of type %s has updated resource to %d\n\n", id, type, resource);

        if (currentWhites == 0)
        {
            sem_post(&resource_semaphore);
        }

        sem_post(&semaphore);
    }
}

void *black(void *args)
{
    data *thread_data = (data *)args;
    int id = *(thread_data->id);
    char *type = thread_data->type;

    for (int i = 0; i < MAX_WORLOAD; i++)
    {
        sem_wait(&service_queue);
        sem_wait(&semaphore);
        sem_post(&service_queue);
        currentBlacks++;
        if (currentBlacks == 1)
        {
            sem_wait(&resource_semaphore);
        }
        sem_post(&semaphore);

        sem_wait(&semaphore);

        currentBlacks--;
        resource = rand() % MAX_RAND;
        printf("Thread %d of type %s has updated resource to %d\n\n", id, type, resource);

        if (currentBlacks == 0)
        {
            sem_post(&resource_semaphore);
        }

        sem_post(&semaphore);
    }
}

data *initialize(pthread_t threads[], int size, char *type)
{
    data *args = malloc(sizeof(data) * size);
    int *id = malloc(sizeof(int));
    void *function;

    if (type == "WHITE")
    {
        function = white;
    }
    else
    {
        function = black;
    }

    for (int i = 0; i < size; i++)
    {
        *id = i;
        args[i].type = type;
        args[i].id = id;
        printf("Initializing %d of type %s\n", *args[i].id, args[i].type);
        pthread_create(&threads[i], NULL, function, (void **)&args[i]);
    }

    return args;
}

void join(pthread_t threads[], int size)
{
    for (int i = 0; i < size; i++)
    {
        pthread_join(threads[i], NULL);
    }
}

void initialize_locks()
{
    sem_init(&semaphore, 0, 1);
    sem_init(&resource_semaphore, 0, 1);
    sem_init(&service_queue, 0, 1);
}

int main()
{
    initialize_locks();
    pthread_t whites[WHITES];
    pthread_t blacks[BLACKS];
    char *white = "white";
    char *black = "black";
    data *whites_arg = initialize(whites, WHITES, white);
    data *blacks_arg = initialize(blacks, BLACKS, black);

    join(whites, WHITES);
    join(blacks, BLACKS);

    free(whites_arg);
    free(blacks_arg);
    return 0;
}
4

1 回答 1

1

如果您想强制在访问单个事物的两种类型的线程之间交替，您可以使用两个信号量。让黑人和白人各有自己的信号量，一个信号量用 0 键启动，另一个用 10 或什么的，然后让白人释放一个黑色信号量的密钥，黑人释放一个密钥到白信号量，这样如果你有 10 个白线程，当其中一个解锁时，你将无法放入第 10 个白线程，但你可以放入黑线程，这样当所有的白色线程释放它们的键，您将没有当前访问该事物的白色线程。

TL;DR：两个相互发布而不是自己发布的信号量将允许组之间的交替，但是独立于此操作，您还需要确保在黑人仍在时白人不会离开。

于 2018-11-27T20:05:41.027 回答