下面是一个使用 C
语言实现的简单
LinkedBlockingQueue 的示例代码：
```c
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <pthread.h>
typ
edef struct Node {
int data;
struct Node* next;
} Node;
typ
edef struct {
Node* head;
Node* tail;
int size;
int capacity;
pthread_mutex_t mutex;
pthread_cond_t notEmpty;
pthread_cond_t notFull;
}
LinkedBlockingQueue;
LinkedBlockingQueue* create
Queue(int capacity) {
LinkedBlockingQueue*
queue = (
LinkedBlockingQueue*)malloc(sizeof(
LinkedBlockingQueue));
queue->head = NULL;
queue->tail = NULL;
queue->size = 0;
queue->capacity = capacity;
pthread_mutex_init(&
queue->mutex, NULL);
pthread_cond_init(&
queue->notEmpty, NULL);
pthread_cond_init(&
queue->notFull, NULL);
return
queue;
}
void en
queue(
LinkedBlockingQueue*
queue, int value) {
pthread_mutex_lock(&
queue->mutex);
while (
queue->size ==
queue->capacity) {
pthread_cond_wait(&
queue->notFull, &
queue->mutex);
}
Node* newNode = (Node*)malloc(sizeof(Node));
newNode->data = value;
newNode->next = NULL;
if (
queue->head == NULL) {
queue->head = newNode;
queue->tail = newNode;
} else {
queue->tail->next = newNode;
queue->tail = newNode;
}
queue->size++;
pthread_cond_signal(&
queue->notEmpty);
pthread_mutex_unlock(&
queue->mutex);
}
int de
queue(
LinkedBlockingQueue*
queue) {
pthread_mutex_lock(&
queue->mutex);
while (
queue->size == 0) {
pthread_cond_wait(&
queue->notEmpty, &
queue->mutex);
}
Node* node =
queue->head;
int value = node->data;
if (
queue->head ==
queue->tail) {
queue->head = NULL;
queue->tail = NULL;
} else {
queue->head =
queue->head->next;
}
free(node);
queue->size--;
pthread_cond_signal(&
queue->notFull);
pthread_mutex_unlock(&
queue->mutex);
return value;
}
void destroy
Queue(
LinkedBlockingQueue*
queue) {
pthread_mutex_destroy(&
queue->mutex);
pthread_cond_destroy(&
queue->notEmpty);
pthread_cond_destroy(&
queue->notFull);
free(
queue);
}
int main() {
LinkedBlockingQueue*
queue = create
Queue(5);
en
queue(
queue, 1);
en
queue(
queue, 2);
en
queue(
queue, 3);
int value1 = de
queue(
queue);
int value2 = de
queue(
queue);
int value3 = de
queue(
queue);
printf("De
queued values: %d, %d, %d\n", value1, value2, value3);
destroy
Queue(
queue);
return 0;
}
```
这个示例代码使用了一个带有互斥锁和条件变量的结构体
LinkedBlockingQueue 来
实现一个带有阻塞特性的
队列。en
queue 函数用于向
队列中添加元素，如果
队列已满，则线程会阻塞，直到有空间可用。de
queue 函数用于从
队列中取出元素，如果
队列为空，则线程会阻塞，直到有元素可取。
在示例代码的主函数中，我们创建了一个容量为 5 的
队列，并进行了一些入队和出队操作。最后，我们销毁了
队列。
本文介绍了如何在Java中通过扩展LinkedBlockingQueue并重写add()和put()方法来实现去重功能。在添加元素时，首先检查队列中是否存在该元素，若存在则忽略，否则将其安全地添加到队列中，确保线程安全。
最低0.47元/天 解锁文章
376
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
