权重一致时，各队列任务不需要排队等候；权重一致时，各队列任务需要排队等候；各队列任务需要排队等候执行时，动态调整各任务权重，使用多级反馈队列调度算法，C语言实现

首先，这里的权重是指任务的优先级，不同的任务具有不同的优先级。当各任务的优先级权重一致时，各队列任务不需要排队等候，可以直接并发执行。

但是，当各队列任务的优先级权重不一致时，需要进行排队等候。排队等候的方式可以使用多级反馈队列调度算法，该算法可以根据任务的执行情况动态调整任务的优先级。

多级反馈队列调度算法是一种常见的调度算法，它将任务按照优先级分成多个队列，然后按照一定的规则调度任务。具体实现中，可以使用C语言编写一个多级反馈队列调度算法的程序，实现任务的排队等候和动态调整任务优先级的功能。

下面是一个简单的C语言实现多级反馈队列调度算法的代码示例：

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

#define MAX_QUEUE_NUM 3
#define MAX_TASK_NUM 10

// 任务结构体
typedef struct Task {
    int id; // 任务ID
    int priority; // 任务优先级
    int queue; // 任务所在队列
} Task;

// 队列结构体
typedef struct Queue {
    Task *tasks[MAX_TASK_NUM]; // 任务指针数组
    int front; // 队头指针
    int rear; // 队尾指针
} Queue;

Queue queues[MAX_QUEUE_NUM]; // 队列数组

// 初始化队列
void initQueue(Queue *queue) {
    queue->front = queue->rear = 0;
    for (int i = 0; i < MAX_TASK_NUM; i++) {
        queue->tasks[i] = NULL;
    }
}

// 入队操作
void enqueue(Task *task) {
    Queue *queue = &queues[task->queue];
    if (queue->rear == MAX_TASK_NUM) {
        printf("Queue %d is full\n", task->queue);
        return;
    }
    queue->tasks[queue->rear++] = task;
}

// 出队操作
Task *dequeue(Queue *queue) {
    if (queue->front == queue->rear) {
        return NULL;
    }
    Task *task = queue->tasks[queue->front++];
    queue->tasks[queue->front - 1] = NULL;
    return task;
}

// 动态调整任务优先级
void adjustPriority(Task *task, int newPriority) {
    if (task->priority != newPriority) {
        printf("Task %d priority adjusted from %d to %d\n", task->id, task->priority, newPriority);
        task->priority = newPriority;
        enqueue(task);
    }
}

// 多级反馈队列调度算法
void schedule() {
    for (int i = 0; i < MAX_QUEUE_NUM; i++) {
        Queue *queue = &queues[i];
        while (queue->front != queue->rear) {
            Task *task = dequeue(queue);
            if (task != NULL) {
                printf("Task %d in queue %d execute\n", task->id, task->queue);
                if (task->queue < MAX_QUEUE_NUM - 1) {
                    adjustPriority(task, task->priority + 1);
                } else {
                    printf("Task %d execute finished\n", task->id);
                }
            }
        }
    }
}

int main() {
    // 初始化队列
    for (int i = 0; i < MAX_QUEUE_NUM; i++) {
        initQueue(&queues[i]);
    }

    // 初始化任务
    Task tasks[MAX_TASK_NUM];
    for (int i = 0; i < MAX_TASK_NUM; i++) {
        tasks[i].id = i;
        tasks[i].priority = rand() % MAX_QUEUE_NUM;
        tasks[i].queue = tasks[i].priority;
        enqueue(&tasks[i]);
    }

    // 调度任务
    schedule();

    return 0;
}

在上面的代码中，我们定义了一个Task结构体和一个Queue结构体，分别用来表示任务和队列。然后，我们定义了一个全局的队列数组queues，其中包含了多个队列，每个队列包含了多个任务。

在程序的主函数中，我们首先初始化了队列和任务，然后调用了schedule函数，该函数实现了多级反馈队列调度算法的核心逻辑。

在schedule函数中，我们首先遍历所有队列，然后从当前队列中取出一个任务进行执行。如果任务的优先级小于最大优先级，那么我们就将其优先级加1，并将其加入到下一个更高优先级的队列中。否则，我们就认为该任务执行完成，可以从队列中删除。

在多级反馈队列调度算法中，如果某个任务的执行时间过长，会导致其优先级不断降低，最终被放到最低优先级的队列中，从而避免了长时间占用CPU资源的问题。