818181

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#include <pthread.h>

#define BUFFER_SIZE 1024

#define EXIT_MESSAGE "exit"

typedef struct {

    int client_socket;

    int client_count;

} ClientInfo;

typedef struct {

    pthread_t tid;

    int client_socket;

    int client_count;

    struct ThreadPool* pool;

} ThreadInfo;

typedef struct {

    ThreadInfo* threads;

    int capacity;

    int count;

    int next_client_count;

    pthread_mutex_t lock;

    pthread_cond_t cond;

} ThreadPool;

void error(const char *message) {

    perror(message);

    exit(1);

}

void* handle_client(void *arg) {

    ClientInfo *client_info = (ClientInfo *)arg;

    int client_socket = client_info->client_socket;

    int client_count = client_info->client_count;

    char buffer[BUFFER_SIZE];

    // 接收和发送消息，直到收到退出消息

    while (1) {

        // 接收客户端消息

        memset(buffer, 0, sizeof(buffer));

        if (recv(client_socket, buffer, sizeof(buffer), 0) < 0) {

            error("Error receiving data");

        }

        printf("Client %d: %s\n", client_count, buffer);

        // 去除换行符

        buffer[strcspn(buffer, "\n")] = '\0';

        // 检查退出消息

        if (strcmp(buffer, EXIT_MESSAGE) == 0) {

            printf("Client %d exited\n", client_count);

            break;

        }

        // 发送消息给客户端

        printf("Server: ");

        fgets(buffer, sizeof(buffer), stdin);

        // 去除换行符

        buffer[strcspn(buffer, "\n")] = '\0';

        // 检查退出消息

        if (strcmp(buffer, EXIT_MESSAGE) == 0) {

            if (send(client_socket, buffer, strlen(buffer), 0) < 0) {

                error("Error sending data");

            }

            printf("You exited\n");

            break;

        }

        if (send(client_socket, buffer, strlen(buffer), 0) < 0) {

            error("Error sending data");

        }

    }

    // 关闭客户端套接字

    close(client_socket);

    free(client_info);  // 释放动态分配的内存

    pthread_exit(NULL);

}

void* manager_thread(void* arg) {

    ThreadPool* pool = (ThreadPool*)arg;

    while (1) {

        // 获取线程池锁

        pthread_mutex_lock(&pool->lock);

        // 等待直到线程池中有空闲线程

        while (pool->count == pool->capacity) {

            pthread_cond_wait(&pool->cond, &pool->lock);

        }

        // 获取下一个客户端套接字

        int client_socket = accept(pool->threads[pool->count].client_socket, NULL, NULL);

        // 设置线程信息

        pool->threads[pool->count].client_socket = client_socket;

        pool->threads[pool->count].client_count = pool->next_client_count;

        pool->next_client_count++;

        // 创建线程处理客户端通信

        if (pthread_create(&pool->threads[pool->count].tid, NULL, handle_client, &(pool->threads[pool->count])) != 0) {

            error("Error creating thread");

        }

        // 分离线程，使其在退出时自动释放资源

        pthread_detach(pool->threads[pool->count].tid);

        // 增加线程池中线程的数量

        pool->count++;

        // 释放线程池锁

        pthread_mutex_unlock(&pool->lock);

    }

}

ThreadPool* create_thread_pool(int capacity) {

    ThreadPool* pool = (ThreadPool*)malloc(sizeof(ThreadPool));

    pool->threads = (ThreadInfo*)malloc(capacity * sizeof(ThreadInfo));

    pool->capacity = capacity;

    pool->count = 0;

    pool->next_client_count = 1;

    pthread_mutex_init(&pool->lock, NULL);

    pthread_cond_init(&pool->cond, NULL);

    return pool;

}

void destroy_thread_pool(ThreadPool* pool) {

    free(pool->threads);

    pthread_mutex_destroy(&pool->lock);

    pthread_cond_destroy(&pool->cond);

    free(pool);

}

int main(int argc, char *argv[]) {

    if (argc != 2) {

        fprintf(stderr, "Usage: %s <port>\n", argv[0]);

        exit(1);

    }

    int server_socket, client_socket;

    char buffer[BUFFER_SIZE];

    struct sockaddr_in server_addr, client_addr;

    socklen_t client_addr_len;

    // 创建服务器套接字

    server_socket = socket(AF_INET, SOCK_STREAM, 0);

    if (server_socket < 0) {

        error("Error opening socket");

    }

    // 设置服务器地址结构

    memset(&server_addr, 0, sizeof(server_addr));

    server_addr.sin_family = AF_INET;

    server_addr.sin_addr.s_addr = INADDR_ANY;

    server_addr.sin_port = htons(atoi(argv[1]));

    // 绑定服务器套接字到指定端口

    if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {

        error("Error binding socket");

    }

    // 监听连接请求

    if (listen(server_socket, 5) < 0) {

        error("Error listening");

    }

    printf("Waiting for connections...\n");

    int client_count = 1;

    ThreadPool* thread_pool = create_thread_pool(5);  // 设置线程池的容量为5

    // 创建管理者线程

    pthread_t manager_tid;

    if (pthread_create(&manager_tid, NULL, manager_thread, thread_pool) != 0) {

        error("Error creating manager thread");

    }

    // 主线程负责接受客户端连接

    while (1) {

        // 接受客户端连接

        client_addr_len = sizeof(client_addr);

        client_socket = accept(server_socket, (struct sockaddr *)&client_addr, &client_addr_len);

        if (client_socket < 0) {

            error("Error accepting connection");

        }

        // 获取线程池锁

        pthread_mutex_lock(&thread_pool->lock);

        // 将客户端套接字信息保存到线程池中的空闲线程中

        thread_pool->threads[thread_pool->count].client_socket = client_socket;

        thread_pool->threads[thread_pool->count].client_count = client_count;

        // 增加线程池中线程的数量

        thread_pool->count++;

        // 通知管理者线程有新的客户端连接

        pthread_cond_signal(&thread_pool->cond);

        // 释放线程池锁

        pthread_mutex_unlock(&thread_pool->lock);

        printf("Client %d connected\n", client_count);

        client_count++;

    }

    // 等待管理者线程结束

    pthread_join(manager_tid, NULL);

    // 关闭服务器套接字

    close(server_socket);

    // 销毁线程池

    destroy_thread_pool(thread_pool);

    return 0;

}