场景中有4张加密卡，当队列任务较少，不需要排队时，4张加密卡依序执行任务且不能空闲；当队列任务较多，需要排队时，动态调整各队列任务权重；对于某一张加密卡，只有一个队列任务执行完了才处理下一个任务。 C语言实现

以下是基于你的问题描述的C语言实现示例：

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

#define NUM_CARDS 4
#define MAX_TASKS 100

typedef struct {
    int id; // 任务id
    int weight; // 任务权重
} Task;

typedef struct {
    Task tasks[MAX_TASKS]; // 队列任务列表
    int num_tasks; // 队列任务数量
    int next_task; // 下一个要执行的任务索引
    pthread_mutex_t mutex; // 互斥锁
    pthread_cond_t cond; // 条件变量
} TaskQueue;

typedef struct {
    int id; // 加密卡id
    TaskQueue *task_queue; // 加密卡对应的任务队列
} Card;

void *card_thread(void *arg) {
    Card *card = (Card *)arg;
    TaskQueue *task_queue = card->task_queue;
    while (1) {
        pthread_mutex_lock(&task_queue->mutex);
        while (task_queue->next_task >= task_queue->num_tasks) { // 等待任务
            pthread_cond_wait(&task_queue->cond, &task_queue->mutex);
        }
        Task task = task_queue->tasks[task_queue->next_task];
        ++task_queue->next_task;
        pthread_mutex_unlock(&task_queue->mutex);
        printf("Card %d: executing task %d with weight %d\n", card->id, task.id, task.weight);
        sleep(task.weight); // 模拟执行任务的时间
    }
    return NULL;
}

void add_task(TaskQueue *task_queue, int weight) {
    pthread_mutex_lock(&task_queue->mutex);
    task_queue->tasks[task_queue->num_tasks].id = task_queue->num_tasks + 1;
    task_queue->tasks[task_queue->num_tasks].weight = weight;
    ++task_queue->num_tasks;
    if (task_queue->num_tasks <= NUM_CARDS) { // 当任务量不多时，让每张加密卡都有任务执行
        task_queue->next_task = task_queue->num_tasks - 1;
    } else { // 当任务量较多时，动态调整任务权重
        int total_weight = 0;
        for (int i = 0; i < task_queue->num_tasks; ++i) {
            total_weight += task_queue->tasks[i].weight;
        }
        int avg_weight = total_weight / NUM_CARDS;
        int num_high_weight_tasks = task_queue->num_tasks - task_queue->next_task;
        int num_low_weight_tasks = task_queue->num_tasks - num_high_weight_tasks;
        int target_num_high_weight_tasks = NUM_CARDS - num_low_weight_tasks;
        int high_weight_task_weight = total_weight - avg_weight * num_low_weight_tasks;
        int target_high_weight_task_weight = high_weight_task_weight / target_num_high_weight_tasks;
        int delta_weight = target_high_weight_task_weight - task_queue->tasks[task_queue->next_task].weight;
        if (delta_weight > 0) {
            task_queue->tasks[task_queue->next_task].weight += delta_weight;
        }
    }
    pthread_cond_signal(&task_queue->cond); // 唤醒等待任务的加密卡线程
    pthread_mutex_unlock(&task_queue->mutex);
}

int main() {
    TaskQueue task_queue = {
        .num_tasks = 0,
        .next_task = 0,
        .mutex = PTHREAD_MUTEX_INITIALIZER,
        .cond = PTHREAD_COND_INITIALIZER
    };
    Card cards[NUM_CARDS];
    for (int i = 0; i < NUM_CARDS; ++i) {
        cards[i].id = i + 1;
        cards[i].task_queue = &task_queue;
        pthread_t tid;
        pthread_create(&tid, NULL, card_thread, &cards[i]);
    }

    // 添加一些任务进行测试
    add_task(&task_queue, 5);
    add_task(&task_queue, 3);
    add_task(&task_queue, 4);
    add_task(&task_queue, 2);
    add_task(&task_queue, 1);
    add_task(&task_queue, 7);

    sleep(10); // 模拟一些任务执行时间
    add_task(&task_queue, 6); // 添加一个新任务

    pthread_exit(NULL);
}

这个实现中，定义了`Task`结构体来表示任务，`TaskQueue`结构体来表示任务队列，`Card`结构体来表示加密卡。`card_thread`函数是卡片线程的入口函数，它会不断地从任务队列中取出任务并执行。`add_task`函数用于向任务队列中添加任务，并根据当前队列任务数量和加密卡数量动态调整任务权重。

在`main`函数中，首先创建了4个加密卡线程，并将它们对应的任务队列指针传入`Card`结构体中。然后添加了一些任务进行测试，其中任务的权重值代表了任务执行的时间。最后等待一段时间后，再添加了一个新任务。

在任务队列的实现中，使用了互斥锁和条件变量来保证多个卡片线程之间的同步与互斥。当任务队列中没有任务时，卡片线程会通过条件变量等待任务的到来。

当队列任务较少时，每张加密卡都会有任务执行。当队列任务较多时，任务队列会根据当前任务数量和加密卡数量动态调整任务权重，根据权重分配队列任务。对于某一张加密卡，只有一个队列任务执行完了才处理下一个任务。