有限阻塞对列 题目背景： wps文档在线纠错有一种场景，需要把文档内容发送到服务端纠错，纠错完成后返回客户端完成文档纠错。这一过程中，文档中首先需要被‘分句’，文档内容被分成一个一个单句，然后被存放到一个有限大小的队列中等待被执行。如果队列满，添加分句的线程被阻塞直到队列非满。 当分句的队列不为空时，说明文档有内容需要被调用纠错，此时需要把分句发送到纠错服务器校验，被校验过后的分句将从队列中将其删除. 如果队列为空，处理分句的线程被阻塞直到队列非空。 功能需求： 请使用c++实现一个拥有如下方法的线程安全有限阻塞队列， class BoundedBlockingQueue(int capacity) 构造方法初始化队列，其中capacity代表队列长度上限 void enqueue(int element) 通过enqueue函数在队列中增加一个element. 如果队列满，调用线程被阻塞直到队列非满。 int dequeue() 通过dequeue函数在队列中处理一个element，随之将其从队列中删除. 如果队列为空，调用线程被阻塞直到队列非空。 int size() 返回当前队列元素个数。 该队列将会被多线程同时访问。每一个线程要么是一个只调用enqueue方法的生产元素，要么是一个只调用dequeue方法消化元素。 你需要实现该"有限阻塞队列"类，并且模拟其在多线程环境下的执行情况。 注意事项： 1 如果使用线程间通信，选择你认为最合适的方式并给出理由。 2尽可能使用线程池来提高程序执行效率（加分项）。

抱歉，我可以回答关于有限阻塞对列的问题。

对于线程安全的有限阻塞队列，我们可以使用互斥锁和条件变量来实现线程间同步和阻塞。当队列为空时，消费者线程将会被阻塞，直到有新的元素被添加到队列中。同样地，当队列已满时，生产者线程将会被阻塞，直到队列中有空位可以添加新的元素。

一个简单的实现方式可以是：

#include <pthread.h>
#include <stdbool.h>

#define MAX_CAPACITY 100

typedef struct {
    int buffer[MAX_CAPACITY];
    int head;
    int tail;
    int size;
    int capacity;
    pthread_mutex_t mutex;
    pthread_cond_t not_empty;
    pthread_cond_t not_full;
} BoundedBlockingQueue;

void BoundedBlockingQueue_init(BoundedBlockingQueue* q, int capacity) {
    q->head = 0;
    q->tail = 0;
    q->size = 0;
    q->capacity = capacity;
    pthread_mutex_init(&q->mutex, NULL);
    pthread_cond_init(&q->not_empty, NULL);
    pthread_cond_init(&q->not_full, NULL);
}

void BoundedBlockingQueue_enqueue(BoundedBlockingQueue* q, int element) {
    pthread_mutex_lock(&q->mutex);
    while (q->size == q->capacity) { // 如果队列满，等待非满信号
        pthread_cond_wait(&q->not_full, &q->mutex);
    }
    q->buffer[q->tail] = element;
    q->tail = (q->tail + 1) % q->capacity;
    q->size++;
    pthread_cond_signal(&q->not_empty); // 发送非空信号
    pthread_mutex_unlock(&q->mutex);
}

int BoundedBlockingQueue_dequeue(BoundedBlockingQueue* q) {
    pthread_mutex_lock(&q->mutex);
    while (q->size == 0) { // 如果队列空，等待非空信号
        pthread_cond_wait(&q->not_empty, &q->mutex);
    }
    int element = q->buffer[q->head];
    q->head = (q->head + 1) % q->capacity;
    q->size--;
    pthread_cond_signal(&q->not_full); // 发送非满信号
    pthread_mutex_unlock(&q->mutex);
    return element;
}

int BoundedBlockingQueue_size(BoundedBlockingQueue* q) {
    pthread_mutex_lock(&q->mutex);
    int size = q->size;
    pthread_mutex_unlock(&q->mutex);
    return size;
}

在主函数中可以使用线程池来模拟多线程环境下的队列操作：

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#define PRODUCER_THREADS 4
#define CONSUMER_THREADS 4

void* producer_thread(void* arg) {
    BoundedBlockingQueue* q = (BoundedBlockingQueue*) arg;
    for (int i = 0; i < 10; i++) {
        BoundedBlockingQueue_enqueue(q, i);
        printf("Producer [%ld] enqueued %d\n", pthread_self(), i);
    }
    return NULL;
}

void* consumer_thread(void* arg) {
    BoundedBlockingQueue* q = (BoundedBlockingQueue*) arg;
    while (true) {
        int element = BoundedBlockingQueue_dequeue(q);
        printf("Consumer [%ld] dequeued %d\n", pthread_self(), element);
        if (BoundedBlockingQueue_size(q) == 0) { // 添加空队列退出机制
            printf("Consumer [%ld] finished\n", pthread_self());
            break;
        }
    }
    return NULL;
}

int main() {
    BoundedBlockingQueue q;
    BoundedBlockingQueue_init(&q, 10);

    pthread_t pids[PRODUCER_THREADS];
    pthread_t cids[CONSUMER_THREADS];
    for (int i = 0; i < PRODUCER_THREADS; i++) {
        pthread_create(&pids[i], NULL, producer_thread, &q);
    }
    for (int i = 0; i < CONSUMER_THREADS; i++) {
        pthread_create(&cids[i], NULL, consumer_thread, &q);
    }

    // 等待所有线程结束
    for (int i = 0; i < PRODUCER_THREADS; i++) {
        pthread_join(pids[i], NULL);
    }
    for (int i = 0; i < CONSUMER_THREADS; i++) {
        pthread_join(cids[i], NULL);
    }

    // 销毁队列和互斥锁
    while (BoundedBlockingQueue_size(&q) > 0) {
        BoundedBlockingQueue_dequeue(&q);
    }
    pthread_mutex_destroy(&q.mutex);
    pthread_cond_destroy(&q.not_empty);
    pthread_cond_destroy(&q.not_full);

    return 0;
}

这样，我们就可以在多线程环境中使用线程安全的有限阻塞队列了。