超硬核区块链算法仿真：联盟链PBFT多线程仿真实现 ：c语言完全详解版

small_wh1te_coder2025-03-21 11:15

1 22年年底想用gpt做出一个pbft的算法仿真，到了25年终于可以结合gpt grok perplexcity deepseek等实现了！！！！！

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <time.h>
#include <locale.h>

#define NODE_COUNT 500           // 节点数量
#define FAULT_TOLERANCE 166      // 容错节点数 (F ≈ (NODE_COUNT - 1) / 3)
#define REQUEST_COUNT 1000       // 总请求数
#define MAX_DELAY 100            // 最大网络延迟（毫秒）
#define MALICIOUS_RATE 0.1       // 作恶节点比例（10%）
#define DOWNTIME_RATE 0.1        // 宕机节点比例（10%）
#define DELAY_JITTER 0.1         // 延迟扰动因子（10%）

// 消息类型
typedef enum {
    MSG_PREPREPARE,
    MSG_PREPARE,
    MSG_COMMIT
} MsgType;

// 消息结构体
typedef struct Message {
    int request_id;         // 请求编号
    MsgType type;           // 消息类型
    int sender;             // 发送节点编号
    struct Message *next;   // 链表指针
} Message;

// 消息队列结构体（每个节点拥有一个消息队列）
typedef struct {
    Message *head;
    Message *tail;
    CRITICAL_SECTION cs;
    CONDITION_VARIABLE cv;
} MessageQueue;

// 初始化消息队列
void init_queue(MessageQueue *q) {
    q->head = q->tail = NULL;
    InitializeCriticalSection(&q->cs);
    InitializeConditionVariable(&q->cv);
}

// 入队操作
void enqueue(MessageQueue *q, Message *msg) {
    EnterCriticalSection(&q->cs);
    msg->next = NULL;
    if(q->tail == NULL) {
        q->head = q->tail = msg;
    } else {
        q->tail->next = msg;
        q->tail = msg;
    }
    WakeConditionVariable(&q->cv);
    LeaveCriticalSection(&q->cs);
}

// 出队操作（阻塞等待队列非空）
Message* dequeue(MessageQueue *q) {
    EnterCriticalSection(&q->cs);
    while(q->head == NULL) {
        SleepConditionVariableCS(&q->cv, &q->cs, INFINITE);
    }
    Message *msg = q->head;
    q->head = msg->next;
    if(q->head == NULL)
        q->tail = NULL;
    LeaveCriticalSection(&q->cs);
    return msg;
}

// 模拟网络延迟，返回延迟时间（毫秒）
double simulate_network_delay() {
    double base_delay = (rand() / (double)RAND_MAX) * MAX_DELAY;
    double jitter = (rand() / (double)RAND_MAX - 0.5) * 2 * DELAY_JITTER * base_delay;
    return base_delay + jitter;
}

// 节点结构体
typedef struct {
    int id;
    int is_primary;    // 是否为主节点（节点0为主）
    int is_malicious;  // 是否作恶
    int is_down;       // 是否宕机
} Node;

// 全局节点数组，用于在节点线程中判断状态
Node nodes_global[NODE_COUNT];

// 初始化节点
void init_nodes(Node *nodes) {
    for (int i = 0; i < NODE_COUNT; i++) {
        nodes[i].id = i;
        nodes[i].is_primary = (i == 0);
        nodes[i].is_malicious = (rand() / (double)RAND_MAX < MALICIOUS_RATE);
        nodes[i].is_down = (rand() / (double)RAND_MAX < DOWNTIME_RATE);
    }
    nodes[0].is_down = 0;  // 保证主节点始终正常
}

// 全局消息队列数组，每个节点一个队列
MessageQueue nodeQueues[NODE_COUNT];

// 节点线程函数（非主节点）
// 每个节点不断从自己的消息队列中取出消息并处理
DWORD WINAPI node_thread_proc(LPVOID param) {
    int node_id = *(int*)param;
    while (1) {
        Message *msg = dequeue(&nodeQueues[node_id]);
        // 终止信号：request_id == -1 且 type == -1
        if (msg->request_id == -1 && msg->type == (MsgType)-1) {
            free(msg);
            break;
        }
        // 如果该节点正常且不作恶，处理消息
        if (!nodes_global[node_id].is_down && !nodes_global[node_id].is_malicious) {
            if (msg->type == MSG_PREPREPARE) {
                // 模拟实际延时等待
                Sleep((int)simulate_network_delay());
                // 发送 PREPARE 消息给主节点（节点0）
                Message *reply = (Message*)malloc(sizeof(Message));
                reply->request_id = msg->request_id;
                reply->type = MSG_PREPARE;
                reply->sender = node_id;
                enqueue(&nodeQueues[0], reply);
            } else if (msg->type == MSG_COMMIT) {
                Sleep((int)simulate_network_delay());
                // 发送 COMMIT 消息给主节点
                Message *reply = (Message*)malloc(sizeof(Message));
                reply->request_id = msg->request_id;
                reply->type = MSG_COMMIT;
                reply->sender = node_id;
                enqueue(&nodeQueues[0], reply);
            }
        }
        free(msg);
    }
    return 0;
}

int main() {
    // 设置控制台编码和区域以支持中文输出
    SetConsoleOutputCP(CP_UTF8);
    setlocale(LC_ALL, "zh_CN.UTF-8");
    srand((unsigned int)time(NULL));
    
    // 初始化节点
    Node nodes[NODE_COUNT];
    init_nodes(nodes);
    for (int i = 0; i < NODE_COUNT; i++) {
        nodes_global[i] = nodes[i];
    }
    
    // 初始化每个节点的消息队列
    for (int i = 0; i < NODE_COUNT; i++) {
        init_queue(&nodeQueues[i]);
    }
    
    // 创建非主节点线程（节点 1 到 NODE_COUNT-1）
    HANDLE nodeThreads[NODE_COUNT - 1];
    int nodeIds[NODE_COUNT - 1];
    for (int i = 1; i < NODE_COUNT; i++) {
        nodeIds[i - 1] = i;
        nodeThreads[i - 1] = CreateThread(NULL, 0, node_thread_proc, &nodeIds[i - 1], 0, NULL);
    }
    
    int threshold = 2 * FAULT_TOLERANCE + 1;
    double total_latency = 0.0;
    int successful_requests = 0;
    
    // 主节点处理请求（模拟 REQUEST_COUNT 个请求）
    for (int req = 0; req < REQUEST_COUNT; req++) {
        // 发送 Pre-Prepare 消息到所有非主节点
        for (int i = 1; i < NODE_COUNT; i++) {
            Message *msg = (Message*)malloc(sizeof(Message));
            msg->request_id = req;
            msg->type = MSG_PREPREPARE;
            msg->sender = 0;
            enqueue(&nodeQueues[i], msg);
        }
        // 主节点自身执行 Pre-Prepare 阶段延迟
        Sleep((int)simulate_network_delay());
        
        DWORD req_start = GetTickCount();
        
        // 收集 Prepare 消息
        int prepareCount = 0;
        while (prepareCount < threshold) {
            Message *msg = dequeue(&nodeQueues[0]);
            if (msg->request_id == req && msg->type == MSG_PREPARE) {
                prepareCount++;
            }
            free(msg);
        }
        
        // 发送 Commit 消息到所有非主节点
        for (int i = 1; i < NODE_COUNT; i++) {
            Message *msg = (Message*)malloc(sizeof(Message));
            msg->request_id = req;
            msg->type = MSG_COMMIT;
            msg->sender = 0;
            enqueue(&nodeQueues[i], msg);
        }
        Sleep((int)simulate_network_delay());
        
        // 收集 Commit 消息
        int commitCount = 0;
        while (commitCount < threshold) {
            Message *msg = dequeue(&nodeQueues[0]);
            if (msg->request_id == req && msg->type == MSG_COMMIT) {
                commitCount++;
            }
            free(msg);
        }
        
        DWORD req_end = GetTickCount();
        double req_latency = req_end - req_start;  // 单位：毫秒
        total_latency += req_latency;
        successful_requests++;
        printf("请求 %d 共识成功，延迟: %.2f 毫秒\n", req, req_latency);
    }
    
    // 发送终止信号给所有非主节点
    for (int i = 1; i < NODE_COUNT; i++) {
        Message *term = (Message*)malloc(sizeof(Message));
        term->request_id = -1;
        term->type = (MsgType)-1;
        term->sender = -1;
        enqueue(&nodeQueues[i], term);
    }
    WaitForMultipleObjects(NODE_COUNT - 1, nodeThreads, TRUE, INFINITE);
    
    double avg_latency = (successful_requests > 0) ? total_latency / successful_requests : 0.0;
    printf("\n=== 性能指标 ===\n");
    printf("总请求数: %d\n", REQUEST_COUNT);
    printf("成功请求数: %d\n", successful_requests);
    printf("平均延迟: %.2f 毫秒\n", avg_latency);
    printf("共识成功率: %.2f%%\n", (successful_requests / (double)REQUEST_COUNT) * 100);
    
    return 0;
}

2 以下是调试和运行结果：

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <time.h>
#include <locale.h>

#define NODE_COUNT 500           // 节点数量
#define FAULT_TOLERANCE 166      // 容错节点数 (F ≈ (NODE_COUNT - 1) / 3)
#define REQUEST_COUNT 1000       // 总请求数
#define MAX_DELAY 100            // 最大网络延迟（毫秒）
#define MALICIOUS_RATE 0.1       // 作恶节点比例（10%）
#define DOWNTIME_RATE 0.1        // 宕机节点比例（10%）
#define DELAY_JITTER 0.1         // 延迟扰动因子（10%）

// 消息类型
typedef enum {
    MSG_PREPREPARE,
    MSG_PREPARE,
    MSG_COMMIT
} MsgType;

// 消息结构体
typedef struct Message {
    int request_id;         // 请求编号
    MsgType type;           // 消息类型
    int sender;             // 发送节点编号
    struct Message *next;   // 链表指针
} Message;

// 消息队列结构体（每个节点拥有一个消息队列）
typedef struct {
    Message *head;
    Message *tail;
    CRITICAL_SECTION cs;
    CONDITION_VARIABLE cv;
} MessageQueue;

// 初始化消息队列
void init_queue(MessageQueue *q) {
    q->head = q->tail = NULL;
    InitializeCriticalSection(&q->cs);
    InitializeConditionVariable(&q->cv);
}

// 入队操作
void enqueue(MessageQueue *q, Message *msg) {
    EnterCriticalSection(&q->cs);
    msg->next = NULL;
    if(q->tail == NULL) {
        q->head = q->tail = msg;
    } else {
        q->tail->next = msg;
        q->tail = msg;
    }
    WakeConditionVariable(&q->cv);
    LeaveCriticalSection(&q->cs);
}

// 出队操作（阻塞等待队列非空）
Message* dequeue(MessageQueue *q) {
    EnterCriticalSection(&q->cs);
    while(q->head == NULL) {
        SleepConditionVariableCS(&q->cv, &q->cs, INFINITE);
    }
    Message *msg = q->head;
    q->head = msg->next;
    if(q->head == NULL)
        q->tail = NULL;
    LeaveCriticalSection(&q->cs);
    return msg;
}

// 模拟网络延迟，返回延迟时间（毫秒）
double simulate_network_delay() {
    double base_delay = (rand() / (double)RAND_MAX) * MAX_DELAY;
    double jitter = (rand() / (double)RAND_MAX - 0.5) * 2 * DELAY_JITTER * base_delay;
    return base_delay + jitter;
}

// 节点结构体
typedef struct {
    int id;
    int is_primary;    // 是否为主节点（节点0为主）
    int is_malicious;  // 是否作恶
    int is_down;       // 是否宕机
} Node;

// 全局节点数组，用于在节点线程中判断状态
Node nodes_global[NODE_COUNT];

// 初始化节点
void init_nodes(Node *nodes) {
    for (int i = 0; i < NODE_COUNT; i++) {
        nodes[i].id = i;
        nodes[i].is_primary = (i == 0);
        nodes[i].is_malicious = (rand() / (double)RAND_MAX < MALICIOUS_RATE);
        nodes[i].is_down = (rand() / (double)RAND_MAX < DOWNTIME_RATE);
    }
    nodes[0].is_down = 0;  // 保证主节点始终正常
}

// 全局消息队列数组，每个节点一个队列
MessageQueue nodeQueues[NODE_COUNT];

// 节点线程函数（非主节点）
// 每个节点不断从自己的消息队列中取出消息并处理
DWORD WINAPI node_thread_proc(LPVOID param) {
    int node_id = *(int*)param;
    while (1) {
        Message *msg = dequeue(&nodeQueues[node_id]);
        // 终止信号：request_id == -1 且 type == -1
        if (msg->request_id == -1 && msg->type == (MsgType)-1) {
            free(msg);
            break;
        }
        // 如果该节点正常且不作恶，处理消息
        if (!nodes_global[node_id].is_down && !nodes_global[node_id].is_malicious) {
            if (msg->type == MSG_PREPREPARE) {
                // 模拟实际延时等待
                Sleep((int)simulate_network_delay());
                // 发送 PREPARE 消息给主节点（节点0）
                Message *reply = (Message*)malloc(sizeof(Message));
                reply->request_id = msg->request_id;
                reply->type = MSG_PREPARE;
                reply->sender = node_id;
                enqueue(&nodeQueues[0], reply);
            } else if (msg->type == MSG_COMMIT) {
                Sleep((int)simulate_network_delay());
                // 发送 COMMIT 消息给主节点
                Message *reply = (Message*)malloc(sizeof(Message));
                reply->request_id = msg->request_id;
                reply->type = MSG_COMMIT;
                reply->sender = node_id;
                enqueue(&nodeQueues[0], reply);
            }
        }
        free(msg);
    }
    return 0;
}

int main() {
    // 设置控制台编码和区域以支持中文输出
    SetConsoleOutputCP(CP_UTF8);
    setlocale(LC_ALL, "zh_CN.UTF-8");
    srand((unsigned int)time(NULL));
    
    // 初始化节点
    Node nodes[NODE_COUNT];
    init_nodes(nodes);
    for (int i = 0; i < NODE_COUNT; i++) {
        nodes_global[i] = nodes[i];
    }
    
    // 初始化每个节点的消息队列
    for (int i = 0; i < NODE_COUNT; i++) {
        init_queue(&nodeQueues[i]);
    }
    
    // 创建非主节点线程（节点 1 到 NODE_COUNT-1）
    HANDLE nodeThreads[NODE_COUNT - 1];
    int nodeIds[NODE_COUNT - 1];
    for (int i = 1; i < NODE_COUNT; i++) {
        nodeIds[i - 1] = i;
        nodeThreads[i - 1] = CreateThread(NULL, 0, node_thread_proc, &nodeIds[i - 1], 0, NULL);
    }
    
    int threshold = 2 * FAULT_TOLERANCE + 1;
    double total_latency = 0.0;
    int successful_requests = 0;
    
    // 主节点处理请求（模拟 REQUEST_COUNT 个请求）
    for (int req = 0; req < REQUEST_COUNT; req++) {
        // 发送 Pre-Prepare 消息到所有非主节点
        for (int i = 1; i < NODE_COUNT; i++) {
            Message *msg = (Message*)malloc(sizeof(Message));
            msg->request_id = req;
            msg->type = MSG_PREPREPARE;
            msg->sender = 0;
            enqueue(&nodeQueues[i], msg);
        }
        // 主节点自身执行 Pre-Prepare 阶段延迟
        Sleep((int)simulate_network_delay());
        
        DWORD req_start = GetTickCount();
        
        // 收集 Prepare 消息
        int prepareCount = 0;
        while (prepareCount < threshold) {
            Message *msg = dequeue(&nodeQueues[0]);
            if (msg->request_id == req && msg->type == MSG_PREPARE) {
                prepareCount++;
            }
            free(msg);
        }
        
        // 发送 Commit 消息到所有非主节点
        for (int i = 1; i < NODE_COUNT; i++) {
            Message *msg = (Message*)malloc(sizeof(Message));
            msg->request_id = req;
            msg->type = MSG_COMMIT;
            msg->sender = 0;
            enqueue(&nodeQueues[i], msg);
        }
        Sleep((int)simulate_network_delay());
        
        // 收集 Commit 消息
        int commitCount = 0;
        while (commitCount < threshold) {
            Message *msg = dequeue(&nodeQueues[0]);
            if (msg->request_id == req && msg->type == MSG_COMMIT) {
                commitCount++;
            }
            free(msg);
        }
        
        DWORD req_end = GetTickCount();
        double req_latency = req_end - req_start;  // 单位：毫秒
        total_latency += req_latency;
        successful_requests++;
        printf("请求 %d 共识成功，延迟: %.2f 毫秒\n", req, req_latency);
    }
    
    // 发送终止信号给所有非主节点
    for (int i = 1; i < NODE_COUNT; i++) {
        Message *term = (Message*)malloc(sizeof(Message));
        term->request_id = -1;
        term->type = (MsgType)-1;
        term->sender = -1;
        enqueue(&nodeQueues[i], term);
    }
    WaitForMultipleObjects(NODE_COUNT - 1, nodeThreads, TRUE, INFINITE);
    
    double avg_latency = (successful_requests > 0) ? total_latency / successful_requests : 0.0;
    printf("\n=== 性能指标 ===\n");
    printf("总请求数: %d\n", REQUEST_COUNT);
    printf("成功请求数: %d\n", successful_requests);
    printf("平均延迟: %.2f 毫秒\n", avg_latency);
    printf("共识成功率: %.2f%%\n", (successful_requests / (double)REQUEST_COUNT) * 100);
    
    return 0;
}




PS D:\software\vscode c coding folder\8pbft模拟> cd "d:\software\vscode c coding folder\8pbft模拟\" ; if ($?) { gcc 22pbftGrokImpByGpt.c -o 22pbftGrokImpByGpt } ; if ($?) { .\22pbftGrokImpByGpt }
22pbftGrokImpByGpt.c: In function 'init_queue':
22pbftGrokImpByGpt.c:42:5: warning: implicit declaration of function 'InitializeConditionVariable'; did you mean 'InitializeContext'? [-Wimplicit-function-declaration]
     InitializeConditionVariable(&q->cv);
     ^~~~~~~~~~~~~~~~~~~~~~~~~~~
     InitializeContext
22pbftGrokImpByGpt.c: In function 'enqueue':
22pbftGrokImpByGpt.c:55:5: warning: implicit declaration of function 'WakeConditionVariable' [-Wimplicit-function-declaration]
     WakeConditionVariable(&q->cv);
     ^~~~~~~~~~~~~~~~~~~~~
22pbftGrokImpByGpt.c: In function 'dequeue':
22pbftGrokImpByGpt.c:63:9: warning: implicit declaration of function 'SleepConditionVariableCS' [-Wimplicit-function-declaration]
         SleepConditionVariableCS(&q->cv, &q->cs, INFINITE);  
         ^~~~~~~~~~~~~~~~~~~~~~~~
请求 0 共识成功，延迟: 94.00 毫秒
请求 1 共识成功，延迟: 110.00 毫秒
请求 2 共识成功，延迟: 172.00 毫秒
请求 3 共识成功，延迟: 62.00 毫秒
请求 4 共识成功，延迟: 31.00 毫秒
请求 5 共识成功，延迟: 109.00 毫秒
请求 6 共识成功，延迟: 94.00 毫秒
请求 7 共识成功，延迟: 94.00 毫秒
请求 8 共识成功，延迟: 63.00 毫秒
请求 9 共识成功，延迟: 94.00 毫秒
请求 10 共识成功，延迟: 188.00 毫秒
请求 11 共识成功，延迟: 110.00 毫秒
请求 12 共识成功，延迟: 157.00 毫秒
请求 13 共识成功，延迟: 188.00 毫秒
请求 14 共识成功，延迟: 78.00 毫秒
请求 15 共识成功，延迟: 93.00 毫秒
请求 16 共识成功，延迟: 63.00 毫秒
请求 17 共识成功，延迟: 94.00 毫秒
请求 18 共识成功，延迟: 94.00 毫秒
请求 19 共识成功，延迟: 63.00 毫秒
请求 20 共识成功，延迟: 78.00 毫秒
请求 21 共识成功，延迟: 63.00 毫秒
请求 22 共识成功，延迟: 94.00 毫秒
请求 23 共识成功，延迟: 31.00 毫秒
请求 24 共识成功，延迟: 78.00 毫秒
请求 25 共识成功，延迟: 93.00 毫秒
请求 26 共识成功，延迟: 78.00 毫秒
请求 27 共识成功，延迟: 187.00 毫秒
请求 28 共识成功，延迟: 46.00 毫秒
请求 29 共识成功，延迟: 125.00 毫秒
请求 30 共识成功，延迟: 47.00 毫秒
请求 31 共识成功，延迟: 125.00 毫秒
请求 32 共识成功，延迟: 109.00 毫秒
请求 33 共识成功，延迟: 78.00 毫秒
请求 34 共识成功，延迟: 187.00 毫秒
请求 35 共识成功，延迟: 110.00 毫秒
请求 36 共识成功，延迟: 110.00 毫秒
请求 37 共识成功，延迟: 78.00 毫秒
请求 38 共识成功，延迟: 156.00 毫秒
请求 39 共识成功，延迟: 78.00 毫秒
请求 40 共识成功，延迟: 110.00 毫秒
请求 41 共识成功，延迟: 125.00 毫秒
请求 42 共识成功，延迟: 94.00 毫秒
请求 43 共识成功，延迟: 79.00 毫秒
请求 44 共识成功，延迟: 109.00 毫秒
请求 45 共识成功，延迟: 63.00 毫秒
请求 46 共识成功，延迟: 172.00 毫秒
请求 47 共识成功，延迟: 62.00 毫秒
请求 48 共识成功，延迟: 156.00 毫秒
请求 49 共识成功，延迟: 78.00 毫秒
请求 50 共识成功，延迟: 62.00 毫秒
请求 51 共识成功，延迟: 63.00 毫秒
请求 52 共识成功，延迟: 78.00 毫秒
请求 53 共识成功，延迟: 63.00 毫秒
请求 54 共识成功，延迟: 63.00 毫秒
请求 55 共识成功，延迟: 94.00 毫秒
请求 56 共识成功，延迟: 78.00 毫秒
请求 57 共识成功，延迟: 93.00 毫秒
请求 58 共识成功，延迟: 125.00 毫秒
请求 59 共识成功，延迟: 156.00 毫秒
请求 60 共识成功，延迟: 94.00 毫秒
请求 61 共识成功，延迟: 79.00 毫秒
请求 62 共识成功，延迟: 110.00 毫秒
请求 63 共识成功，延迟: 94.00 毫秒
请求 64 共识成功，延迟: 78.00 毫秒
请求 65 共识成功，延迟: 78.00 毫秒
请求 66 共识成功，延迟: 109.00 毫秒
请求 67 共识成功，延迟: 109.00 毫秒
请求 68 共识成功，延迟: 125.00 毫秒
请求 69 共识成功，延迟: 79.00 毫秒
请求 70 共识成功，延迟: 140.00 毫秒
请求 71 共识成功，延迟: 16.00 毫秒
请求 72 共识成功，延迟: 93.00 毫秒
请求 73 共识成功，延迟: 172.00 毫秒
请求 74 共识成功，延迟: 94.00 毫秒
请求 75 共识成功，延迟: 78.00 毫秒
请求 76 共识成功，延迟: 63.00 毫秒
请求 77 共识成功，延迟: 110.00 毫秒
请求 78 共识成功，延迟: 78.00 毫秒
请求 79 共识成功，延迟: 109.00 毫秒
请求 80 共识成功，延迟: 125.00 毫秒
请求 81 共识成功，延迟: 32.00 毫秒
请求 82 共识成功，延迟: 156.00 毫秒
请求 83 共识成功，延迟: 62.00 毫秒
请求 84 共识成功，延迟: 157.00 毫秒
请求 85 共识成功，延迟: 109.00 毫秒
请求 86 共识成功，延迟: 78.00 毫秒
请求 87 共识成功，延迟: 78.00 毫秒
请求 88 共识成功，延迟: 31.00 毫秒
请求 89 共识成功，延迟: 31.00 毫秒
请求 90 共识成功，延迟: 47.00 毫秒
请求 91 共识成功，延迟: 110.00 毫秒
请求 92 共识成功，延迟: 94.00 毫秒
请求 93 共识成功，延迟: 93.00 毫秒
请求 94 共识成功，延迟: 31.00 毫秒
请求 95 共识成功，延迟: 93.00 毫秒
请求 96 共识成功，延迟: 78.00 毫秒
请求 97 共识成功，延迟: 109.00 毫秒
请求 98 共识成功，延迟: 46.00 毫秒
请求 99 共识成功，延迟: 78.00 毫秒
请求 100 共识成功，延迟: 46.00 毫秒
请求 101 共识成功，延迟: 62.00 毫秒
请求 102 共识成功，延迟: 109.00 毫秒
请求 103 共识成功，延迟: 78.00 毫秒
请求 104 共识成功，延迟: 78.00 毫秒
请求 105 共识成功，延迟: 172.00 毫秒
请求 106 共识成功，延迟: 125.00 毫秒
请求 107 共识成功，延迟: 94.00 毫秒
请求 108 共识成功，延迟: 125.00 毫秒
请求 109 共识成功，延迟: 47.00 毫秒
请求 110 共识成功，延迟: 62.00 毫秒
请求 111 共识成功，延迟: 31.00 毫秒
请求 112 共识成功，延迟: 94.00 毫秒
请求 113 共识成功，延迟: 94.00 毫秒
请求 114 共识成功，延迟: 110.00 毫秒
请求 115 共识成功，延迟: 125.00 毫秒
请求 116 共识成功，延迟: 16.00 毫秒
请求 117 共识成功，延迟: 62.00 毫秒
请求 118 共识成功，延迟: 125.00 毫秒
请求 119 共识成功，延迟: 32.00 毫秒
请求 120 共识成功，延迟: 94.00 毫秒
请求 121 共识成功，延迟: 63.00 毫秒
请求 122 共识成功，延迟: 94.00 毫秒
请求 123 共识成功，延迟: 94.00 毫秒
请求 124 共识成功，延迟: 47.00 毫秒
请求 125 共识成功，延迟: 78.00 毫秒
请求 126 共识成功，延迟: 109.00 毫秒
请求 127 共识成功，延迟: 79.00 毫秒
请求 128 共识成功，延迟: 188.00 毫秒
请求 129 共识成功，延迟: 46.00 毫秒
请求 130 共识成功，延迟: 125.00 毫秒
请求 131 共识成功，延迟: 63.00 毫秒
请求 132 共识成功，延迟: 109.00 毫秒
请求 133 共识成功，延迟: 125.00 毫秒
请求 134 共识成功，延迟: 78.00 毫秒
请求 135 共识成功，延迟: 47.00 毫秒
请求 136 共识成功，延迟: 94.00 毫秒
请求 137 共识成功，延迟: 94.00 毫秒
请求 138 共识成功，延迟: 110.00 毫秒
请求 139 共识成功，延迟: 47.00 毫秒
请求 140 共识成功，延迟: 93.00 毫秒
请求 141 共识成功，延迟: 94.00 毫秒
请求 142 共识成功，延迟: 110.00 毫秒
请求 143 共识成功，延迟: 94.00 毫秒
请求 144 共识成功，延迟: 110.00 毫秒
请求 145 共识成功，延迟: 15.00 毫秒
请求 146 共识成功，延迟: 94.00 毫秒
请求 147 共识成功，延迟: 125.00 毫秒
请求 148 共识成功，延迟: 47.00 毫秒
请求 149 共识成功，延迟: 94.00 毫秒
请求 150 共识成功，延迟: 78.00 毫秒
请求 151 共识成功，延迟: 110.00 毫秒
请求 152 共识成功，延迟: 94.00 毫秒
请求 153 共识成功，延迟: 78.00 毫秒
请求 154 共识成功，延迟: 15.00 毫秒
请求 155 共识成功，延迟: 47.00 毫秒
请求 156 共识成功，延迟: 109.00 毫秒
请求 157 共识成功，延迟: 125.00 毫秒
请求 158 共识成功，延迟: 109.00 毫秒
请求 159 共识成功，延迟: 125.00 毫秒
请求 160 共识成功，延迟: 31.00 毫秒
请求 161 共识成功，延迟: 109.00 毫秒
请求 162 共识成功，延迟: 109.00 毫秒
请求 163 共识成功，延迟: 94.00 毫秒
请求 164 共识成功，延迟: 156.00 毫秒
请求 165 共识成功，延迟: 140.00 毫秒
请求 166 共识成功，延迟: 109.00 毫秒
请求 167 共识成功，延迟: 62.00 毫秒
请求 168 共识成功，延迟: 109.00 毫秒
请求 169 共识成功，延迟: 140.00 毫秒
请求 170 共识成功，延迟: 109.00 毫秒
请求 171 共识成功，延迟: 94.00 毫秒
请求 172 共识成功，延迟: 125.00 毫秒
请求 173 共识成功，延迟: 31.00 毫秒
请求 174 共识成功，延迟: 125.00 毫秒
请求 175 共识成功，延迟: 94.00 毫秒
请求 176 共识成功，延迟: 62.00 毫秒
请求 177 共识成功，延迟: 94.00 毫秒
请求 178 共识成功，延迟: 63.00 毫秒
请求 179 共识成功，延迟: 94.00 毫秒
请求 180 共识成功，延迟: 63.00 毫秒
请求 181 共识成功，延迟: 109.00 毫秒
请求 182 共识成功，延迟: 63.00 毫秒
请求 183 共识成功，延迟: 78.00 毫秒
请求 184 共识成功，延迟: 125.00 毫秒
请求 185 共识成功，延迟: 94.00 毫秒
请求 186 共识成功，延迟: 63.00 毫秒
请求 187 共识成功，延迟: 93.00 毫秒
请求 188 共识成功，延迟: 78.00 毫秒
请求 189 共识成功，延迟: 172.00 毫秒
请求 190 共识成功，延迟: 125.00 毫秒
请求 191 共识成功，延迟: 187.00 毫秒
请求 192 共识成功，延迟: 79.00 毫秒
请求 193 共识成功，延迟: 125.00 毫秒
请求 194 共识成功，延迟: 78.00 毫秒
请求 195 共识成功，延迟: 109.00 毫秒
请求 196 共识成功，延迟: 31.00 毫秒
请求 197 共识成功，延迟: 109.00 毫秒
请求 198 共识成功，延迟: 78.00 毫秒
请求 199 共识成功，延迟: 47.00 毫秒
请求 200 共识成功，延迟: 94.00 毫秒
请求 201 共识成功，延迟: 47.00 毫秒
请求 202 共识成功，延迟: 62.00 毫秒
请求 203 共识成功，延迟: 171.00 毫秒
请求 204 共识成功，延迟: 94.00 毫秒
请求 205 共识成功，延迟: 78.00 毫秒
请求 206 共识成功，延迟: 94.00 毫秒
请求 207 共识成功，延迟: 62.00 毫秒
请求 208 共识成功，延迟: 78.00 毫秒
请求 209 共识成功，延迟: 109.00 毫秒
请求 210 共识成功，延迟: 78.00 毫秒
请求 211 共识成功，延迟: 125.00 毫秒
请求 212 共识成功，延迟: 109.00 毫秒
请求 213 共识成功，延迟: 171.00 毫秒
请求 214 共识成功，延迟: 109.00 毫秒
请求 215 共识成功，延迟: 110.00 毫秒
请求 216 共识成功，延迟: 94.00 毫秒
请求 217 共识成功，延迟: 94.00 毫秒
请求 218 共识成功，延迟: 94.00 毫秒
请求 219 共识成功，延迟: 109.00 毫秒
请求 220 共识成功，延迟: 47.00 毫秒
请求 221 共识成功，延迟: 109.00 毫秒
请求 222 共识成功，延迟: 125.00 毫秒
请求 223 共识成功，延迟: 109.00 毫秒
请求 224 共识成功，延迟: 78.00 毫秒
请求 225 共识成功，延迟: 141.00 毫秒
请求 226 共识成功，延迟: 63.00 毫秒
请求 227 共识成功，延迟: 16.00 毫秒
请求 228 共识成功，延迟: 109.00 毫秒
请求 229 共识成功，延迟: 94.00 毫秒
请求 230 共识成功，延迟: 109.00 毫秒
请求 231 共识成功，延迟: 93.00 毫秒
请求 232 共识成功，延迟: 140.00 毫秒
请求 233 共识成功，延迟: 31.00 毫秒
请求 234 共识成功，延迟: 78.00 毫秒
请求 235 共识成功，延迟: 78.00 毫秒
请求 236 共识成功，延迟: 125.00 毫秒
请求 237 共识成功，延迟: 156.00 毫秒
请求 238 共识成功，延迟: 110.00 毫秒
请求 239 共识成功，延迟: 78.00 毫秒
请求 240 共识成功，延迟: 78.00 毫秒
请求 241 共识成功，延迟: 78.00 毫秒
请求 242 共识成功，延迟: 156.00 毫秒
请求 243 共识成功，延迟: 32.00 毫秒
请求 244 共识成功，延迟: 94.00 毫秒
请求 245 共识成功，延迟: 94.00 毫秒
请求 246 共识成功，延迟: 94.00 毫秒
请求 247 共识成功，延迟: 141.00 毫秒
请求 248 共识成功，延迟: 47.00 毫秒
请求 249 共识成功，延迟: 47.00 毫秒
请求 250 共识成功，延迟: 109.00 毫秒
请求 251 共识成功，延迟: 171.00 毫秒
请求 252 共识成功，延迟: 125.00 毫秒
请求 253 共识成功，延迟: 109.00 毫秒
请求 254 共识成功，延迟: 78.00 毫秒
请求 255 共识成功，延迟: 157.00 毫秒
请求 256 共识成功，延迟: 125.00 毫秒
请求 257 共识成功，延迟: 172.00 毫秒
请求 258 共识成功，延迟: 109.00 毫秒
请求 259 共识成功，延迟: 78.00 毫秒
请求 260 共识成功，延迟: 47.00 毫秒
请求 261 共识成功，延迟: 110.00 毫秒
请求 262 共识成功，延迟: 78.00 毫秒
请求 263 共识成功，延迟: 78.00 毫秒
请求 264 共识成功，延迟: 140.00 毫秒
请求 265 共识成功，延迟: 110.00 毫秒
请求 266 共识成功，延迟: 141.00 毫秒
请求 267 共识成功，延迟: 125.00 毫秒
请求 268 共识成功，延迟: 46.00 毫秒
请求 269 共识成功，延迟: 47.00 毫秒
请求 270 共识成功，延迟: 31.00 毫秒
请求 271 共识成功，延迟: 93.00 毫秒
请求 272 共识成功，延迟: 62.00 毫秒
请求 273 共识成功，延迟: 125.00 毫秒
请求 274 共识成功，延迟: 63.00 毫秒
请求 275 共识成功，延迟: 94.00 毫秒
请求 276 共识成功，延迟: 93.00 毫秒
请求 277 共识成功，延迟: 78.00 毫秒
请求 278 共识成功，延迟: 156.00 毫秒
请求 279 共识成功，延迟: 78.00 毫秒
请求 280 共识成功，延迟: 31.00 毫秒
请求 281 共识成功，延迟: 109.00 毫秒
请求 282 共识成功，延迟: 63.00 毫秒
请求 283 共识成功，延迟: 94.00 毫秒
请求 284 共识成功，延迟: 93.00 毫秒
请求 285 共识成功，延迟: 63.00 毫秒
请求 286 共识成功，延迟: 94.00 毫秒
请求 287 共识成功，延迟: 78.00 毫秒
请求 288 共识成功，延迟: 47.00 毫秒
请求 289 共识成功，延迟: 156.00 毫秒
请求 290 共识成功，延迟: 47.00 毫秒
请求 291 共识成功，延迟: 125.00 毫秒
请求 292 共识成功，延迟: 109.00 毫秒
请求 293 共识成功，延迟: 109.00 毫秒
请求 294 共识成功，延迟: 94.00 毫秒
请求 295 共识成功，延迟: 109.00 毫秒
请求 296 共识成功，延迟: 63.00 毫秒
请求 297 共识成功，延迟: 62.00 毫秒
请求 298 共识成功，延迟: 16.00 毫秒
请求 299 共识成功，延迟: 63.00 毫秒
请求 300 共识成功，延迟: 78.00 毫秒
请求 301 共识成功，延迟: 109.00 毫秒
请求 302 共识成功，延迟: 157.00 毫秒
请求 303 共识成功，延迟: 172.00 毫秒
请求 304 共识成功，延迟: 109.00 毫秒
请求 305 共识成功，延迟: 78.00 毫秒
请求 306 共识成功，延迟: 15.00 毫秒
请求 307 共识成功，延迟: 94.00 毫秒
请求 308 共识成功，延迟: 94.00 毫秒
请求 309 共识成功，延迟: 125.00 毫秒
请求 310 共识成功，延迟: 47.00 毫秒
请求 311 共识成功，延迟: 47.00 毫秒
请求 312 共识成功，延迟: 110.00 毫秒
请求 313 共识成功，延迟: 31.00 毫秒
请求 314 共识成功，延迟: 46.00 毫秒
请求 315 共识成功，延迟: 47.00 毫秒
请求 316 共识成功，延迟: 125.00 毫秒
请求 317 共识成功，延迟: 62.00 毫秒
请求 318 共识成功，延迟: 172.00 毫秒
请求 319 共识成功，延迟: 78.00 毫秒
请求 320 共识成功，延迟: 94.00 毫秒
请求 321 共识成功，延迟: 94.00 毫秒
请求 322 共识成功，延迟: 94.00 毫秒
请求 323 共识成功，延迟: 109.00 毫秒
请求 324 共识成功，延迟: 125.00 毫秒
请求 325 共识成功，延迟: 187.00 毫秒
请求 326 共识成功，延迟: 47.00 毫秒
请求 327 共识成功，延迟: 110.00 毫秒
请求 328 共识成功，延迟: 157.00 毫秒
请求 329 共识成功，延迟: 94.00 毫秒
请求 330 共识成功，延迟: 63.00 毫秒
请求 331 共识成功，延迟: 94.00 毫秒
请求 332 共识成功，延迟: 125.00 毫秒
请求 333 共识成功，延迟: 62.00 毫秒
请求 334 共识成功，延迟: 94.00 毫秒
请求 335 共识成功，延迟: 47.00 毫秒
请求 336 共识成功，延迟: 157.00 毫秒
请求 337 共识成功，延迟: 93.00 毫秒
请求 338 共识成功，延迟: 47.00 毫秒
请求 339 共识成功，延迟: 47.00 毫秒
请求 340 共识成功，延迟: 141.00 毫秒
请求 341 共识成功，延迟: 94.00 毫秒
请求 342 共识成功，延迟: 79.00 毫秒
请求 343 共识成功，延迟: 63.00 毫秒
请求 344 共识成功，延迟: 172.00 毫秒
请求 345 共识成功，延迟: 156.00 毫秒
请求 346 共识成功，延迟: 79.00 毫秒
请求 347 共识成功，延迟: 94.00 毫秒
请求 348 共识成功，延迟: 31.00 毫秒
请求 349 共识成功，延迟: 62.00 毫秒
请求 350 共识成功，延迟: 63.00 毫秒
请求 351 共识成功，延迟: 125.00 毫秒
请求 352 共识成功，延迟: 172.00 毫秒
请求 353 共识成功，延迟: 94.00 毫秒
请求 354 共识成功，延迟: 78.00 毫秒
请求 355 共识成功，延迟: 94.00 毫秒
请求 356 共识成功，延迟: 31.00 毫秒
请求 357 共识成功，延迟: 172.00 毫秒
请求 358 共识成功，延迟: 78.00 毫秒
请求 359 共识成功，延迟: 125.00 毫秒
请求 360 共识成功，延迟: 32.00 毫秒
请求 361 共识成功，延迟: 94.00 毫秒
请求 362 共识成功，延迟: 31.00 毫秒
请求 363 共识成功，延迟: 63.00 毫秒
请求 364 共识成功，延迟: 109.00 毫秒
请求 365 共识成功，延迟: 109.00 毫秒
请求 366 共识成功，延迟: 94.00 毫秒
请求 367 共识成功，延迟: 62.00 毫秒
请求 368 共识成功，延迟: 110.00 毫秒
请求 369 共识成功，延迟: 47.00 毫秒
请求 370 共识成功，延迟: 109.00 毫秒
请求 371 共识成功，延迟: 109.00 毫秒
请求 372 共识成功，延迟: 47.00 毫秒
请求 373 共识成功，延迟: 78.00 毫秒
请求 374 共识成功，延迟: 109.00 毫秒
请求 375 共识成功，延迟: 78.00 毫秒
请求 376 共识成功，延迟: 78.00 毫秒
请求 377 共识成功，延迟: 78.00 毫秒
请求 378 共识成功，延迟: 78.00 毫秒
请求 379 共识成功，延迟: 78.00 毫秒
请求 380 共识成功，延迟: 78.00 毫秒
请求 381 共识成功，延迟: 109.00 毫秒
请求 382 共识成功，延迟: 109.00 毫秒
请求 383 共识成功，延迟: 62.00 毫秒
请求 384 共识成功，延迟: 78.00 毫秒
请求 385 共识成功，延迟: 63.00 毫秒
请求 386 共识成功，延迟: 141.00 毫秒
请求 387 共识成功，延迟: 31.00 毫秒
请求 388 共识成功，延迟: 31.00 毫秒
请求 389 共识成功，延迟: 93.00 毫秒
请求 390 共识成功，延迟: 78.00 毫秒
请求 391 共识成功，延迟: 62.00 毫秒
请求 392 共识成功，延迟: 109.00 毫秒
请求 393 共识成功，延迟: 46.00 毫秒
请求 394 共识成功，延迟: 109.00 毫秒
请求 395 共识成功，延迟: 47.00 毫秒
请求 396 共识成功，延迟: 78.00 毫秒
请求 397 共识成功，延迟: 110.00 毫秒
请求 398 共识成功，延迟: 110.00 毫秒
请求 399 共识成功，延迟: 63.00 毫秒
请求 400 共识成功，延迟: 94.00 毫秒
请求 401 共识成功，延迟: 78.00 毫秒
请求 402 共识成功，延迟: 110.00 毫秒
请求 403 共识成功，延迟: 94.00 毫秒
请求 404 共识成功，延迟: 109.00 毫秒
请求 405 共识成功，延迟: 78.00 毫秒
请求 406 共识成功，延迟: 94.00 毫秒
请求 407 共识成功，延迟: 157.00 毫秒
请求 408 共识成功，延迟: 94.00 毫秒
请求 409 共识成功，延迟: 94.00 毫秒
请求 410 共识成功，延迟: 110.00 毫秒
请求 411 共识成功，延迟: 78.00 毫秒
请求 412 共识成功，延迟: 78.00 毫秒
请求 413 共识成功，延迟: 187.00 毫秒
请求 414 共识成功，延迟: 47.00 毫秒
请求 415 共识成功，延迟: 125.00 毫秒
请求 416 共识成功，延迟: 93.00 毫秒
请求 417 共识成功，延迟: 47.00 毫秒
请求 418 共识成功，延迟: 46.00 毫秒
请求 419 共识成功，延迟: 125.00 毫秒
请求 420 共识成功，延迟: 109.00 毫秒
请求 421 共识成功，延迟: 79.00 毫秒
请求 422 共识成功，延迟: 62.00 毫秒
请求 423 共识成功，延迟: 47.00 毫秒
请求 424 共识成功，延迟: 78.00 毫秒
请求 425 共识成功，延迟: 63.00 毫秒
请求 426 共识成功，延迟: 78.00 毫秒
请求 427 共识成功，延迟: 47.00 毫秒
请求 428 共识成功，延迟: 63.00 毫秒
请求 429 共识成功，延迟: 79.00 毫秒
请求 430 共识成功，延迟: 125.00 毫秒
请求 431 共识成功，延迟: 62.00 毫秒
请求 432 共识成功，延迟: 78.00 毫秒
请求 433 共识成功，延迟: 94.00 毫秒
请求 434 共识成功，延迟: 62.00 毫秒
请求 435 共识成功，延迟: 94.00 毫秒
请求 436 共识成功，延迟: 79.00 毫秒
请求 437 共识成功，延迟: 32.00 毫秒
请求 438 共识成功，延迟: 110.00 毫秒
请求 439 共识成功，延迟: 94.00 毫秒
请求 440 共识成功，延迟: 31.00 毫秒
请求 441 共识成功，延迟: 109.00 毫秒
请求 442 共识成功，延迟: 47.00 毫秒
请求 443 共识成功，延迟: 141.00 毫秒
请求 444 共识成功，延迟: 32.00 毫秒
请求 445 共识成功，延迟: 125.00 毫秒
请求 446 共识成功，延迟: 78.00 毫秒
请求 447 共识成功，延迟: 109.00 毫秒
请求 448 共识成功，延迟: 63.00 毫秒
请求 449 共识成功，延迟: 62.00 毫秒
请求 450 共识成功，延迟: 94.00 毫秒
请求 451 共识成功，延迟: 62.00 毫秒
请求 452 共识成功，延迟: 125.00 毫秒
请求 453 共识成功，延迟: 93.00 毫秒
请求 454 共识成功，延迟: 78.00 毫秒
请求 455 共识成功，延迟: 109.00 毫秒
请求 456 共识成功，延迟: 46.00 毫秒
请求 457 共识成功，延迟: 63.00 毫秒
请求 458 共识成功，延迟: 47.00 毫秒
请求 459 共识成功，延迟: 94.00 毫秒
请求 460 共识成功，延迟: 94.00 毫秒
请求 461 共识成功，延迟: 47.00 毫秒
请求 462 共识成功，延迟: 47.00 毫秒
请求 463 共识成功，延迟: 62.00 毫秒
请求 464 共识成功，延迟: 110.00 毫秒
请求 465 共识成功，延迟: 78.00 毫秒
请求 466 共识成功，延迟: 125.00 毫秒
请求 467 共识成功，延迟: 94.00 毫秒
请求 468 共识成功，延迟: 110.00 毫秒
请求 469 共识成功，延迟: 93.00 毫秒
请求 470 共识成功，延迟: 78.00 毫秒
请求 471 共识成功，延迟: 63.00 毫秒
请求 472 共识成功，延迟: 94.00 毫秒
请求 473 共识成功，延迟: 78.00 毫秒
请求 474 共识成功，延迟: 125.00 毫秒
请求 475 共识成功，延迟: 93.00 毫秒
请求 476 共识成功，延迟: 94.00 毫秒
请求 477 共识成功，延迟: 109.00 毫秒
请求 478 共识成功，延迟: 141.00 毫秒
请求 479 共识成功，延迟: 140.00 毫秒
请求 480 共识成功，延迟: 125.00 毫秒
请求 481 共识成功，延迟: 125.00 毫秒
请求 482 共识成功，延迟: 125.00 毫秒
请求 483 共识成功，延迟: 110.00 毫秒
请求 484 共识成功，延迟: 109.00 毫秒
请求 485 共识成功，延迟: 110.00 毫秒
请求 486 共识成功，延迟: 172.00 毫秒
请求 487 共识成功，延迟: 78.00 毫秒
请求 488 共识成功，延迟: 109.00 毫秒
请求 489 共识成功，延迟: 78.00 毫秒
请求 490 共识成功，延迟: 125.00 毫秒
请求 491 共识成功，延迟: 63.00 毫秒
请求 492 共识成功，延迟: 78.00 毫秒
请求 493 共识成功，延迟: 156.00 毫秒
请求 494 共识成功，延迟: 78.00 毫秒
请求 495 共识成功，延迟: 109.00 毫秒
请求 496 共识成功，延迟: 63.00 毫秒
请求 497 共识成功，延迟: 63.00 毫秒
请求 498 共识成功，延迟: 156.00 毫秒
请求 499 共识成功，延迟: 62.00 毫秒
请求 500 共识成功，延迟: 78.00 毫秒
请求 501 共识成功，延迟: 78.00 毫秒
请求 502 共识成功，延迟: 172.00 毫秒
请求 503 共识成功，延迟: 63.00 毫秒
请求 504 共识成功，延迟: 93.00 毫秒
请求 505 共识成功，延迟: 156.00 毫秒
请求 506 共识成功，延迟: 94.00 毫秒
请求 507 共识成功，延迟: 94.00 毫秒
请求 508 共识成功，延迟: 156.00 毫秒
请求 509 共识成功，延迟: 141.00 毫秒
请求 510 共识成功，延迟: 78.00 毫秒
请求 511 共识成功，延迟: 47.00 毫秒
请求 512 共识成功，延迟: 125.00 毫秒
请求 513 共识成功，延迟: 125.00 毫秒
请求 514 共识成功，延迟: 109.00 毫秒
请求 515 共识成功，延迟: 156.00 毫秒
请求 516 共识成功，延迟: 109.00 毫秒
请求 517 共识成功，延迟: 47.00 毫秒
请求 518 共识成功，延迟: 47.00 毫秒
请求 519 共识成功，延迟: 63.00 毫秒
请求 520 共识成功，延迟: 63.00 毫秒
请求 521 共识成功，延迟: 63.00 毫秒
请求 522 共识成功，延迟: 94.00 毫秒
请求 523 共识成功，延迟: 63.00 毫秒
请求 524 共识成功，延迟: 156.00 毫秒
请求 525 共识成功，延迟: 110.00 毫秒
请求 526 共识成功，延迟: 141.00 毫秒
请求 527 共识成功，延迟: 93.00 毫秒
请求 528 共识成功，延迟: 125.00 毫秒
请求 529 共识成功，延迟: 109.00 毫秒
请求 530 共识成功，延迟: 31.00 毫秒
请求 531 共识成功，延迟: 46.00 毫秒
请求 532 共识成功，延迟: 93.00 毫秒
请求 533 共识成功，延迟: 78.00 毫秒
请求 534 共识成功，延迟: 63.00 毫秒
请求 535 共识成功，延迟: 141.00 毫秒
请求 536 共识成功，延迟: 110.00 毫秒
请求 537 共识成功，延迟: 94.00 毫秒
请求 538 共识成功，延迟: 125.00 毫秒
请求 539 共识成功，延迟: 93.00 毫秒
请求 540 共识成功，延迟: 110.00 毫秒
请求 541 共识成功，延迟: 141.00 毫秒
请求 542 共识成功，延迟: 78.00 毫秒
请求 543 共识成功，延迟: 109.00 毫秒
请求 544 共识成功，延迟: 140.00 毫秒
请求 545 共识成功，延迟: 188.00 毫秒
请求 546 共识成功，延迟: 47.00 毫秒
请求 547 共识成功，延迟: 94.00 毫秒
请求 548 共识成功，延迟: 78.00 毫秒
请求 549 共识成功，延迟: 31.00 毫秒
请求 550 共识成功，延迟: 94.00 毫秒
请求 551 共识成功，延迟: 62.00 毫秒
请求 552 共识成功，延迟: 125.00 毫秒
请求 553 共识成功，延迟: 15.00 毫秒
请求 554 共识成功，延迟: 109.00 毫秒
请求 555 共识成功，延迟: 15.00 毫秒
请求 556 共识成功，延迟: 62.00 毫秒
请求 557 共识成功，延迟: 125.00 毫秒
请求 558 共识成功，延迟: 109.00 毫秒
请求 559 共识成功，延迟: 63.00 毫秒
请求 560 共识成功，延迟: 141.00 毫秒
请求 561 共识成功，延迟: 63.00 毫秒
请求 562 共识成功，延迟: 141.00 毫秒
请求 563 共识成功，延迟: 109.00 毫秒
请求 564 共识成功，延迟: 78.00 毫秒
请求 565 共识成功，延迟: 125.00 毫秒
请求 566 共识成功，延迟: 31.00 毫秒
请求 567 共识成功，延迟: 47.00 毫秒
请求 568 共识成功，延迟: 157.00 毫秒
请求 569 共识成功，延迟: 94.00 毫秒
请求 570 共识成功，延迟: 78.00 毫秒
请求 571 共识成功，延迟: 93.00 毫秒
请求 572 共识成功，延迟: 141.00 毫秒
请求 573 共识成功，延迟: 141.00 毫秒
请求 574 共识成功，延迟: 94.00 毫秒
请求 575 共识成功，延迟: 78.00 毫秒
请求 576 共识成功，延迟: 94.00 毫秒
请求 577 共识成功，延迟: 110.00 毫秒
请求 578 共识成功，延迟: 94.00 毫秒
请求 579 共识成功，延迟: 94.00 毫秒
请求 580 共识成功，延迟: 109.00 毫秒
请求 581 共识成功，延迟: 109.00 毫秒
请求 582 共识成功，延迟: 94.00 毫秒
请求 583 共识成功，延迟: 125.00 毫秒
请求 584 共识成功，延迟: 47.00 毫秒
请求 585 共识成功，延迟: 94.00 毫秒
请求 586 共识成功，延迟: 46.00 毫秒
请求 587 共识成功，延迟: 156.00 毫秒
请求 588 共识成功，延迟: 141.00 毫秒
请求 589 共识成功，延迟: 78.00 毫秒
请求 590 共识成功，延迟: 78.00 毫秒
请求 591 共识成功，延迟: 109.00 毫秒
请求 592 共识成功，延迟: 78.00 毫秒
请求 593 共识成功，延迟: 109.00 毫秒
请求 594 共识成功，延迟: 79.00 毫秒
请求 595 共识成功，延迟: 47.00 毫秒
请求 596 共识成功，延迟: 16.00 毫秒
请求 597 共识成功，延迟: 62.00 毫秒
请求 598 共识成功，延迟: 140.00 毫秒
请求 599 共识成功，延迟: 94.00 毫秒
请求 600 共识成功，延迟: 109.00 毫秒
请求 601 共识成功，延迟: 62.00 毫秒
请求 602 共识成功，延迟: 109.00 毫秒
请求 603 共识成功，延迟: 94.00 毫秒
请求 604 共识成功，延迟: 78.00 毫秒
请求 605 共识成功，延迟: 47.00 毫秒
请求 606 共识成功，延迟: 125.00 毫秒
请求 607 共识成功，延迟: 94.00 毫秒
请求 608 共识成功，延迟: 109.00 毫秒
请求 609 共识成功，延迟: 47.00 毫秒
请求 610 共识成功，延迟: 78.00 毫秒
请求 611 共识成功，延迟: 109.00 毫秒
请求 612 共识成功，延迟: 15.00 毫秒
请求 613 共识成功，延迟: 125.00 毫秒
请求 614 共识成功，延迟: 63.00 毫秒
请求 615 共识成功，延迟: 110.00 毫秒
请求 616 共识成功，延迟: 172.00 毫秒
请求 617 共识成功，延迟: 125.00 毫秒
请求 618 共识成功，延迟: 15.00 毫秒
请求 619 共识成功，延迟: 94.00 毫秒
请求 620 共识成功，延迟: 94.00 毫秒
请求 621 共识成功，延迟: 110.00 毫秒
请求 622 共识成功，延迟: 78.00 毫秒
请求 623 共识成功，延迟: 47.00 毫秒
请求 624 共识成功，延迟: 109.00 毫秒
请求 625 共识成功，延迟: 31.00 毫秒
请求 626 共识成功，延迟: 141.00 毫秒
请求 627 共识成功，延迟: 94.00 毫秒
请求 628 共识成功，延迟: 156.00 毫秒
请求 629 共识成功，延迟: 109.00 毫秒
请求 630 共识成功，延迟: 32.00 毫秒
请求 631 共识成功，延迟: 94.00 毫秒
请求 632 共识成功，延迟: 140.00 毫秒
请求 633 共识成功，延迟: 94.00 毫秒
请求 634 共识成功，延迟: 78.00 毫秒
请求 635 共识成功，延迟: 93.00 毫秒
请求 636 共识成功，延迟: 109.00 毫秒
请求 637 共识成功，延迟: 156.00 毫秒
请求 638 共识成功，延迟: 62.00 毫秒
请求 639 共识成功，延迟: 63.00 毫秒
请求 640 共识成功，延迟: 94.00 毫秒
请求 641 共识成功，延迟: 78.00 毫秒
请求 642 共识成功，延迟: 79.00 毫秒
请求 643 共识成功，延迟: 47.00 毫秒
请求 644 共识成功，延迟: 140.00 毫秒
请求 645 共识成功，延迟: 79.00 毫秒
请求 646 共识成功，延迟: 156.00 毫秒
请求 647 共识成功，延迟: 78.00 毫秒
请求 648 共识成功，延迟: 94.00 毫秒
请求 649 共识成功，延迟: 94.00 毫秒
请求 650 共识成功，延迟: 110.00 毫秒
请求 651 共识成功，延迟: 78.00 毫秒
请求 652 共识成功，延迟: 47.00 毫秒
请求 653 共识成功，延迟: 15.00 毫秒
请求 654 共识成功，延迟: 78.00 毫秒
请求 655 共识成功，延迟: 109.00 毫秒
请求 656 共识成功，延迟: 31.00 毫秒
请求 657 共识成功，延迟: 31.00 毫秒
请求 658 共识成功，延迟: 78.00 毫秒
请求 659 共识成功，延迟: 47.00 毫秒
请求 660 共识成功，延迟: 31.00 毫秒
请求 661 共识成功，延迟: 47.00 毫秒
请求 662 共识成功，延迟: 47.00 毫秒
请求 663 共识成功，延迟: 203.00 毫秒
请求 664 共识成功，延迟: 93.00 毫秒
请求 665 共识成功，延迟: 31.00 毫秒
请求 666 共识成功，延迟: 62.00 毫秒
请求 667 共识成功，延迟: 31.00 毫秒
请求 668 共识成功，延迟: 94.00 毫秒
请求 669 共识成功，延迟: 78.00 毫秒
请求 670 共识成功，延迟: 78.00 毫秒
请求 671 共识成功，延迟: 79.00 毫秒
请求 672 共识成功，延迟: 93.00 毫秒
请求 673 共识成功，延迟: 78.00 毫秒
请求 674 共识成功，延迟: 79.00 毫秒
请求 675 共识成功，延迟: 94.00 毫秒
请求 676 共识成功，延迟: 93.00 毫秒
请求 677 共识成功，延迟: 94.00 毫秒
请求 678 共识成功，延迟: 62.00 毫秒
请求 679 共识成功，延迟: 109.00 毫秒
请求 680 共识成功，延迟: 94.00 毫秒
请求 681 共识成功，延迟: 157.00 毫秒
请求 682 共识成功，延迟: 78.00 毫秒
请求 683 共识成功，延迟: 31.00 毫秒
请求 684 共识成功，延迟: 93.00 毫秒
请求 685 共识成功，延迟: 93.00 毫秒
请求 686 共识成功，延迟: 78.00 毫秒
请求 687 共识成功，延迟: 78.00 毫秒
请求 688 共识成功，延迟: 63.00 毫秒
请求 689 共识成功，延迟: 62.00 毫秒
请求 690 共识成功，延迟: 78.00 毫秒
请求 691 共识成功，延迟: 140.00 毫秒
请求 692 共识成功，延迟: 63.00 毫秒
请求 693 共识成功，延迟: 47.00 毫秒
请求 694 共识成功，延迟: 187.00 毫秒
请求 695 共识成功，延迟: 78.00 毫秒
请求 696 共识成功，延迟: 156.00 毫秒
请求 697 共识成功，延迟: 47.00 毫秒
请求 698 共识成功，延迟: 78.00 毫秒
请求 699 共识成功，延迟: 110.00 毫秒
请求 700 共识成功，延迟: 79.00 毫秒
请求 701 共识成功，延迟: 94.00 毫秒
请求 702 共识成功，延迟: 94.00 毫秒
请求 703 共识成功，延迟: 93.00 毫秒
请求 704 共识成功，延迟: 94.00 毫秒
请求 705 共识成功，延迟: 78.00 毫秒
请求 706 共识成功，延迟: 94.00 毫秒
请求 707 共识成功，延迟: 94.00 毫秒
请求 708 共识成功，延迟: 94.00 毫秒
请求 709 共识成功，延迟: 78.00 毫秒
请求 710 共识成功，延迟: 78.00 毫秒
请求 711 共识成功，延迟: 172.00 毫秒
请求 712 共识成功，延迟: 94.00 毫秒
请求 713 共识成功，延迟: 63.00 毫秒
请求 714 共识成功，延迟: 94.00 毫秒
请求 715 共识成功，延迟: 78.00 毫秒
请求 716 共识成功，延迟: 156.00 毫秒
请求 717 共识成功，延迟: 78.00 毫秒
请求 718 共识成功，延迟: 93.00 毫秒
请求 719 共识成功，延迟: 47.00 毫秒
请求 720 共识成功，延迟: 93.00 毫秒
请求 721 共识成功，延迟: 109.00 毫秒
请求 722 共识成功，延迟: 31.00 毫秒
请求 723 共识成功，延迟: 110.00 毫秒
请求 724 共识成功，延迟: 109.00 毫秒
请求 725 共识成功，延迟: 109.00 毫秒
请求 726 共识成功，延迟: 109.00 毫秒
请求 727 共识成功，延迟: 63.00 毫秒
请求 728 共识成功，延迟: 31.00 毫秒
请求 729 共识成功，延迟: 94.00 毫秒
请求 730 共识成功，延迟: 94.00 毫秒
请求 731 共识成功，延迟: 47.00 毫秒
请求 732 共识成功，延迟: 109.00 毫秒
请求 733 共识成功，延迟: 94.00 毫秒
请求 734 共识成功，延迟: 109.00 毫秒
请求 735 共识成功，延迟: 141.00 毫秒
请求 736 共识成功，延迟: 203.00 毫秒
请求 737 共识成功，延迟: 78.00 毫秒
请求 738 共识成功，延迟: 94.00 毫秒
请求 739 共识成功，延迟: 78.00 毫秒
请求 740 共识成功，延迟: 78.00 毫秒
请求 741 共识成功，延迟: 78.00 毫秒
请求 742 共识成功，延迟: 110.00 毫秒
请求 743 共识成功，延迟: 62.00 毫秒
请求 744 共识成功，延迟: 109.00 毫秒
请求 745 共识成功，延迟: 78.00 毫秒
请求 746 共识成功，延迟: 109.00 毫秒
请求 747 共识成功，延迟: 109.00 毫秒
请求 748 共识成功，延迟: 109.00 毫秒
请求 749 共识成功，延迟: 125.00 毫秒
请求 750 共识成功，延迟: 46.00 毫秒
请求 751 共识成功，延迟: 140.00 毫秒
请求 752 共识成功，延迟: 109.00 毫秒
请求 753 共识成功，延迟: 94.00 毫秒
请求 754 共识成功，延迟: 78.00 毫秒
请求 755 共识成功，延迟: 47.00 毫秒
请求 756 共识成功，延迟: 109.00 毫秒
请求 757 共识成功，延迟: 62.00 毫秒
请求 758 共识成功，延迟: 31.00 毫秒
请求 759 共识成功，延迟: 141.00 毫秒
请求 760 共识成功，延迟: 94.00 毫秒
请求 761 共识成功，延迟: 156.00 毫秒
请求 762 共识成功，延迟: 93.00 毫秒
请求 763 共识成功，延迟: 31.00 毫秒
请求 764 共识成功，延迟: 94.00 毫秒
请求 765 共识成功，延迟: 93.00 毫秒
请求 766 共识成功，延迟: 94.00 毫秒
请求 767 共识成功，延迟: 125.00 毫秒
请求 768 共识成功，延迟: 93.00 毫秒
请求 769 共识成功，延迟: 94.00 毫秒
请求 770 共识成功，延迟: 171.00 毫秒
请求 771 共识成功，延迟: 109.00 毫秒
请求 772 共识成功，延迟: 141.00 毫秒
请求 773 共识成功，延迟: 31.00 毫秒
请求 774 共识成功，延迟: 62.00 毫秒
请求 775 共识成功，延迟: 125.00 毫秒
请求 776 共识成功，延迟: 16.00 毫秒
请求 777 共识成功，延迟: 78.00 毫秒
请求 778 共识成功，延迟: 125.00 毫秒
请求 779 共识成功，延迟: 78.00 毫秒
请求 780 共识成功，延迟: 125.00 毫秒
请求 781 共识成功，延迟: 63.00 毫秒
请求 782 共识成功，延迟: 109.00 毫秒
请求 783 共识成功，延迟: 78.00 毫秒
请求 784 共识成功，延迟: 109.00 毫秒
请求 785 共识成功，延迟: 94.00 毫秒
请求 786 共识成功，延迟: 109.00 毫秒
请求 787 共识成功，延迟: 78.00 毫秒
请求 788 共识成功，延迟: 78.00 毫秒
请求 789 共识成功，延迟: 109.00 毫秒
请求 790 共识成功，延迟: 109.00 毫秒
请求 791 共识成功，延迟: 78.00 毫秒
请求 792 共识成功，延迟: 94.00 毫秒
请求 793 共识成功，延迟: 78.00 毫秒
请求 794 共识成功，延迟: 78.00 毫秒
请求 795 共识成功，延迟: 125.00 毫秒
请求 796 共识成功，延迟: 94.00 毫秒
请求 797 共识成功，延迟: 94.00 毫秒
请求 798 共识成功，延迟: 125.00 毫秒
请求 799 共识成功，延迟: 109.00 毫秒
请求 800 共识成功，延迟: 125.00 毫秒
请求 801 共识成功，延迟: 94.00 毫秒
请求 802 共识成功，延迟: 94.00 毫秒
请求 803 共识成功，延迟: 93.00 毫秒
请求 804 共识成功，延迟: 47.00 毫秒
请求 805 共识成功，延迟: 140.00 毫秒
请求 806 共识成功，延迟: 94.00 毫秒
请求 807 共识成功，延迟: 171.00 毫秒
请求 808 共识成功，延迟: 62.00 毫秒
请求 809 共识成功，延迟: 79.00 毫秒
请求 810 共识成功，延迟: 63.00 毫秒
请求 811 共识成功，延迟: 125.00 毫秒
请求 812 共识成功，延迟: 109.00 毫秒
请求 813 共识成功，延迟: 109.00 毫秒
请求 814 共识成功，延迟: 110.00 毫秒
请求 815 共识成功，延迟: 94.00 毫秒
请求 816 共识成功，延迟: 94.00 毫秒
请求 817 共识成功，延迟: 109.00 毫秒
请求 818 共识成功，延迟: 78.00 毫秒
请求 819 共识成功，延迟: 172.00 毫秒
请求 820 共识成功，延迟: 125.00 毫秒
请求 821 共识成功，延迟: 78.00 毫秒
请求 822 共识成功，延迟: 78.00 毫秒
请求 823 共识成功，延迟: 109.00 毫秒
请求 824 共识成功，延迟: 93.00 毫秒
请求 825 共识成功，延迟: 78.00 毫秒
请求 826 共识成功，延迟: 110.00 毫秒
请求 827 共识成功，延迟: 78.00 毫秒
请求 828 共识成功，延迟: 141.00 毫秒
请求 829 共识成功，延迟: 94.00 毫秒
请求 830 共识成功，延迟: 93.00 毫秒
请求 831 共识成功，延迟: 78.00 毫秒
请求 832 共识成功，延迟: 156.00 毫秒
请求 833 共识成功，延迟: 31.00 毫秒
请求 834 共识成功，延迟: 47.00 毫秒
请求 835 共识成功，延迟: 125.00 毫秒
请求 836 共识成功，延迟: 94.00 毫秒
请求 837 共识成功，延迟: 47.00 毫秒
请求 838 共识成功，延迟: 125.00 毫秒
请求 839 共识成功，延迟: 109.00 毫秒
请求 840 共识成功，延迟: 47.00 毫秒
请求 841 共识成功，延迟: 78.00 毫秒
请求 842 共识成功，延迟: 62.00 毫秒
请求 843 共识成功，延迟: 47.00 毫秒
请求 844 共识成功，延迟: 78.00 毫秒
请求 845 共识成功，延迟: 110.00 毫秒
请求 846 共识成功，延迟: 46.00 毫秒
请求 847 共识成功，延迟: 140.00 毫秒
请求 848 共识成功，延迟: 78.00 毫秒
请求 849 共识成功，延迟: 78.00 毫秒
请求 850 共识成功，延迟: 63.00 毫秒
请求 851 共识成功，延迟: 110.00 毫秒
请求 852 共识成功，延迟: 109.00 毫秒
请求 853 共识成功，延迟: 172.00 毫秒
请求 854 共识成功，延迟: 47.00 毫秒
请求 855 共识成功，延迟: 156.00 毫秒
请求 856 共识成功，延迟: 172.00 毫秒
请求 857 共识成功，延迟: 31.00 毫秒
请求 858 共识成功，延迟: 109.00 毫秒
请求 859 共识成功，延迟: 47.00 毫秒
请求 860 共识成功，延迟: 62.00 毫秒
请求 861 共识成功，延迟: 94.00 毫秒
请求 862 共识成功，延迟: 78.00 毫秒
请求 863 共识成功，延迟: 79.00 毫秒
请求 864 共识成功，延迟: 110.00 毫秒
请求 865 共识成功，延迟: 94.00 毫秒
请求 866 共识成功，延迟: 31.00 毫秒
请求 867 共识成功，延迟: 63.00 毫秒
请求 868 共识成功，延迟: 63.00 毫秒
请求 869 共识成功，延迟: 125.00 毫秒
请求 870 共识成功，延迟: 47.00 毫秒
请求 871 共识成功，延迟: 94.00 毫秒
请求 872 共识成功，延迟: 156.00 毫秒
请求 873 共识成功，延迟: 93.00 毫秒
请求 874 共识成功，延迟: 94.00 毫秒
请求 875 共识成功，延迟: 93.00 毫秒
请求 876 共识成功，延迟: 94.00 毫秒
请求 877 共识成功，延迟: 79.00 毫秒
请求 878 共识成功，延迟: 94.00 毫秒
请求 879 共识成功，延迟: 125.00 毫秒
请求 880 共识成功，延迟: 32.00 毫秒
请求 881 共识成功，延迟: 94.00 毫秒
请求 882 共识成功，延迟: 93.00 毫秒
请求 883 共识成功，延迟: 94.00 毫秒
请求 884 共识成功，延迟: 63.00 毫秒
请求 885 共识成功，延迟: 94.00 毫秒
请求 886 共识成功，延迟: 47.00 毫秒
请求 887 共识成功，延迟: 78.00 毫秒
请求 888 共识成功，延迟: 140.00 毫秒
请求 889 共识成功，延迟: 62.00 毫秒
请求 890 共识成功，延迟: 109.00 毫秒
请求 891 共识成功，延迟: 94.00 毫秒
请求 892 共识成功，延迟: 78.00 毫秒
请求 893 共识成功，延迟: 62.00 毫秒
请求 894 共识成功，延迟: 110.00 毫秒
请求 895 共识成功，延迟: 94.00 毫秒
请求 896 共识成功，延迟: 109.00 毫秒
请求 897 共识成功，延迟: 93.00 毫秒
请求 898 共识成功，延迟: 109.00 毫秒
请求 899 共识成功，延迟: 79.00 毫秒
请求 900 共识成功，延迟: 63.00 毫秒
请求 901 共识成功，延迟: 31.00 毫秒
请求 902 共识成功，延迟: 63.00 毫秒
请求 903 共识成功，延迟: 140.00 毫秒
请求 904 共识成功，延迟: 94.00 毫秒
请求 905 共识成功，延迟: 78.00 毫秒
请求 906 共识成功，延迟: 93.00 毫秒
请求 907 共识成功，延迟: 125.00 毫秒
请求 908 共识成功，延迟: 125.00 毫秒
请求 909 共识成功，延迟: 109.00 毫秒
请求 910 共识成功，延迟: 63.00 毫秒
请求 911 共识成功，延迟: 93.00 毫秒
请求 912 共识成功，延迟: 32.00 毫秒
请求 913 共识成功，延迟: 156.00 毫秒
请求 914 共识成功，延迟: 109.00 毫秒
请求 915 共识成功，延迟: 203.00 毫秒
请求 916 共识成功，延迟: 46.00 毫秒
请求 917 共识成功，延迟: 93.00 毫秒
请求 918 共识成功，延迟: 109.00 毫秒
请求 919 共识成功，延迟: 94.00 毫秒
请求 920 共识成功，延迟: 94.00 毫秒
请求 921 共识成功，延迟: 109.00 毫秒
请求 922 共识成功，延迟: 93.00 毫秒
请求 923 共识成功，延迟: 125.00 毫秒
请求 924 共识成功，延迟: 63.00 毫秒
请求 925 共识成功，延迟: 172.00 毫秒
请求 926 共识成功，延迟: 93.00 毫秒
请求 927 共识成功，延迟: 78.00 毫秒
请求 928 共识成功，延迟: 78.00 毫秒
请求 929 共识成功，延迟: 125.00 毫秒
请求 930 共识成功，延迟: 94.00 毫秒
请求 931 共识成功，延迟: 78.00 毫秒
请求 932 共识成功，延迟: 78.00 毫秒
请求 933 共识成功，延迟: 47.00 毫秒
请求 934 共识成功，延迟: 78.00 毫秒
请求 935 共识成功，延迟: 93.00 毫秒
请求 936 共识成功，延迟: 125.00 毫秒
请求 937 共识成功，延迟: 125.00 毫秒
请求 938 共识成功，延迟: 47.00 毫秒
请求 939 共识成功，延迟: 15.00 毫秒
请求 940 共识成功，延迟: 62.00 毫秒
请求 941 共识成功，延迟: 31.00 毫秒
请求 942 共识成功，延迟: 47.00 毫秒
请求 943 共识成功，延迟: 125.00 毫秒
请求 944 共识成功，延迟: 94.00 毫秒
请求 945 共识成功，延迟: 62.00 毫秒
请求 946 共识成功，延迟: 125.00 毫秒
请求 947 共识成功，延迟: 109.00 毫秒
请求 948 共识成功，延迟: 93.00 毫秒
请求 949 共识成功，延迟: 63.00 毫秒
请求 950 共识成功，延迟: 78.00 毫秒
请求 951 共识成功，延迟: 63.00 毫秒
请求 952 共识成功，延迟: 93.00 毫秒
请求 953 共识成功，延迟: 78.00 毫秒
请求 954 共识成功，延迟: 172.00 毫秒
请求 955 共识成功，延迟: 63.00 毫秒
请求 956 共识成功，延迟: 63.00 毫秒
请求 957 共识成功，延迟: 62.00 毫秒
请求 958 共识成功，延迟: 78.00 毫秒
请求 959 共识成功，延迟: 125.00 毫秒
请求 960 共识成功，延迟: 93.00 毫秒
请求 961 共识成功，延迟: 78.00 毫秒
请求 962 共识成功，延迟: 125.00 毫秒
请求 963 共识成功，延迟: 31.00 毫秒
请求 964 共识成功，延迟: 63.00 毫秒
请求 965 共识成功，延迟: 47.00 毫秒
请求 966 共识成功，延迟: 110.00 毫秒
请求 967 共识成功，延迟: 94.00 毫秒
请求 968 共识成功，延迟: 110.00 毫秒
请求 969 共识成功，延迟: 172.00 毫秒
请求 970 共识成功，延迟: 94.00 毫秒
请求 971 共识成功，延迟: 63.00 毫秒
请求 972 共识成功，延迟: 156.00 毫秒
请求 973 共识成功，延迟: 93.00 毫秒
请求 974 共识成功，延迟: 110.00 毫秒
请求 975 共识成功，延迟: 94.00 毫秒
请求 976 共识成功，延迟: 62.00 毫秒
请求 977 共识成功，延迟: 141.00 毫秒
请求 978 共识成功，延迟: 188.00 毫秒
请求 979 共识成功，延迟: 79.00 毫秒
请求 980 共识成功，延迟: 62.00 毫秒
请求 981 共识成功，延迟: 31.00 毫秒
请求 982 共识成功，延迟: 110.00 毫秒
请求 983 共识成功，延迟: 47.00 毫秒
请求 984 共识成功，延迟: 78.00 毫秒
请求 985 共识成功，延迟: 110.00 毫秒
请求 986 共识成功，延迟: 32.00 毫秒
请求 987 共识成功，延迟: 125.00 毫秒
请求 988 共识成功，延迟: 94.00 毫秒
请求 989 共识成功，延迟: 31.00 毫秒
请求 990 共识成功，延迟: 203.00 毫秒
请求 991 共识成功，延迟: 94.00 毫秒
请求 992 共识成功，延迟: 47.00 毫秒
请求 993 共识成功，延迟: 94.00 毫秒
请求 994 共识成功，延迟: 63.00 毫秒
请求 995 共识成功，延迟: 94.00 毫秒
请求 996 共识成功，延迟: 94.00 毫秒
请求 997 共识成功，延迟: 47.00 毫秒
请求 998 共识成功，延迟: 63.00 毫秒
请求 999 共识成功，延迟: 109.00 毫秒

=== 性能指标 ===
总请求数: 1000
成功请求数: 1000
平均延迟: 91.78 毫秒
共识成功率: 100.00%




分析一下，有什么不足，该如何改进更拟真

3.超硬核系列之：pbft多线程c语言完全仿真

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <time.h>
#include <locale.h>

// 定义常量
#define NODE_COUNT 80        // 节点数量，减少到80，模拟中小型区块链网络
#define FAULT_TOLERANCE 26   // 容错节点数，满足 N=3F+1，F≈(80-1)/3
#define REQUEST_COUNT 100    // 总请求数，减少到100以加快运行
#define MAX_DELAY 10         // 最大网络延迟（毫秒），模拟更快通信
#define MALICIOUS_RATE 0.1   // 作恶节点比例（10%）
#define DOWNTIME_RATE 0.1    // 宕机节点比例（10%）
#define DELAY_JITTER 0.1     // 延迟扰动因子（10%）

// 消息类型枚举，定义PBFT的三个阶段
typedef enum {
    MSG_PREPREPARE,  // Pre-Prepare阶段消息
    MSG_PREPARE,     // Prepare阶段消息
    MSG_COMMIT       // Commit阶段消息
} MsgType;

// 消息结构体，用于节点间通信
typedef struct Message {
    int request_id;         // 请求编号，标识哪个请求
    MsgType type;           // 消息类型（Pre-Prepare/Prepare/Commit）
    int sender;             // 发送节点编号
    struct Message *next;   // 链表指针，用于消息队列
} Message;

// 消息队列结构体，每个节点拥有一个独立队列
typedef struct {
    Message *head;          // 队列头部指针
    Message *tail;          // 队列尾部指针
    CRITICAL_SECTION cs;    // 互斥锁，确保线程安全
    CONDITION_VARIABLE cv;  // 条件变量，用于线程同步
} MessageQueue;

// 初始化消息队列
void init_queue(MessageQueue *q) {
    q->head = q->tail = NULL;          // 队列初始为空
    InitializeCriticalSection(&q->cs); // 初始化互斥锁
    InitializeConditionVariable(&q->cv); // 初始化条件变量
}

// 入队操作，将消息加入队列
void enqueue(MessageQueue *q, Message *msg) {
    EnterCriticalSection(&q->cs);      // 进入临界区，保护队列
    msg->next = NULL;                  // 新消息的下一个指针为空
    if (q->tail == NULL) {             // 如果队列为空
        q->head = q->tail = msg;       // 头尾都指向新消息
    } else {                           // 如果队列非空
        q->tail->next = msg;           // 将新消息链接到尾部
        q->tail = msg;                 // 更新尾指针
    }
    WakeConditionVariable(&q->cv);     // 唤醒等待消息的线程
    LeaveCriticalSection(&q->cs);      // 离开临界区
}

// 出队操作，阻塞等待队列非空并返回消息
Message* dequeue(MessageQueue *q) {
    EnterCriticalSection(&q->cs);      // 进入临界区
    while (q->head == NULL) {          // 如果队列为空
        SleepConditionVariableCS(&q->cv, &q->cs, INFINITE); // 等待消息到达
    }
    Message *msg = q->head;            // 取出头部消息
    q->head = msg->next;               // 更新头部指针
    if (q->head == NULL)               // 如果队列变空
        q->tail = NULL;                // 尾指针置空
    LeaveCriticalSection(&q->cs);      // 离开临界区
    return msg;                        // 返回消息
}

// 模拟网络延迟，返回延迟时间（毫秒）
double simulate_network_delay() {
    double base_delay = (rand() / (double)RAND_MAX) * MAX_DELAY; // 基础延迟：0到10ms
    double jitter = (rand() / (double)RAND_MAX - 0.5) * 2 * DELAY_JITTER * base_delay; // 扰动：±10%
    return base_delay + jitter;        // 返回总延迟
}

// 节点结构体，定义节点状态
typedef struct {
    int id;            // 节点编号
    int is_primary;    // 是否为主节点（节点0为主）
    int is_malicious;  // 是否作恶
    int is_down;       // 是否宕机
} Node;

// 全局节点数组，供线程访问节点状态
Node nodes_global[NODE_COUNT];

// 初始化节点，设置节点状态
void init_nodes(Node *nodes) {
    for (int i = 0; i < NODE_COUNT; i++) {
        nodes[i].id = i;                   // 设置节点编号
        nodes[i].is_primary = (i == 0);    // 节点0为主节点
        nodes[i].is_malicious = (rand() / (double)RAND_MAX < MALICIOUS_RATE); // 随机设置作恶状态
        nodes[i].is_down = (rand() / (double)RAND_MAX < DOWNTIME_RATE);       // 随机设置宕机状态
    }
    nodes[0].is_down = 0;                  // 确保主节点不宕机
}

// 全局消息队列数组，每个节点一个队列
MessageQueue nodeQueues[NODE_COUNT];

// 全局统计变量，用于记录性能指标
double total_latency = 0.0;                // 总延迟（毫秒）
int successful_requests = 0;               // 成功请求数
CRITICAL_SECTION stats_cs;                 // 保护统计数据的互斥锁

// 延迟直方图数组，用于统计延迟分布
double latencies[REQUEST_COUNT];

// 节点线程函数（非主节点），处理消息并模拟通信
DWORD WINAPI node_thread_proc(LPVOID param) {
    int node_id = *(int*)param;            // 获取节点ID
    while (1) {
        Message *msg = dequeue(&nodeQueues[node_id]); // 从队列中取出消息
        // 检查终止信号：request_id == -1 且 type == -1
        if (msg->request_id == -1 && msg->type == (MsgType)-1) {
            free(msg);                     // 释放消息内存
            break;                         // 退出线程
        }
        // 如果节点正常且不作恶，处理消息
        if (!nodes_global[node_id].is_down && !nodes_global[node_id].is_malicious) {
            double delay = simulate_network_delay(); // 计算网络延迟
            Sleep((int)delay);             // 模拟实际通信等待
            if (msg->type == MSG_PREPREPARE) {
                // 收到Pre-Prepare消息，回复Prepare消息给主节点
                Message *reply = (Message*)malloc(sizeof(Message));
                reply->request_id = msg->request_id;
                reply->type = MSG_PREPARE;
                reply->sender = node_id;
                enqueue(&nodeQueues[0], reply); // 发送给主节点（节点0）
            } else if (msg->type == MSG_COMMIT) {
                // 收到Commit消息，回复Commit消息给主节点
                Message *reply = (Message*)malloc(sizeof(Message));
                reply->request_id = msg->request_id;
                reply->type = MSG_COMMIT;
                reply->sender = node_id;
                enqueue(&nodeQueues[0], reply);
            }
        }
        free(msg);                         // 释放接收到的消息内存
    }
    return 0;                              // 线程结束
}

// 生成延迟直方图，统计延迟分布
void print_stats_histogram(double *latencies, int count) {
    printf("\n=== 延迟直方图 (毫秒) ===\n");
    int bins[10] = {0};                    // 10个区间（0-100ms）
    for (int i = 0; i < count; i++) {
        int bin = (int)(latencies[i] / 10); // 将延迟映射到区间
        if (bin >= 0 && bin < 10) bins[bin]++;
    }
    for (int i = 0; i < 10; i++) {
        printf("%2d-%2d ms: ", i * 10, (i + 1) * 10); // 打印区间
        for (int j = 0; j < bins[i] / 5; j++) printf("*"); // 每5个请求一个*
        printf(" (%d)\n", bins[i]);        // 打印数量
    }
}

int main() {
    // 设置控制台编码和区域，支持中文输出
    SetConsoleOutputCP(CP_UTF8);
    setlocale(LC_ALL, "zh_CN.UTF-8");
    srand((unsigned int)time(NULL));

    // 初始化统计数据的互斥锁
    InitializeCriticalSection(&stats_cs);

    // 初始化节点数组
    Node nodes[NODE_COUNT];
    init_nodes(nodes);
    for (int i = 0; i < NODE_COUNT; i++) {
        nodes_global[i] = nodes[i];        // 同步到全局数组
    }

    // 初始化每个节点的消息队列
    for (int i = 0; i < NODE_COUNT; i++) {
        init_queue(&nodeQueues[i]);
    }

    // 创建非主节点线程（节点1到79）
    HANDLE nodeThreads[NODE_COUNT - 1];
    int nodeIds[NODE_COUNT - 1];
    for (int i = 1; i < NODE_COUNT; i++) {
        nodeIds[i - 1] = i;                // 记录节点ID
        nodeThreads[i - 1] = CreateThread(NULL, 0, node_thread_proc, &nodeIds[i - 1], 0, NULL); // 创建线程
    }

    // 定义共识所需的阈值：2F+1
    int threshold = 2 * FAULT_TOLERANCE + 1;

    // 高精度计时开始
    LARGE_INTEGER frequency, start_time, end_time;
    QueryPerformanceFrequency(&frequency);
    QueryPerformanceCounter(&start_time);

    // 主节点处理请求
    for (int req = 0; req < REQUEST_COUNT; req++) {
        // 主节点发送Pre-Prepare消息给所有非主节点
        for (int i = 1; i < NODE_COUNT; i++) {
            Message *msg = (Message*)malloc(sizeof(Message));
            msg->request_id = req;
            msg->type = MSG_PREPREPARE;
            msg->sender = 0;
            enqueue(&nodeQueues[i], msg);  // 将消息加入目标节点的队列
        }
        // 主节点自身模拟Pre-Prepare阶段延迟
        double preprepare_delay = simulate_network_delay();
        Sleep((int)preprepare_delay);

        DWORD req_start = GetTickCount();  // 记录请求开始时间

        // 收集Prepare消息
        int prepareCount = 0;
        while (prepareCount < threshold) {
            Message *msg = dequeue(&nodeQueues[0]); // 主节点从自己的队列取消息
            if (msg->request_id == req && msg->type == MSG_PREPARE) {
                prepareCount++;             // 统计Prepare消息数量
            }
            free(msg);                      // 释放消息内存
        }

        // 主节点发送Commit消息给所有非主节点
        for (int i = 1; i < NODE_COUNT; i++) {
            Message *msg = (Message*)malloc(sizeof(Message));
            msg->request_id = req;
            msg->type = MSG_COMMIT;
            msg->sender = 0;
            enqueue(&nodeQueues[i], msg);  // 将消息加入目标节点的队列
        }
        // 主节点自身模拟Commit阶段延迟
        double commit_delay = simulate_network_delay();
        Sleep((int)commit_delay);

        // 收集Commit消息
        int commitCount = 0;
        while (commitCount < threshold) {
            Message *msg = dequeue(&nodeQueues[0]); // 主节点从自己的队列取消息
            if (msg->request_id == req && msg->type == MSG_COMMIT) {
                commitCount++;             // 统计Commit消息数量
            }
            free(msg);                     // 释放消息内存
        }

        // 记录请求延迟
        DWORD req_end = GetTickCount();
        double req_latency = req_end - req_start; // 计算请求总延迟
        EnterCriticalSection(&stats_cs);   // 保护统计数据
        if (successful_requests < REQUEST_COUNT) {
            latencies[successful_requests] = req_latency; // 记录延迟
            total_latency += req_latency;  // 累加总延迟
            successful_requests++;         // 增加成功请求计数
        }
        LeaveCriticalSection(&stats_cs);   // 离开临界区

        // 每10个请求打印一次进度
        if (req % 10 == 0) {
            printf("请求 %d 共识成功，延迟: %.2f 毫秒\n", req, req_latency);
        }
    }

    // 发送终止信号给所有非主节点线程
    for (int i = 1; i < NODE_COUNT; i++) {
        Message *term = (Message*)malloc(sizeof(Message));
        term->request_id = -1;             // 终止信号
        term->type = (MsgType)-1;          // 终止类型
        term->sender = -1;                 // 无意义发送者
        enqueue(&nodeQueues[i], term);     // 发送终止消息
    }

    // 等待所有非主节点线程结束
    WaitForMultipleObjects(NODE_COUNT - 1, nodeThreads, TRUE, INFINITE);

    // 计算并记录总运行时间
    QueryPerformanceCounter(&end_time);
    double real_total_time = (double)(end_time.QuadPart - start_time.QuadPart) / frequency.QuadPart; // 转换为秒

    // 计算性能指标
    double avg_latency = (successful_requests > 0) ? total_latency / successful_requests : 0.0; // 平均延迟
    double throughput = (real_total_time > 0) ? successful_requests / real_total_time : 0.0;    // 吞吐量
    double consensus_rate = (double)successful_requests / REQUEST_COUNT * 100;                   // 共识成功率

    // 输出性能指标
    printf("\n=== 性能指标 ===\n");
    printf("总请求数: %d\n", REQUEST_COUNT);
    printf("成功请求数: %d\n", successful_requests);
    printf("共识成功率: %.2f%%\n", consensus_rate);
    printf("实际运行时间: %.2f 秒\n", real_total_time);
    printf("平均延迟: %.2f 毫秒\n", avg_latency);
    printf("吞吐量: %.2f 请求/秒\n", throughput);

    // 输出延迟直方图
    print_stats_histogram(latencies, successful_requests);

    // 清理资源
    DeleteCriticalSection(&stats_cs);      // 删除统计数据的互斥锁
    for (int i = 0; i < NODE_COUNT; i++) {
        DeleteCriticalSection(&nodeQueues[i].cs); // 删除每个队列的互斥锁
    }
    for (int i = 0; i < NODE_COUNT - 1; i++) {
        CloseHandle(nodeThreads[i]);       // 关闭线程句柄
    }

    return 0;                              // 程序结束
}

4 硬核详解！！！

cpp 复制代码 
我会非常详细地解释这个代码的运行过程，从头到尾逐步分析每个部分的功能和执行步骤，尤其会重点讲解互斥锁（CRITICAL_SECTION）和条件变量（CONDITION_VARIABLE）的作用，帮助你理解这些概念。代码模拟了一个基于PBFT（实用拜占庭容错）算法的区块链共识过程，我们将以一个实际运行的视角来分解它。

代码整体运行过程概述
这个程序模拟了一个由80个节点组成的小型区块链网络，其中节点0是主节点，其他节点（1到79）是从节点。程序的目标是处理100个请求，通过PBFT的三个阶段（Pre-Prepare、Prepare、Commit）达成共识。每个节点有自己的消息队列，节点之间通过消息传递进行通信，模拟真实的网络延迟和并发处理。为了确保线程安全，使用了互斥锁和条件变量。

运行过程可以分为以下几个大步骤：

初始化：设置节点状态、消息队列和线程。
主节点发起请求：主节点发送Pre-Prepare消息，启动共识过程。
从节点处理消息：从节点接收消息，依次回复Prepare和Commit消息。
主节点收集回复：主节点收集足够的Prepare和Commit消息，完成共识。
统计和清理：计算性能指标，清理资源并结束程序。
详细运行过程分解
1. 程序启动和初始化（main函数开头）
c

收起

換行

複製
int main() {
    SetConsoleOutputCP(CP_UTF8);
    setlocale(LC_ALL, "zh_CN.UTF-8");
    srand((unsigned int)time(NULL));
功能：
SetConsoleOutputCP(CP_UTF8)：设置控制台输出编码为UTF-8，确保中文显示正常。
setlocale(LC_ALL, "zh_CN.UTF-8")：设置程序的区域为中文环境，支持中文字符。
srand((unsigned int)time(NULL))：用当前时间初始化随机数种子，用于生成随机延迟和节点状态。
c

收起

換行

複製
    InitializeCriticalSection(&stats_cs);
功能：初始化全局统计数据的互斥锁stats_cs。
什么是互斥锁（CRITICAL_SECTION）？
想象你家里只有一个厕所（共享资源），而你和你的兄弟姐妹（多个线程）都想用。为了避免大家同时挤进去发生混乱，你在厕所门上装了一个锁。每次有人要进去时，必须先锁门，用完后再解锁。互斥锁就是这样的"锁"，它确保同一时间只有一个线程能访问共享资源（这里是total_latency和successful_requests）。
InitializeCriticalSection是Windows API，用于创建这个锁。
c

收起

換行

複製
    Node nodes[NODE_COUNT];
    init_nodes(nodes);
    for (int i = 0; i < NODE_COUNT; i++) {
        nodes_global[i] = nodes[i];
    }
功能：
创建一个包含80个节点的数组nodes。
调用init_nodes函数初始化每个节点的属性（ID、主节点状态、作恶状态、宕机状态）。
将nodes复制到全局数组nodes_global，供所有线程访问。
执行过程：
init_nodes遍历80个节点：
nodes[i].id = i：节点编号从0到79。
nodes[i].is_primary = (i == 0)：节点0为主节点。
nodes[i].is_malicious和nodes[i].is_down：随机生成，10%概率为作恶或宕机。
nodes[0].is_down = 0：强制主节点不宕机。
c

收起

換行

複製
    for (int i = 0; i < NODE_COUNT; i++) {
        init_queue(&nodeQueues[i]);
    }
功能：为80个节点分别初始化消息队列。
消息队列（MessageQueue）：
每个节点有一个MessageQueue，包含head和tail指针（链表形式），用于存储消息。
init_queue函数：
将head和tail设为NULL，表示队列为空。
InitializeCriticalSection(&q->cs)：为队列初始化互斥锁，保护队列操作。
InitializeConditionVariable(&q->cv)：初始化条件变量，用于线程等待消息。
什么是条件变量（CONDITION_VARIABLE）？
想象你在等人送快递，但你不想一直盯着门口（浪费时间）。你告诉快递员："到了敲门，我再出来拿。"条件变量就像这个"敲门信号"，当队列为空时，线程会暂停（睡觉），等到有新消息时被唤醒。
c

收起

換行

複製
    HANDLE nodeThreads[NODE_COUNT - 1];
    int nodeIds[NODE_COUNT - 1];
    for (int i = 1; i < NODE_COUNT; i++) {
        nodeIds[i - 1] = i;
        nodeThreads[i - 1] = CreateThread(NULL, 0, node_thread_proc, &nodeIds[i - 1], 0, NULL);
    }
功能：创建79个从节点线程（节点1到79）。
执行过程：
nodeIds[i - 1] = i：记录每个线程对应的节点ID（1到79）。
CreateThread：为每个从节点创建一个线程，运行node_thread_proc函数，参数是节点ID。
主节点（节点0）不创建线程，它在主线程中运行。
结果：程序启动后，79个线程开始运行，等待处理消息。
2. 主节点发起请求（主循环）
c

收起

換行

複製
    int threshold = 2 * FAULT_TOLERANCE + 1;
    LARGE_INTEGER frequency, start_time, end_time;
    QueryPerformanceFrequency(&frequency);
    QueryPerformanceCounter(&start_time);
功能：
threshold = 2 * FAULT_TOLERANCE + 1：计算PBFT共识所需的票数（2F+1=53）。
初始化高精度计时器，用于测量程序总运行时间。
c

收起

換行

複製
    for (int req = 0; req < REQUEST_COUNT; req++) {
        for (int i = 1; i < NODE_COUNT; i++) {
            Message *msg = (Message*)malloc(sizeof(Message));
            msg->request_id = req;
            msg->type = MSG_PREPREPARE;
            msg->sender = 0;
            enqueue(&nodeQueues[i], msg);
        }
        double preprepare_delay = simulate_network_delay();
        Sleep((int)preprepare_delay);
功能：主节点处理100个请求，发送Pre-Prepare消息。
执行过程：
循环100次（req从0到99）。
对于每个请求：
遍历节点1到79，创建Pre-Prepare消息（MSG_PREPREPARE），request_id为当前请求编号，sender为主节点0。
调用enqueue将消息加入每个从节点的队列。
主节点自身模拟延迟（0-10ms），用Sleep等待。
enqueue过程：
进入队列的互斥锁（EnterCriticalSection），防止其他线程同时操作队列。
将消息加入链表（若为空则设为head和tail，否则追加到tail）。
唤醒等待的线程（WakeConditionVariable）。
释放锁（LeaveCriticalSection）。
3. 从节点处理消息（node_thread_proc）
c

收起

換行

複製
DWORD WINAPI node_thread_proc(LPVOID param) {
    int node_id = *(int*)param;
    while (1) {
        Message *msg = dequeue(&nodeQueues[node_id]);
        if (msg->request_id == -1 && msg->type == (MsgType)-1) {
            free(msg);
            break;
        }
功能：每个从节点线程持续从自己的队列中取消息。
执行过程：
dequeue：从节点队列中取出一条消息。
如果消息是终止信号（request_id == -1且type == -1），释放内存并退出线程。
dequeue过程：
进入队列互斥锁。
如果队列为空，线程暂停（SleepConditionVariableCS），等待enqueue唤醒。
取走head消息，更新队列指针，释放锁，返回消息。
c

收起

換行

複製
        if (!nodes_global[node_id].is_down && !nodes_global[node_id].is_malicious) {
            double delay = simulate_network_delay();
            Sleep((int)delay);
            if (msg->type == MSG_PREPREPARE) {
                Message *reply = (Message*)malloc(sizeof(Message));
                reply->request_id = msg->request_id;
                reply->type = MSG_PREPARE;
                reply->sender = node_id;
                enqueue(&nodeQueues[0], reply);
            } else if (msg->type == MSG_COMMIT) {
                Message *reply = (Message*)malloc(sizeof(Message));
                reply->request_id = msg->request_id;
                reply->type = MSG_COMMIT;
                reply->sender = node_id;
                enqueue(&nodeQueues[0], reply);
            }
        }
        free(msg);
功能：处理消息并回复。
执行过程：
检查节点状态：若宕机或作恶，跳过处理。
计算延迟并等待（Sleep）。
如果是Pre-Prepare消息：
创建Prepare回复，发送到主节点队列（nodeQueues[0]）。
如果是Commit消息：
创建Commit回复，发送到主节点队列。
释放接收到的消息内存。
4. 主节点收集回复
c

收起

換行

複製
        DWORD req_start = GetTickCount();
        int prepareCount = 0;
        while (prepareCount < threshold) {
            Message *msg = dequeue(&nodeQueues[0]);
            if (msg->request_id == req && msg->type == MSG_PREPARE) {
                prepareCount++;
            }
            free(msg);
        }
功能：主节点收集Prepare消息。
执行过程：
记录请求开始时间。
循环直到收到53条（threshold）Prepare消息：
从主节点队列取消息。
检查消息是否匹配当前请求且类型为MSG_PREPARE，计数加1。
释放消息内存。
c

收起

換行

複製
        for (int i = 1; i < NODE_COUNT; i++) {
            Message *msg = (Message*)malloc(sizeof(Message));
            msg->request_id = req;
            msg->type = MSG_COMMIT;
            msg->sender = 0;
            enqueue(&nodeQueues[i], msg);
        }
        double commit_delay = simulate_network_delay();
        Sleep((int)commit_delay);
功能：发送Commit消息。
执行过程：
主节点广播Commit消息给所有从节点。
模拟延迟并等待。
c

收起

換行

複製
        int commitCount = 0;
        while (commitCount < threshold) {
            Message *msg = dequeue(&nodeQueues[0]);
            if (msg->request_id == req && msg->type == MSG_COMMIT) {
                commitCount++;
            }
            free(msg);
        }
功能：收集Commit消息。
执行过程：类似Prepare阶段，收集53条Commit消息，确认共识达成。
c

收起

換行

複製
        DWORD req_end = GetTickCount();
        double req_latency = req_end - req_start;
        EnterCriticalSection(&stats_cs);
        if (successful_requests < REQUEST_COUNT) {
            latencies[successful_requests] = req_latency;
            total_latency += req_latency;
            successful_requests++;
        }
        LeaveCriticalSection(&stats_cs);
        if (req % 10 == 0) {
            printf("请求 %d 共识成功，延迟: %.2f 毫秒\n", req, req_latency);
        }
功能：记录延迟和统计。
执行过程：
计算请求总延迟（从req_start到req_end）。
使用互斥锁保护统计数据，更新latencies、total_latency和successful_requests。
每10个请求打印进度。
5. 结束和统计
c

收起

換行

複製
    for (int i = 1; i < NODE_COUNT; i++) {
        Message *term = (Message*)malloc(sizeof(Message));
        term->request_id = -1;
        term->type = (MsgType)-1;
        term->sender = -1;
        enqueue(&nodeQueues[i], term);
    }
    WaitForMultipleObjects(NODE_COUNT - 1, nodeThreads, TRUE, INFINITE);
功能：终止从节点线程。
执行过程：
发送终止信号给79个从节点。
等待所有线程结束。
c

收起

換行

複製
    QueryPerformanceCounter(&end_time);
    double real_total_time = (double)(end_time.QuadPart - start_time.QuadPart) / frequency.QuadPart;
    double avg_latency = (successful_requests > 0) ? total_latency / successful_requests : 0.0;
    double throughput = (real_total_time > 0) ? successful_requests / real_total_time : 0.0;
    double consensus_rate = (double)successful_requests / REQUEST_COUNT * 100;
功能：计算性能指标。
执行过程：
计算总运行时间。
计算平均延迟、吞吐量和共识成功率。
c

收起

換行

複製
    printf("\n=== 性能指标 ===\n");
    printf("总请求数: %d\n", REQUEST_COUNT);
    printf("成功请求数: %d\n", successful_requests);
    printf("共识成功率: %.2f%%\n", consensus_rate);
    printf("实际运行时间: %.2f 秒\n", real_total_time);
    printf("平均延迟: %.2f 毫秒\n", avg_latency);
    printf("吞吐量: %.2f 请求/秒\n", throughput);
    print_stats_histogram(latencies, successful_requests);
功能：输出结果。
print_stats_histogram：将延迟分段统计并打印直方图。
c

收起

換行

複製
    DeleteCriticalSection(&stats_cs);
    for (int i = 0; i < NODE_COUNT; i++) {
        DeleteCriticalSection(&nodeQueues[i].cs);
    }
    for (int i = 0; i < NODE_COUNT - 1; i++) {
        CloseHandle(nodeThreads[i]);
    }
功能：清理资源。
执行过程：
删除所有互斥锁和线程句柄，释放内存。
运行过程总结
启动：初始化80个节点和队列，创建79个从节点线程。
请求循环：
主节点广播Pre-Prepare。
从节点异步处理并回复Prepare。
主节点收集Prepare，广播Commit。
从节点回复Commit，主节点收集并完成共识。
结束：统计结果，清理资源。
互斥锁和条件变量的直观理解
互斥锁（CRITICAL_SECTION）：
作用：防止多个线程同时修改共享数据（比如队列或统计变量）。
例子：就像一个房间只能一个人进，多人同时进会乱套，锁确保顺序。
条件变量（CONDITION_VARIABLE）：
作用：让线程等待某个条件（比如队列非空），条件满足时被唤醒。
例子：你在等公交车，没车时你休息，车来了有人叫你上车。
这个代码通过锁和条件变量，确保了80个节点并行处理消息时的安全性和正确性，同时模拟了真实的区块链通信延迟。

5.详细版本解释：

这个程序模拟了一个小型区块链网络：

节点：80个节点，其中节点0是主节点（负责发起请求），节点1到79是从节点（负责响应）。

目标：处理100个请求，通过PBFT的三个阶段（Pre-Prepare、Prepare、Commit）达成共识。

通信方式：每个节点有自己的消息队列，主节点和从节点通过队列传递消息，模拟网络通信。

并发性：使用多线程（79个从节点线程+1个主线程），模拟区块链节点的并行工作。

延迟：每个消息传递有0-10ms的随机延迟，模拟真实网络环境。

同步工具：使用互斥锁和条件变量，确保线程安全和消息顺序。

运行过程可以分为五个主要阶段：

初始化阶段：设置节点、队列和线程。

主节点发起请求：发送Pre-Prepare消息，启动共识。

从节点处理消息：接收并回复Prepare和Commit消息。

主节点收集回复：收集足够的消息，完成共识。

统计和清理：输出性能指标，释放资源。

相关推荐
人类群星闪耀时4 分钟前
重塑数字版权管理——区块链的去中心化革新之路
去中心化·区块链
Hi-Jimmy7 分钟前
【VolView】纯前端实现CT三维重建-CBCT
前端·架构·volview·cbct
menge23337 分钟前
Python递归与递推的练习(初步了解复杂度，全排列的价值，奇妙的变换，数正方形，高塔登顶方案)
算法
janthinasnail34 分钟前
编写一个简单的chrome截图扩展
前端·chrome
大力水手偷吃菠菜变成米老鼠35 分钟前
stm32 2.0.1
stm32
Vitalia37 分钟前
⭐算法OJ⭐二叉树的后序遍历【树的遍历】（C++实现）Binary Tree Postorder Traversal
开发语言·c++·算法·二叉树
拉不动的猪1 小时前
刷刷题40（vue中计算属性不能异步，如何实现异步）
前端·javascript·vue.js
冴羽yayujs1 小时前
SvelteKit 最新中文文档教程（6）—— 状态管理
前端·javascript·vue.js·前端框架·react·svelte·sveltekit
做一个码农都是奢望1 小时前
MATLAB 调用arduino uno
开发语言·算法·matlab
烛阴1 小时前
前端进阶必学：JavaScript Class 的正确打开方式，让你代码更清晰！
前端·javascript
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03DeepSeek各版本说明与优缺点分析04如何在WPS和Word/Excel中直接使用DeepSeek功能05KGG转MP3工具|非KGM文件|解密音频06本地部署DeepSeek教程（Mac版本）07MySQL（七）MySQL和Oracle、PostgreSQL的区别08Windows 11 安装 Dify 完整指南 非docker环境09本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程102 本地部署DeepSeek模型构建本地知识库+联网搜索详细步骤