【发布时间】：2018-12-18 19:55:26
【问题描述】：
免责声明：这篇文章包含对以下答案所做的修改，所有功劳归其各自所有者所有。
我正在尝试实现一个问题，即资源可能被两种类型的线程使用。每种类型可以有更多的线程。 （4 个白色类型的螺纹和 6 个黑色类型的螺纹）。任意数量的黑人可以同时使用该资源。白人也一样。我仍然无法解决这个问题......
我尝试使用互斥锁来实现这一点。我还想考虑此实现可能存在的饥饿问题，因此我决定检查是否已达到某种类型的服务线程数，从而允许其他类型工作。我似乎无法实施最新的。
我还想考虑到，每当其他类型想要使用资源时，它必须等待轮到它，以及其他类型完成使用资源。
编辑：我尝试使用 @Nominal-Animal 的解决方案，但似乎有时也会出现这种死锁。此外，我在结构中添加了缺少的转弯。现在，我有一些额外的问题：
- 这似乎是正确的，但不起作用，为什么？
- 为什么
bwlock_lock()里面的isBLack参数需要双重否定
现在，一些代码：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <wait.h>
#include <pthread.h>
#define WHITES 31
#define BLACKS 33
#define TYPES 2
#define W_ID 0
#define B_ID 1
struct bwlock
{
pthread_mutex_t lock; /* Protects the rest of the fields */
pthread_cond_t wait[2]; /* To wait for their turn */
volatile int waiting[2]; /* Number of threads waiting */
volatile int running[2]; /* Number of threads running */
volatile int started[2]; /* Number of threads started in this turn */
const int limit[2]; /* Maximum number of starts per turn */
volatile int black; /* Black threads' turn */
volatile int turn; /*The turn */
};
#define BWLOCK_INIT(whites, blacks, turn) \
{ \
PTHREAD_MUTEX_INITIALIZER, \
{PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER}, \
{0, 0}, {0, 0}, {0, 0}, {whites, blacks}, 0, turn \
}
struct bwlock resource = BWLOCK_INIT(4, 5, W_ID);
void bwlock_unlock(struct bwlock *bwl, const int isblack)
{
const int black = !!isblack; /* 0 if white, 1 if black */
pthread_mutex_lock(&(bwl->lock));
/* This thread is no longer using the resource. */
bwl->running[black]--;
/* Was this the last of this color, with others waiting? */
if (bwl->running[black] <= 0 && bwl->waiting[!black])
{
/* Yes. It's their turn. */
if (bwl->turn == black)
{
bwl->turn = !black;
/* Clear their started counter. */
bwl->started[!black] = 0;
}
/* Wake them all up. */
pthread_cond_broadcast(&(bwl->wait[!black]));
}
pthread_mutex_unlock(&(bwl->lock));
}
void bwlock_lock(struct bwlock *bwl, const int isblack)
{
const int black = !!isblack; /* 0 if white, 1 if black */
pthread_mutex_lock(&(bwl->lock));
while (1)
{
/* No runners or waiters of the other color? */
if (!(bwl->waiting[!black] < 1) && bwl->running[!black] < 1)
{
/* No; we can run. Does this change the turn? */
if (bwl->turn != black)
{
bwl->turn = black;
/* Clear started counter. */
bwl->started[black] = 0;
}
break;
}
/* Still our turn, and not too many started threads? */
if (bwl->turn == black && bwl->started[black] < bwl->limit[black])
break;
/* We must wait. */
bwl->waiting[black]++;
pthread_cond_wait(&(bwl->wait[black]), &(bwl->lock));
bwl->waiting[black]--;
}
bwl->started[black]++;
bwl->running[black]++;
pthread_mutex_unlock(&(bwl->lock));
}
typedef struct
{
int thread_id;
char *type;
int type_id;
} data;
void use_resource(int thread_id, char *type)
{
printf("U: Thread %d of type %s is using the resource!\n", thread_id, type);
}
void take_resource(int thread_id, char *type, int type_id)
{
printf("W:Thread %d of type %s is trying to get the resource!\n", thread_id, type);
bwlock_lock(&resource, type_id);
printf("W:Thread %d of type %sB got resource!\n", thread_id, type);
}
void release_resource(int thread_id, char *type, int type_id)
{
bwlock_unlock(&resource, type_id);
printf("R:Thread %d of type %s has released the resource!\n", thread_id, type);
}
void *doWork(void *arg)
{
data thread_data = *((data *)arg);
int thread_id = thread_data.thread_id;
char *type = thread_data.type;
int type_id = thread_data.type_id;
take_resource(thread_id, type, type_id);
use_resource(thread_id, type);
release_resource(thread_id, type, type_id);
return NULL;
}
data *initialize(pthread_t threads[], int size, char *type, int type_id)
{
data *args = malloc(sizeof(data) * size);
for (int i = 0; i < size; i++)
{
args[i].type = type;
args[i].thread_id = i;
args[i].type_id = type_id;
pthread_create(&threads[i], NULL, doWork, (void **)&args[i]);
}
return args;
}
void join(pthread_t threads[], int size)
{
for (int i = 0; i < size; i++)
{
pthread_join(threads[i], NULL);
}
}
int main()
{
pthread_t whites[WHITES];
pthread_t blacks[BLACKS];
char *white = "WHITE";
char *black = "BLACK";
data *w_args = initialize(whites, WHITES, white, W_ID);
data *b_args = initialize(blacks, BLACKS, black, B_ID);
join(whites, WHITES);
join(blacks, BLACKS);
free(w_args);
free(b_args);
return 0;
}
这是使用gcc -g -o ba blacks_whites.c -Wall -Wextra -pthread 编译的。
【问题讨论】：
-
让我确保我有这个直。您的几个线程分为两组，以一个属性为特征，我们将其两个可能的值标记为“黑色”和“白色”。对托管资源的访问权限是按组获取的，因此在任何给定时间，每个资源要么归黑线程所有，要么归白线程所有，或者可供获取。对吗？
-
此外，除了当前的所有权信息之外，您还希望维护每个资源的使用计数，以防止任一线程组独占任何资源。
-
你有一个错误。在
take_resource中，如果（例如）not_your_turn返回 false，while子句中的其他函数将被 not 调用（短路评估），release_locks将尝试执行pthread_mutex_unlock在未被获取的互斥体上（例如comparison_mutex和status_mutex）。 -
另外，您可能有竞争条件。在
take_resource中，您执行current[type_id]++;没有 持有任何锁，因此您可能在另一个线程中与others_not_released竞争。 -
我感觉你有一个潜在的僵局，但没有时间去调查/证明它。遵循下面的一些示例，因为您的最新代码必须在与条件变量关联的互斥锁上执行
pthread_mutex_lock，在使用该互斥锁调用pthread_cond_wait（即）pthread_cond_wait期望 要锁定的互斥体，可以 [在内部] 释放它，并返回锁定的互斥体
标签： c multithreading thread-safety posix starvation