按类型限制多对多的资源访问
Restricting resource access by type for many-to-many
免责声明：此 post 包含对以下答案所做的编辑，所有学分归其各自所有者所有。
我正在尝试解决一个问题，该问题指出资源可能被两种类型的线程使用。每种类型可以有更多线程。 （4 条白色螺纹和 6 条黑色螺纹）。任意数量的黑人可以同时使用该资源。白人也是如此。我仍然无法解决这个问题...
我尝试使用互斥体来实现它。我还想考虑到此实现可能存在的饥饿问题，因此我决定检查是否已达到某种类型的服务线程数，以允许其他类型工作。我似乎无法实施最新的。
我还想考虑到每当其他类型想要使用该资源时，它必须等待轮到它，以及其他类型来完成使用该资源。
编辑：我尝试使用 @Nominal-Animal 的解决方案，但似乎有时也会出现这种死锁。此外，我将缺少的 turn 添加到结构中。现在，我有一些额外的问题：
- 这似乎是对的，但行不通，为什么？
- 为什么
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 编译的。
一般评论
sleep() 几乎从来不是解决同步问题的正确方法。- 互斥体提供仅互斥。如果您需要比这更多的线程间协调，那么您应该选择不同类型的同步对象（有时信号量更合适），或者添加另一种类型（条件变量通常是互斥体的伴侣）。
- 将互斥锁和解锁拆分成不同的函数是有问题的风格。即使你必须这样做，至少更愿意设置一对平衡的函数来执行锁定和解锁。
一些细节
你的互斥体太多了，这给你带来了麻烦。我认为没有必要为您维护的不同类型的资源管理元数据维护单独的互斥体。您最多需要两个互斥体：一个用于保护组访问元数据（turn、pending、current 和 served），一个可能用于保护资源本身。任何线程都没有必要同时持有这两者，但您必须确保在没有适当互斥锁保护的情况下不会访问任何共享数据。
您应该使用条件变量来帮助调节对组访问元数据的访问。当轮到他们的组时，线程将等待 CV，而不是休眠。这将自然地与保护组访问元数据的互斥锁集成。
虽然实施这些更改需要进行一些重新设计，但结果在概念上会更简单，而且在实践中会更稳健。例如，take_resource() 中围绕已获取哪些互斥量的不确定性的问题将消失，因为首先只有一个互斥量将涉及该部分。
考虑以下对 的扩展评论。
OP 描述的规则不完整。例如，考虑这样一种情况：三个黑色线程拥有资源，一个白色线程等待资源，另一个黑色线程到达并希望获取资源。应该发生什么？如果黑线程总是获得资源，那么黑（或白）线程有可能饿死其他类型的线程。如果在可能的情况下立即将所有权更改为另一种类型，我们将失去跨同一类型线程的大部分并发优势；如果传入线程类型的分布大致均匀，可能 运行一次只使用一种类型的一个线程，所有线程都是顺序排列的！
有几种可能的解决方案。似乎符合 OP 的问题陈述的是在切换之前允许 Nblack 黑线程与资源 运行如果有人在等，轮到白人；在切换到黑人之前，最多 Nwhite 白人线程到 运行 与资源。 （时间限制，当相同类型的其他线程也可能抢占资源时的宽限期，可能是您在实践中实际使用的。）
我们可以用下面的结构来描述这种锁：
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 */
};
#define BWLOCK_INIT(whites, blacks) \
{ PTHREAD_MUTEX_INITIALIZER, \
{ PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER }, \
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { whites, blacks }, 0 \
}
lock 互斥量仅在检查字段时保留，而不是在资源访问期间保留。
(另请注意，虽然black最初为0，但当没有运行ners和waiters时，轮次会发生变化，因此无所谓。代码将完全按照如果初始 black 为 1，则相同。)
我们先看看释放bwlock，因为这是比较有趣的部分；它是控制转弯变化的原因。假设锁定和释放都有一个 isblack 参数（为 0 或 1）。如果释放线程是其颜色的最后一个，并且其他颜色的线程正在等待，它将改变轮次，并在其他颜色上广播 wait 条件变量以唤醒它们：
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] > 0)) {
/* Yes. It's their turn. */
if (bwl->black == black) {
bwl->black = !black;
/* Clear their started counter. */
bwl->started[!black] = 0;
}
/* Wake them all up. */
pthread_cond_broadcast(&(bwl->wait[!black]));
}
pthread_mutex_unlock(&(bwl->lock));
return;
}
获取 bwlock 更复杂。该限制仅在没有其他类型的线程在等待时适用（因为如果我们这样做，单一颜色的线程会在没有其他颜色的情况下死锁）。
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->black != black) {
bwl->black = black;
/* Clear started counter. */
bwl->started[black] = 0;
}
break;
}
/* Still our turn, and not too many started threads? */
if ((bwl->black == 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));
}
pthread_cond_wait(&(bwl->wait[black]), &(bwl->lock)) 释放锁并等待条件变量上的信号或广播。当收到信号时，它将在返回之前重新获取锁。 （在释放锁和等待条件变量时没有竞争 window；它在同一时间点以原子方式有效地发生。）
如果考虑上述逻辑，bwlock_unlock() 处理特定颜色的最后一个 运行ning 线程应该处理 "baton" 到另一个线程集的情况。 bwlock_lock() 确定线程是否可以 运行 使用资源，或者是否需要等待。它只会在没有其他颜色的线程 运行ning 或等待轮到它们时才改变轮次。
这是一个相当简单的方案，但您可能需要考虑几种情况才能理解其行为。
started 计数器在轮次更改时清零，并为在该轮次期间启动的每个线程递增。当它达到 limit 时，将不再启动该类型的线程；他们会等待轮到他们。
假设 limit 是 {3, 3}，每种类型有四个线程，它们基本上同时冲向 bwlock。假设抢锁的第一个线程是黑色的。前三个黑色线程将 运行 资源，一个黑色线程和四个白色线程将等待条件变量。当转弯时，三个白线到达 运行；一个白色，一个随机的，将重新等待直到下一个白色回合。
此外，正如 Craig Estey 在对 John Bollingers 回答的评论中指出的那样，这并不能保证同一类型线程之间的公平性。例如，如果 A 和 B 是同一类型，A 在轮到他们时多次访问受 bwlock 保护的资源，而 B 只访问一次，则 B 可能必须无限期地等待才能轮到，因为 A "hogs" 所有插槽。
为了保证公平，我们需要某种票证锁或有序等待队列，这样我们就可以唤醒特定颜色的 limit 最长等待线程，而不是随机等待线程.
免责声明：此 post 包含对以下答案所做的编辑，所有学分归其各自所有者所有。
我正在尝试解决一个问题，该问题指出资源可能被两种类型的线程使用。每种类型可以有更多线程。 （4 条白色螺纹和 6 条黑色螺纹）。任意数量的黑人可以同时使用该资源。白人也是如此。我仍然无法解决这个问题...
我尝试使用互斥体来实现它。我还想考虑到此实现可能存在的饥饿问题，因此我决定检查是否已达到某种类型的服务线程数，以允许其他类型工作。我似乎无法实施最新的。
我还想考虑到每当其他类型想要使用该资源时，它必须等待轮到它，以及其他类型来完成使用该资源。
编辑：我尝试使用 @Nominal-Animal 的解决方案，但似乎有时也会出现这种死锁。此外，我将缺少的 turn 添加到结构中。现在，我有一些额外的问题：
- 这似乎是对的，但行不通，为什么？
- 为什么
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 编译的。
一般评论
sleep()几乎从来不是解决同步问题的正确方法。- 互斥体提供仅互斥。如果您需要比这更多的线程间协调，那么您应该选择不同类型的同步对象（有时信号量更合适），或者添加另一种类型（条件变量通常是互斥体的伴侣）。
- 将互斥锁和解锁拆分成不同的函数是有问题的风格。即使你必须这样做，至少更愿意设置一对平衡的函数来执行锁定和解锁。
一些细节
你的互斥体太多了，这给你带来了麻烦。我认为没有必要为您维护的不同类型的资源管理元数据维护单独的互斥体。您最多需要两个互斥体：一个用于保护组访问元数据（turn、pending、current 和 served），一个可能用于保护资源本身。任何线程都没有必要同时持有这两者，但您必须确保在没有适当互斥锁保护的情况下不会访问任何共享数据。
您应该使用条件变量来帮助调节对组访问元数据的访问。当轮到他们的组时，线程将等待 CV，而不是休眠。这将自然地与保护组访问元数据的互斥锁集成。
虽然实施这些更改需要进行一些重新设计，但结果在概念上会更简单，而且在实践中会更稳健。例如，take_resource() 中围绕已获取哪些互斥量的不确定性的问题将消失，因为首先只有一个互斥量将涉及该部分。
考虑以下对
OP 描述的规则不完整。例如，考虑这样一种情况：三个黑色线程拥有资源，一个白色线程等待资源，另一个黑色线程到达并希望获取资源。应该发生什么？如果黑线程总是获得资源，那么黑（或白）线程有可能饿死其他类型的线程。如果在可能的情况下立即将所有权更改为另一种类型，我们将失去跨同一类型线程的大部分并发优势；如果传入线程类型的分布大致均匀，可能 运行一次只使用一种类型的一个线程，所有线程都是顺序排列的！
有几种可能的解决方案。似乎符合 OP 的问题陈述的是在切换之前允许 Nblack 黑线程与资源 运行如果有人在等，轮到白人；在切换到黑人之前，最多 Nwhite 白人线程到 运行 与资源。 （时间限制，当相同类型的其他线程也可能抢占资源时的宽限期，可能是您在实践中实际使用的。）
我们可以用下面的结构来描述这种锁：
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 */
};
#define BWLOCK_INIT(whites, blacks) \
{ PTHREAD_MUTEX_INITIALIZER, \
{ PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER }, \
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { whites, blacks }, 0 \
}
lock 互斥量仅在检查字段时保留，而不是在资源访问期间保留。
(另请注意，虽然black最初为0，但当没有运行ners和waiters时，轮次会发生变化，因此无所谓。代码将完全按照如果初始 black 为 1，则相同。)
我们先看看释放bwlock，因为这是比较有趣的部分；它是控制转弯变化的原因。假设锁定和释放都有一个 isblack 参数（为 0 或 1）。如果释放线程是其颜色的最后一个，并且其他颜色的线程正在等待，它将改变轮次，并在其他颜色上广播 wait 条件变量以唤醒它们：
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] > 0)) {
/* Yes. It's their turn. */
if (bwl->black == black) {
bwl->black = !black;
/* Clear their started counter. */
bwl->started[!black] = 0;
}
/* Wake them all up. */
pthread_cond_broadcast(&(bwl->wait[!black]));
}
pthread_mutex_unlock(&(bwl->lock));
return;
}
获取 bwlock 更复杂。该限制仅在没有其他类型的线程在等待时适用（因为如果我们这样做，单一颜色的线程会在没有其他颜色的情况下死锁）。
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->black != black) {
bwl->black = black;
/* Clear started counter. */
bwl->started[black] = 0;
}
break;
}
/* Still our turn, and not too many started threads? */
if ((bwl->black == 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));
}
pthread_cond_wait(&(bwl->wait[black]), &(bwl->lock)) 释放锁并等待条件变量上的信号或广播。当收到信号时，它将在返回之前重新获取锁。 （在释放锁和等待条件变量时没有竞争 window；它在同一时间点以原子方式有效地发生。）
如果考虑上述逻辑，bwlock_unlock() 处理特定颜色的最后一个 运行ning 线程应该处理 "baton" 到另一个线程集的情况。 bwlock_lock() 确定线程是否可以 运行 使用资源，或者是否需要等待。它只会在没有其他颜色的线程 运行ning 或等待轮到它们时才改变轮次。
这是一个相当简单的方案，但您可能需要考虑几种情况才能理解其行为。
started 计数器在轮次更改时清零，并为在该轮次期间启动的每个线程递增。当它达到 limit 时，将不再启动该类型的线程；他们会等待轮到他们。
假设 limit 是 {3, 3}，每种类型有四个线程，它们基本上同时冲向 bwlock。假设抢锁的第一个线程是黑色的。前三个黑色线程将 运行 资源，一个黑色线程和四个白色线程将等待条件变量。当转弯时，三个白线到达 运行；一个白色，一个随机的，将重新等待直到下一个白色回合。
此外，正如 Craig Estey 在对 John Bollingers 回答的评论中指出的那样，这并不能保证同一类型线程之间的公平性。例如，如果 A 和 B 是同一类型，A 在轮到他们时多次访问受 bwlock 保护的资源，而 B 只访问一次，则 B 可能必须无限期地等待才能轮到，因为 A "hogs" 所有插槽。
为了保证公平，我们需要某种票证锁或有序等待队列，这样我们就可以唤醒特定颜色的 limit 最长等待线程，而不是随机等待线程.