C语言实现WFQ算法，将这个项目编程三个例程，“发送者”、“接收者”和“路由器”。使用FlowID=1、权重=1和数据包大小1024启动发送端。几秒钟后，使用FlowID=2、权重=1和数据包大小512启动另一个发送器。再过几秒钟，使用FlowID=3、权重=2和数据包大小1024启动第三个发送方。接收者负责数据统计的部分，每次完成一个数据包时记录时间、流ID和数据包的大小。

好的，这是一个比较具体的项目需求，需要用到C语言实现WFQ算法，并编写发送者、接收者和路由器三个例程。我可以向您解释这些算法和程序的实现方法，但是不具备实现的能力，您需要自己完成编程。

首先，WFQ算法是一种基于权重的公平队列调度算法，可以保证不同流量的数据包在网络中传输时受到公平的待遇。实现WFQ算法时，需要维护多个队列，每个队列对应一个流ID，并按照权重分配一定的带宽。数据包到达路由器后，根据其流ID将其插入到相应的队列中，并按照队列中的权重比例进行调度。

对于发送者和接收者，需要编写程序模拟数据包的发送和接收过程。发送者需要根据要求生成具有不同流ID、权重和数据包大小的数据包，并将其发送给路由器。接收者需要接收数据包，并对其进行统计，记录每个数据包的流ID、大小和接收时间。

对于路由器的实现，可以参考下面的示例代码：

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

#define MAX_QUEUE_NUM 3           //最大队列数
#define MAX_PACKET_NUM 100        //最大数据包数
#define MAX_PACKET_SIZE 1024      //最大数据包大小
#define MAX_WEIGHT 2              //最大权重
#define MAX_ARRIVAL_INTERVAL 3    //最大到达时间间隔
#define MAX_SERVICE_INTERVAL 3    //最大服务时间间隔

//数据包结构体
typedef struct packet {
    int flowID;     //流ID
    int weight;     //权重
    int size;       //数据包大小
    time_t arrivalTime;     //到达时间
    time_t serviceTime;     //服务时间
} Packet;

//队列结构体
typedef struct queue {
    int flowID;     //流ID
    int weight;     //权重
    int head;       //队头
    int tail;       //队尾
    int count;      //队列长度
    Packet* packets[MAX_PACKET_NUM];    //队列中的数据包
} Queue;

int queueNum = 0;           //队列数量
Queue* queues[MAX_QUEUE_NUM];   //队列数组

//初始化队列
void initQueue(int flowID, int weight) {
    Queue* queue = (Queue*)malloc(sizeof(Queue));
    queue->flowID = flowID;
    queue->weight = weight;
    queue->head = 0;
    queue->tail = 0;
    queue->count = 0;
    for (int i = 0; i < MAX_PACKET_NUM; i++) {
        queue->packets[i] = NULL;
    }
    queues[queueNum++] = queue;
}

//插入数据包到队列中
void enqueue(int flowID, int weight, int size) {
    int queueIndex = -1;
    for (int i = 0; i < queueNum; i++) {
        if (queues[i]->flowID == flowID && queues[i]->weight == weight) {
            queueIndex = i;
            break;
        }
    }
    if (queueIndex == -1) {
        initQueue(flowID, weight);
        queueIndex = queueNum - 1;
    }
    Queue* queue = queues[queueIndex];
    if (queue->count < MAX_PACKET_NUM) {
        Packet* packet = (Packet*)malloc(sizeof(Packet));
        packet->flowID = flowID;
        packet->weight = weight;
        packet->size = size;
        packet->arrivalTime = time(NULL);
        packet->serviceTime = 0;
        queue->packets[queue->tail++] = packet;
        queue->count++;
        queue->tail %= MAX_PACKET_NUM;
    }
}

//从队列中取出数据包
Packet* dequeue() {
    Packet* packet = NULL;
    int minArrivalTime = INT_MAX;
    int minServiceTime = INT_MAX;
    int minQueueIndex = -1;
    for (int i = 0; i < queueNum; i++) {
        Queue* queue = queues[i];
        if (queue->count > 0) {
            Packet* p = queue->packets[queue->head];
            if (p->arrivalTime < minArrivalTime ||
                    (p->arrivalTime == minArrivalTime && p->serviceTime < minServiceTime)) {
                minArrivalTime = p->arrivalTime;
                minServiceTime = p->serviceTime;
                minQueueIndex = i;
                packet = p;
            }
        }
    }
    if (packet != NULL) {
        Queue* queue = queues[minQueueIndex];
        queue->packets[queue->head++] = NULL;
        queue->count--;
        queue->head %= MAX_PACKET_NUM;
    }
    return packet;
}

//发送者
void sender(int flowID, int weight, int size) {
    while (1) {
        enqueue(flowID, weight, size);
        sleep(rand() % MAX_ARRIVAL_INTERVAL + 1);
    }
}

//接收者
void receiver() {
    int packetCount = 0;
    while (1) {
        Packet* packet = dequeue();
        if (packet != NULL) {
            packet->serviceTime = time(NULL);
            printf("Packet %d: flowID=%d, size=%d, arrivalTime=%ld, serviceTime=%ld\n",
                   ++packetCount, packet->flowID, packet->size, packet->arrivalTime, packet->serviceTime);
            free(packet);
        }
    }
}

int main() {
    srand(time(NULL));
    initQueue(1, 1);
    initQueue(2, 1);
    initQueue(3, 2);
    //启动三个发送者
    int pid1 = fork();
    if (pid1 == 0) {
        sender(1, 1, 1024);
    }
    int pid2 = fork();
    if (pid2 == 0) {
        sleep(5);
        sender(2, 1, 512);
    }
    int pid3 = fork();
    if (pid3 == 0) {
        sleep(10);
        sender(3, 2, 1024);
    }
    //启动接收者
    receiver();
    return 0;
}

以上是一个简单的WFQ算法实现的示例代码，可以根据需要进行修改和完善。其中，enqueue函数用于将数据包插入到相应的队列中，dequeue函数用于从队列中取出一个数据包进行传输。sender函数用于模拟数据包的发送过程，每次随机等待一定时间后生成一个数据包并插入到相应的队列中。receiver函数用于接收数据包，并对其进行统计，记录每个数据包的流ID、大小和接收时间。

请注意，以上示例仅供参考，具体实现需要根据具体需求进行修改和完善。