套接字通信(C/C++ 多线程)----基于线程池的并发服务器

（一）大家可以看我写的这三篇，了解一下： 

基于linux下的高并发服务器开发（第四章）- 多线程实现并发服务器_呵呵哒(￣▽￣)"的博客-CSDN博客https://blog.csdn.net/weixin_41987016/article/details/132026417?spm=1001.2014.3001.5501

手写线程池 - C语言版 - 笔记总结_呵呵哒(￣▽￣)"的博客-CSDN博客https://blog.csdn.net/weixin_41987016/article/details/131926834?spm=1001.2014.3001.5501

基于多线程实现服务器并发_呵呵哒(￣▽￣)"的博客-CSDN博客https://blog.csdn.net/weixin_41987016/article/details/132047357?spm=1001.2014.3001.5501

（二）在套接字服务器端使用线程池的思路：

        两类任务需要处理：第一类任务就是和客户端建立连接，第二类任务就是和客户端建立连接之后进行数据通信，所以可以把与客户端建立连接抽象出一个函数，和客户端进行通信抽象一个函数。

        那么在通信的过程中，线程有多少个是由谁来管理呢？其实是由管理者线程来维护的。综上所述，如果我们使用了线程池，不管是和客户端建立连接，还是和客户端进行通信，其实都是由工作的线程来完成的。除此之外，工作的线程和管理者线程其实他们都是子线程。如果他们都是子线程，那么程序中的这个主线程干什么事情呢？其实在程序里的主线程，它只需要把监听的套接字创建出来，然后进行绑定，设置监听，接着把这个线程池对象创建出来。然后把这个接受客户端连接的任务放到线程池里边，主线程的使命其实就算是完成了。这个时候我们就可以让主线程退出了。【pthread_exit(NULL);】如果单纯的让主线程退出，也不会影响子线程的执行。这个子线程就是线程池里边所有的线程，基于这些线程池里边运行的线程就可以和客户端建立连接，并且和客户端进行通信。

（三）使用多线程和使用线程池在逻辑上是有一些区别的：

如果直接编写多线程程序，需要在这个主线程里边去做一个accept操作，在这个子线程里边去做通信。但是如果使用了线程池里边的主线程，这个主线程主要负责把线程池创建出来，在线程池里边的n个子线程就负责和客户端建立连接，并且和建立连接成功的客户端进行通信。这些都是由线程池里边的这n个工作的子线程来完成的。线程池里边这个子线程的创建和销毁，都是由线程池里边的这个管理者线程来维护的。这一点是手写线程池和使用线程池思路上有一些区别的地方。

（1）主线程需要完成的任务：

1.创建监听的套接字 lfd

int lfd = socket(AF_INET,SOCK_STREAM,0);
if(lfd == -1) {
	perror("socket");
	exit(-1);
}

2.绑定本地的IP port

// 2.绑定本地的IP port
struct sockaddr_in saddr;
saddr.sin_family = AF_INET;
saddr.sin_port = htons(9999);//主机字节序转换成网络字节序
saddr.sin_addr.s_addr = INADDR_ANY;// 0 = 0.0.0.0 对于0来说，大端和小端是没有区别的的，因此不需要转换

int ret = bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));
if(ret == -1) {
	perror("bind");
	exit(-1);
}

3.设置监听

ret = listen(lfd,128);
if(ret == -1) {
	perror("listen");
	exit(-1);
}

4.创建线程池

// 创建线程池 
ThreadPool* pool =threadPoolCreate(3,8,100);
PoolInfo* info = (PoolInfo*)malloc(sizeof(PoolInfo));
info->pool = pool;
info->fd = lfd;

5.给线程池添加任务 

threadPoolAdd(pool,acceptConn,info);

         给线程池添加任务 （让线程池里边的线程去检测有没有新的客户端连接）因此把这个任务需要的信息放到了一块堆内存里面 :PoolInfo* info = (PoolInfo*)malloc(sizeof(PoolInfo));这个堆内存什么时候被释放呢？当这个acceptConn函数执行完毕之后，它就会把info这块内存释放掉了。主线程完成添加任务操作之后，我们就让主线程退出了。

6.主线程退出

pthread_exit(NULL);

         到此为止，主线程的使命已经结束，我们可以让主线程退出，剩下的所有任务都是由子线程来做的。（这个子线程就是线程池里边的线程）通过pthread_exit(NULL);调用，它只会让当前的线程退出，并不会影响其他线程的运行。也就是说主线程退出了，它并不会影响线程池里边所有的线程的运行。

        咱们写的这个线程池里边并没有对线程进行销毁操作，因为我们线程池里边的这些任务函数他们执行的是一个死循环，也就意味着你不认为的去终止这些线程池里边的线程执行的任务，是不能执行完毕的，是停不了的。因此在这里就不做销毁了。在正常的项目里的任务肯定是由终止的时刻的，当任务终止了之后，就需要把相关的资源全部释放掉。那么这种关于子线程的任务函数也就执行完毕了。

（2）子线程需要完成的任务：

先准备相关结构体

// 信息结构体
typedef struct SockInfo {
    struct sockaddr_in addr;
    int fd;
}SockInfo;

typedef struct PoolInfo{
    ThreadPool* pool;
    int fd;
}PoolInfo;

1.与客户端建立连接

void acceptConn(void* arg) {
    PoolInfo* poolInfo = (PoolInfo*)arg;
    // 4.阻塞并等待客户端的连接
    int addrlen = sizeof(struct sockaddr_in);
    while (1)
    {
        SockInfo* pinfo;
        pinfo = (SockInfo*)malloc(sizeof(SockInfo));
        pinfo->fd = accept(poolInfo->fd,(struct sockaddr*)&pinfo->addr,&addrlen);
        if(pinfo->fd == -1) {
            perror("accept");
            break;
        }
        // 添加通信的任务
        threadPoolAdd(poolInfo->pool,working,pinfo);
    }
    // 把用于监听的文件描述符给关掉
    close(poolInfo->fd);
}

2.和客户端进行通信

void working(void* arg) {
    struct SockInfo* pinfo = (struct SockInfo*)arg;
    // 连接建立成功，打印客户端的IP和端口信息
    char ip[32];
    
    printf("客户端的IP: %s,端口: %d\n",
            inet_ntop(AF_INET,&pinfo->addr.sin_addr.s_addr,ip,sizeof(ip)),
            ntohs(pinfo->addr.sin_port));
    
    // 5.通信
    while(1) {
        // 接收数据
        char buff[1024];
        int len = recv(pinfo->fd,buff,sizeof(buff),0);
        if(len > 0) {
            printf("client say: %s\n",buff);
            send(pinfo->fd,buff,len,0);
        }else if(len == 0) {
            printf("客户端已经断开了连接...\n");
            break;
        }else{
            perror("recv");
            break;
        }
    }
    
    // 关掉文件描述符
    close(pinfo->fd);
    // 当任务执行完成之后，会在线程池里边销毁pinfo指向的内存
}

完整代码：

server.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include "threadpool.h"

// 信息结构体
typedef struct SockInfo {
    struct sockaddr_in addr;
    int fd;
}SockInfo;

typedef struct PoolInfo{
    ThreadPool* pool;
    int fd;
}PoolInfo;


void working(void* arg);
void acceptConn(void* arg);

int main() {
    // 1.创建监听的套接字 lfd
    int lfd = socket(AF_INET,SOCK_STREAM,0);
    if(lfd == -1) {
        perror("socket");
        exit(-1);
    }
    // 2.绑定本地的IP port
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);//主机字节序转换成网络字节序
    saddr.sin_addr.s_addr = INADDR_ANY;// 0 = 0.0.0.0 对于0来说，大端和小端是没有区别的的，因此不需要转换

    int ret = bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));
    if(ret == -1) {
        perror("bind");
        exit(-1);
    }

    // 3.设置监听
    ret = listen(lfd,128);
    if(ret == -1) {
        perror("listen");
        exit(-1);
    }

    // 创建线程池 
    ThreadPool* pool =threadPoolCreate(3,8,100);
    PoolInfo* info = (PoolInfo*)malloc(sizeof(PoolInfo));
    info->pool = pool;
    info->fd = lfd;
    threadPoolAdd(pool,acceptConn,info);
    pthread_exit(NULL);
    return 0;
}

void acceptConn(void* arg) {
    PoolInfo* poolInfo = (PoolInfo*)arg;
    // 4.阻塞并等待客户端的连接
    int addrlen = sizeof(struct sockaddr_in);
    while (1)
    {
        SockInfo* pinfo;
        pinfo = (SockInfo*)malloc(sizeof(SockInfo));
        pinfo->fd = accept(poolInfo->fd,(struct sockaddr*)&pinfo->addr,&addrlen);
        if(pinfo->fd == -1) {
            perror("accept");
            break;
        }
        // 添加通信的任务
        threadPoolAdd(poolInfo->pool,working,pinfo);
    }
    // 把用于监听的文件描述符给关掉
    close(poolInfo->fd);
}

void working(void* arg) {
    struct SockInfo* pinfo = (struct SockInfo*)arg;
    // 连接建立成功，打印客户端的IP和端口信息
    char ip[32];
    
    printf("客户端的IP: %s,端口: %d\n",
            inet_ntop(AF_INET,&pinfo->addr.sin_addr.s_addr,ip,sizeof(ip)),
            ntohs(pinfo->addr.sin_port));
    
    // 5.通信
    while(1) {
        // 接收数据
        char buff[1024];
        int len = recv(pinfo->fd,buff,sizeof(buff),0);
        if(len > 0) {
            printf("client say: %s\n",buff);
            send(pinfo->fd,buff,len,0);
        }else if(len == 0) {
            printf("客户端已经断开了连接...\n");
            break;
        }else{
            perror("recv");
            break;
        }
    }
    
    // 关掉文件描述符
    close(pinfo->fd);
    // 当任务执行完成之后，会在线程池里边销毁pinfo指向的内存
}

client.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>

int main() {
    // 1.创建套接字
    int fd = socket(AF_INET,SOCK_STREAM,0);
    if(fd == -1) {
        perror("socket");
        return -1;
    }

    // 2.连接服务器IP port
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    inet_pton(AF_INET,"192.168.88.129",&saddr.sin_addr.s_addr);
    int ret = connect(fd,(struct sockaddr*)&saddr,sizeof(saddr));
    if(ret == -1) {
        perror("connect");
        return -1;
    }

    int number = 0;
    // 3.通信
    while(1) {
        // 发送数据
        char buff[1024];
        sprintf(buff,"你好，呵呵哒,%d...\n",number++);
        send(fd,buff,strlen(buff) + 1,0);

        //接收数据
        memset(buff,0,sizeof(buff));
        int len = recv(fd,buff,sizeof(buff),0);
        if(len > 0) {
            printf("server say: %s\n",buff);
        }else if(len == 0) {
            printf("服务器已经断开了连接...\n");
            break;
        }else{
            perror("recv");
        }
        sleep(1);
    }
    // 关闭文件描述符
    close(fd);
    return 0;
}

threadpool.h

#ifndef _THREADPOOL_H
#define _THREADPOOL_H
 
typedef struct ThreadPool ThreadPool;
// 创建线程池并初始化
ThreadPool *threadPoolCreate(int min, int max, int queueCapacity);
 
// 销毁线程池
int threadPoolDestroy(ThreadPool* pool);
 
// 给线程池添加任务
void threadPoolAdd(ThreadPool* pool, void(*func)(void*), void* arg);
 
// 获取线程池中工作的线程的个数
int threadPoolBusyNum(ThreadPool* pool);
 
// 获取线程池中活着的线程的个数
int threadPoolAliveNum(ThreadPool* pool);
 
//
// 工作的线程(消费者线程)任务函数
void* worker(void* arg);
// 管理者线程任务函数
void* manager(void* arg);
// 单个线程退出
void threadExit(ThreadPool* pool);
#endif  // _THREADPOOL_H

threadpool.c

#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "threadpool.h"
const int NUMBER = 2;
 
// 任务结构体
typedef struct Task
{
    void (*function)(void* arg);
    void* arg;
}Task;
 
// 线程池结构体
struct ThreadPool
{
    // 任务队列
    Task* taskQ;
    int queueCapacity;  // 容量
    int queueSize;      // 当前任务个数
    int queueFront;     // 队头 -> 取数据
    int queueRear;      // 队尾 -> 放数据
 
    pthread_t managerID;    // 管理者线程ID
    pthread_t *threadIDs;   // 工作的线程ID
    int minNum;             // 最小线程数量
    int maxNum;             // 最大线程数量
    int busyNum;            // 忙的线程的个数
    int liveNum;            // 存活的线程的个数
    int exitNum;            // 要销毁的线程个数
    pthread_mutex_t mutexPool;  // 锁整个的线程池
    pthread_mutex_t mutexBusy;  // 锁busyNum变量
    pthread_cond_t notFull;     // 任务队列是不是满了
    pthread_cond_t notEmpty;    // 任务队列是不是空了
 
    int shutdown;           // 是不是要销毁线程池, 销毁为1, 不销毁为0
};
 
// 创建线程池并初始化
ThreadPool* threadPoolCreate(int min, int max, int queueCapacity)
{
    ThreadPool* pool = (ThreadPool*)malloc(sizeof(ThreadPool));
    do 
    {
        if (pool == NULL)
        {
            printf("malloc threadpool fail...\n");
            break;
        }
 
        pool->threadIDs = (pthread_t*)malloc(sizeof(pthread_t) * max);
        if (pool->threadIDs == NULL)
        {
            printf("malloc threadIDs fail...\n");
            break;
        }
        memset(pool->threadIDs, 0, sizeof(pthread_t) * max);
        pool->minNum = min;
        pool->maxNum = max;
        pool->busyNum = 0;
        pool->liveNum = min;    // 和最小个数相等
        pool->exitNum = 0;
 
        if (pthread_mutex_init(&pool->mutexPool, NULL) != 0 ||
            pthread_mutex_init(&pool->mutexBusy, NULL) != 0 ||
            pthread_cond_init(&pool->notEmpty, NULL) != 0 ||
            pthread_cond_init(&pool->notFull, NULL) != 0)
        {
            printf("mutex or condition init fail...\n");
            break;
        }
 
        // 任务队列
        pool->taskQ = (Task*)malloc(sizeof(Task) * queueCapacity);
        pool->queueCapacity = queueCapacity;
        pool->queueSize = 0;
        pool->queueFront = 0;
        pool->queueRear = 0;
 
        pool->shutdown = 0;
 
        // 创建线程
        pthread_create(&pool->managerID, NULL, manager, pool);
        for (int i = 0; i < min; ++i)
        {
            pthread_create(&pool->threadIDs[i], NULL, worker, pool);
        }
        return pool;
    } while (0);
 
    // 释放资源
    if (pool && pool->threadIDs) free(pool->threadIDs);
    if (pool && pool->taskQ) free(pool->taskQ);
    if (pool) free(pool);
 
    return NULL;
}
 
// 销毁线程池
int threadPoolDestroy(ThreadPool* pool)
{
    if (pool == NULL)
    {
        return -1;
    }
 
    // 关闭线程池
    pool->shutdown = 1;
    // 阻塞回收管理者线程
    pthread_join(pool->managerID, NULL);
    // 唤醒阻塞的消费者线程
    for (int i = 0; i < pool->liveNum; ++i)
    {
        pthread_cond_signal(&pool->notEmpty);
    }
    // 释放堆内存
    if (pool->taskQ)
    {
        free(pool->taskQ);
    }
    if (pool->threadIDs)
    {
        free(pool->threadIDs);
    }
 
    pthread_mutex_destroy(&pool->mutexPool);
    pthread_mutex_destroy(&pool->mutexBusy);
    pthread_cond_destroy(&pool->notEmpty);
    pthread_cond_destroy(&pool->notFull);
 
    free(pool);
    pool = NULL;
 
    return 0;
}
 
// 给线程池添加任务
void threadPoolAdd(ThreadPool* pool, void(*func)(void*), void* arg)
{
    pthread_mutex_lock(&pool->mutexPool);
    while (pool->queueSize == pool->queueCapacity && !pool->shutdown)
    {
        // 阻塞生产者线程
        pthread_cond_wait(&pool->notFull, &pool->mutexPool);
    }
    if (pool->shutdown)
    {
        pthread_mutex_unlock(&pool->mutexPool);
        return;
    }
    // 添加任务
    pool->taskQ[pool->queueRear].function = func;
    pool->taskQ[pool->queueRear].arg = arg;
    pool->queueRear = (pool->queueRear + 1) % pool->queueCapacity;
    pool->queueSize++;
 
    pthread_cond_signal(&pool->notEmpty);
    pthread_mutex_unlock(&pool->mutexPool);
}
 
// 获取线程池中工作的线程的个数
int threadPoolBusyNum(ThreadPool* pool)
{
    pthread_mutex_lock(&pool->mutexBusy);
    int busyNum = pool->busyNum;
    pthread_mutex_unlock(&pool->mutexBusy);
    return busyNum;
}
 
// 获取线程池中活着的线程的个数
int threadPoolAliveNum(ThreadPool* pool)
{
    pthread_mutex_lock(&pool->mutexPool);
    int aliveNum = pool->liveNum;
    pthread_mutex_unlock(&pool->mutexPool);
    return aliveNum;
}
 
// 工作的线程(消费者线程)任务函数
void* worker(void* arg)
{
    ThreadPool* pool = (ThreadPool*)arg;
 
    while (1)
    {
        pthread_mutex_lock(&pool->mutexPool);
        // 当前任务队列是否为空
        while (pool->queueSize == 0 && !pool->shutdown)
        {
            // 阻塞工作线程
            pthread_cond_wait(&pool->notEmpty, &pool->mutexPool);
 
            // 判断是不是要销毁线程
            if (pool->exitNum > 0)
            {
                pool->exitNum--;
                if (pool->liveNum > pool->minNum)
                {
                    pool->liveNum--;
                    pthread_mutex_unlock(&pool->mutexPool);
                    threadExit(pool);
                }
            }
        }
 
        // 判断线程池是否被关闭了
        if (pool->shutdown)
        {
            pthread_mutex_unlock(&pool->mutexPool);
            threadExit(pool);
        }
 
        // 从任务队列中取出一个任务
        Task task;
        task.function = pool->taskQ[pool->queueFront].function;
        task.arg = pool->taskQ[pool->queueFront].arg;
        // 移动头结点
        pool->queueFront = (pool->queueFront + 1) % pool->queueCapacity;
        pool->queueSize--;
        // 解锁
        pthread_cond_signal(&pool->notFull);
        pthread_mutex_unlock(&pool->mutexPool);
 
        printf("thread %ld start working...\n", pthread_self());
        pthread_mutex_lock(&pool->mutexBusy);
        pool->busyNum++;
        pthread_mutex_unlock(&pool->mutexBusy);
        task.function(task.arg);
        free(task.arg);
        task.arg = NULL;
 
        printf("thread %ld end working...\n", pthread_self());
        pthread_mutex_lock(&pool->mutexBusy);
        pool->busyNum--;
        pthread_mutex_unlock(&pool->mutexBusy);
    }
    return NULL;
}
 
// 管理者线程任务函数
void* manager(void* arg)
{
    ThreadPool* pool = (ThreadPool*)arg;
    while (!pool->shutdown)
    {
        // 每隔3s检测一次
        sleep(3);
 
        // 取出线程池中任务的数量和当前线程的数量
        pthread_mutex_lock(&pool->mutexPool);
        int queueSize = pool->queueSize;
        int liveNum = pool->liveNum;
        pthread_mutex_unlock(&pool->mutexPool);
 
        // 取出忙的线程的数量
        pthread_mutex_lock(&pool->mutexBusy);
        int busyNum = pool->busyNum;
        pthread_mutex_unlock(&pool->mutexBusy);
 
        // 添加线程
        // 任务的个数>存活的线程个数-忙的线程 && 存活的线程数<最大线程数
        if (queueSize > liveNum-busyNum && liveNum < pool->maxNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            int counter = 0;
            for (int i = 0; i < pool->maxNum && counter < NUMBER
                && pool->liveNum < pool->maxNum; ++i)
            {
                if (pool->threadIDs[i] == 0)
                {
                    pthread_create(&pool->threadIDs[i], NULL, worker, pool);
                    counter++;
                    pool->liveNum++;
                }
            }
            pthread_mutex_unlock(&pool->mutexPool);
        }
        // 销毁线程
        // 忙的线程*2 < 存活的线程数 && 存活的线程>最小线程数
        if (busyNum * 2 < liveNum && liveNum > pool->minNum)
        {
            pthread_mutex_lock(&pool->mutexPool);
            pool->exitNum = NUMBER;
            pthread_mutex_unlock(&pool->mutexPool);
            // 让工作的线程自杀
            for (int i = 0; i < NUMBER; ++i)
            {
                pthread_cond_signal(&pool->notEmpty);
            }
        }
    }
    return NULL;
}
 
// 单个线程退出
void threadExit(ThreadPool* pool)
{
    pthread_t tid = pthread_self();
    for (int i = 0; i < pool->maxNum; ++i)
    {
        if (pool->threadIDs[i] == tid)
        {
            pool->threadIDs[i] = 0;
            printf("threadExit() called, %ld exiting...\n", tid);
            break;
        }
    }
    pthread_exit(NULL);
}

运行效果：

gcc server.c threadpool.c -lpthread -o server

./server
heheda@heheda:~/Linux/DB_teacher$ ./server
thread 140278235014912 start working...
thread 140278218229504 start working...
客户端的IP: 192.168.88.129,端口: 50356
client say: 你好，呵呵哒,0...

client say: 你好，呵呵哒,1...

client say: 你好，呵呵哒,2...

thread 140278226622208 start working...
客户端的IP: 192.168.88.129,端口: 50362
client say: 你好，呵呵哒,0...

client say: 你好，呵呵哒,3...

client say: 你好，呵呵哒,1...

client say: 你好，呵呵哒,4...

client say: 你好，呵呵哒,2...

client say: 你好，呵呵哒,5...

client say: 你好，呵呵哒,3...

thread 140278207641344 start working...
客户端的IP: 192.168.88.129,端口: 50378
client say: 你好，呵呵哒,0...

client say: 你好，呵呵哒,6...

client say: 你好，呵呵哒,4...

client say: 你好，呵呵哒,1...

client say: 你好，呵呵哒,7...

client say: 你好，呵呵哒,5...

client say: 你好，呵呵哒,2...

client say: 你好，呵呵哒,8...

thread 140278128178944 start working...
客户端的IP: 192.168.88.129,端口: 58904
client say: 你好，呵呵哒,0...

client say: 你好，呵呵哒,6...

client say: 你好，呵呵哒,3...

client say: 你好，呵呵哒,9...

client say: 你好，呵呵哒,1...

client say: 你好，呵呵哒,7...

client say: 你好，呵呵哒,4...

client say: 你好，呵呵哒,10...

client say: 你好，呵呵哒,2...

client say: 你好，呵呵哒,8...

client say: 你好，呵呵哒,5...

client say: 你好，呵呵哒,11...

client say: 你好，呵呵哒,3...

client say: 你好，呵呵哒,9...

client say: 你好，呵呵哒,6...

client say: 你好，呵呵哒,12...

client say: 你好，呵呵哒,4...

client say: 你好，呵呵哒,10...

client say: 你好，呵呵哒,7...

client say: 你好，呵呵哒,13...

client say: 你好，呵呵哒,5...

client say: 你好，呵呵哒,11...

client say: 你好，呵呵哒,8...

client say: 你好，呵呵哒,14...

client say: 你好，呵呵哒,6...

client say: 你好，呵呵哒,12...

client say: 你好，呵呵哒,9...

client say: 你好，呵呵哒,15...

client say: 你好，呵呵哒,7...

client say: 你好，呵呵哒,13...

client say: 你好，呵呵哒,10...

client say: 你好，呵呵哒,16...

client say: 你好，呵呵哒,8...

client say: 你好，呵呵哒,14...

client say: 你好，呵呵哒,11...

client say: 你好，呵呵哒,17...

client say: 你好，呵呵哒,9...

client say: 你好，呵呵哒,15...

client say: 你好，呵呵哒,12...

client say: 你好，呵呵哒,18...

client say: 你好，呵呵哒,10...

client say: 你好，呵呵哒,16...

client say: 你好，呵呵哒,13...

client say: 你好，呵呵哒,19...

client say: 你好，呵呵哒,11...

client say: 你好，呵呵哒,17...

client say: 你好，呵呵哒,14...

client say: 你好，呵呵哒,20...

client say: 你好，呵呵哒,12...

client say: 你好，呵呵哒,18...

client say: 你好，呵呵哒,15...

客户端已经断开了连接...
thread 140278218229504 end working...
client say: 你好，呵呵哒,13...

client say: 你好，呵呵哒,19...

client say: 你好，呵呵哒,16...

client say: 你好，呵呵哒,14...

客户端已经断开了连接...
thread 140278226622208 end working...
client say: 你好，呵呵哒,17...

client say: 你好，呵呵哒,15...

client say: 你好，呵呵哒,18...

客户端已经断开了连接...
thread 140278207641344 end working...
client say: 你好，呵呵哒,16...

client say: 你好，呵呵哒,17...

客户端已经断开了连接...
thread 140278128178944 end working...
threadExit() called, 140278218229504 exiting...
threadExit() called, 140278226622208 exiting...

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/55319.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【JavaWeb】Javascript经典案例

【JavaWeb】Javascript经典案例

Javascript经典案例 注意&#xff1a;该文章是参考b站<20个JS经典案例>进行学习的&#xff0c;没有CSS的组成。 在慢慢更新中…哈哈哈哈&#xff0c;太慢了 文章目录 1.支付定时器2.验证码生成及校验 1.支付定时器 代码实现&#xff1a; confirm.html <!DOCTYPE html…
阅读更多...
2.04 商品搜索功能实现

2.04 商品搜索功能实现

根据关键字获取分类查询对应的分页商品信息&#xff0c;并可以价格和销量进行排序切换 步骤1&#xff1a;mapper.xml编写sql语句 <!-- k: 默认&#xff0c;代表默认排序&#xff0c;根据name--> <!-- c: 根据销量排序--> <!-- p: 根据价格排序--> <sel…
阅读更多...
消息队列 - 数据库操作

消息队列 - 数据库操作

这里写自定义目录标题 前言数据表的插入删除操作关于实现接口类的几个注意实现实现封装创建DataBaseManager 类另一种获取Bean对象的方式 对数据库进行单元测试 前言 上一篇博客, 我们将消息队列的实体类创建完毕了, 并且还写了一些关于数据库的操作, 接下来我们继续进行关于数…
阅读更多...
Java throw和throws 关键字

Java throw和throws 关键字

在Java中&#xff0c;异常可以分为两种类型&#xff1a; 未检查的异常&#xff1a;它们不是在编译时而是在运行时被检查&#xff0c;例如&#xff1a;ArithmeticException&#xff0c;NullPointerException&#xff0c;ArrayIndexOutOfBoundsException&#xff0c;Error类下的异…
阅读更多...
wordpress 学习贴

wordpress 学习贴

安装问题 我的使用环境为docker环境&#xff0c;php、nginx、mysql分别处于3个容器中&#xff0c; 提示异常&#xff0c;打开debug模式&#xff0c;会发现 No such file or directory Warning: mysqli_real_connect(): (HY000/2002): No such file or directory 这个其实问题其…
阅读更多...
Linux操作系统3-项目部署

Linux操作系统3-项目部署

手动部署 步骤 1.在idea中将文件项目进行打包 2.自定义一个文件目录&#xff0c;上传到Linux 3.使用 java -jar jar包名就可以进行运行 注意,如果需要启动该项目&#xff0c;需要确定所需的端口是否打开 采用这种方式&#xff0c;程序运行的时候会出现霸屏&#xff0c;并且会…
阅读更多...
最近写了10篇Java技术博客【SQL和画图组件】

最近写了10篇Java技术博客【SQL和画图组件】

&#xff08;1&#xff09;Java获取SQL语句中的表名 &#xff08;2&#xff09;Java SQL 解析器实践 &#xff08;3&#xff09;Java SQL 格式化实践 &#xff08;4&#xff09;Java 画图 画图组件jgraphx项目整体介绍&#xff08;一&#xff09; 画图组件jgraphx项目导出…
阅读更多...
计算机毕设 深度学习实现行人重识别 - python opencv yolo Reid

计算机毕设 深度学习实现行人重识别 - python opencv yolo Reid

文章目录 0 前言1 课题背景2 效果展示3 行人检测4 行人重识别5 其他工具6 最后 0 前言 &#x1f525; 这两年开始毕业设计和毕业答辩的要求和难度不断提升&#xff0c;传统的毕设题目缺少创新和亮点&#xff0c;往往达不到毕业答辩的要求&#xff0c;这两年不断有学弟学妹告诉…
阅读更多...
二阶段web基础与http协议

二阶段web基础与http协议

dns与域名 网络是基于tcp/ip协议进行通信和连接的 应用层-----传输层-----网络层-----数据链路层-----物理层 ip地址&#xff0c;每一台主机都有一个唯一的地址标识&#xff08;固定的ip地址&#xff09; 1.区分用户和计算机 2.通信 ip地址的问题在于32位二进制数组成的&…
阅读更多...
【安装vue脚手架报错：npm install -g @vue-cli pm ERR! code EINVALIDTAGNAME 】

【安装vue脚手架报错：npm install -g @vue-cli pm ERR! code EINVALIDTAGNAME 】

当我们执行npm install -g vue-cli时候会报错&#xff1a; npm ERR! Invalid tag name “vue-cli” of package “vue-cli”: Tags may not have any characters that encodeURIComponent encodes. npm ERR! A complete log of this run can be found in: /Users/wuwenlu/.npm/…
阅读更多...
Centos虚拟机修改密码

Centos虚拟机修改密码

1.重启系统 2.在这个选择界面&#xff0c;按e 3.找到如下位置&#xff0c;插入init/bin/sh 4.填写完成后按Ctrlx引导启动 5.输入mount -o remount, rw / (注意空格) 6.重置密码 出现以下为重置成功 7.执行touch /.autorelabel 8.退出exec /sbin/init 9.输入你的新密码…
阅读更多...
React入门学习笔记1

React入门学习笔记1

前言 React是一个用来动态构0建用户界面的JavaScript库&#xff08;只关注于视图&#xff09;。它可以帮助开发人员轻松地创建复杂的交互式界面&#xff0c;以及管理与用户交互的状态。相比于其他的JavaScript框架&#xff0c;React采用了一种不同的编程模型&#xff0c;称为“…
阅读更多...
【BASH】回顾与知识点梳理（二）

【BASH】回顾与知识点梳理（二）

【BASH】回顾与知识点梳理 二 二. Shell 的变量功能2.1 什么是变量&#xff1f;2.2 变量的取用与设定: echo, 变量设定规则: set/unset2.3 环境变量的功能用 set 观察所有变量 (含环境变量与自定义变量)export&#xff1a; 自定义变量转成环境变量那如何将环境变量转成自定义变…
阅读更多...
《向量数据库指南》——当前向量数据库的赛道有哪些？

《向量数据库指南》——当前向量数据库的赛道有哪些？

当前&#xff0c;向量数据库赛道主要分为四个类别&#xff1a; 基于PG、Clickhouse 等进行魔改或者插件化实现的向量数据库&#xff1a;这类解决方案以现有的关系数据库或列存数据库作为基础&#xff0c;通过修改或插件扩展的方式添加向量搜索功能。PG Vector 是这类解决方案的…
阅读更多...
【设计模式——学习笔记】23种设计模式——外观模式Facade（原理讲解+应用场景介绍+案例介绍+Java代码实现）

【设计模式——学习笔记】23种设计模式——外观模式Facade（原理讲解+应用场景介绍+案例介绍+Java代码实现）

文章目录 案例引入介绍基本介绍类图出场角色 案例实现案例一类图代码实现 案例二类图代码实现 外观模式在Mybatis源码中的应用总结文章说明 案例引入 在家庭影院中&#xff0c;要享受一场电影&#xff0c;需要如下步骤&#xff1a; 直接用遥控器&#xff1a;统筹各设备开关开…
阅读更多...
Linux - 进程控制(进程替换)

Linux - 进程控制(进程替换)

0.引入 创建子进程的目的是什么&#xff1f; 就是为了让子进程帮我执行特定的任务 让子进程执行父进程的一部分代码 如果子进程想执行一个全新的程序代码呢&#xff1f; 那么就要使用 进程的程序替换 为什么要有程序替换&#xff1f; 也就是说子进程想执行一个全新的程序代码&a…
阅读更多...
FSM：Full Surround Monodepth from Multiple Cameras

FSM：Full Surround Monodepth from Multiple Cameras

参考代码&#xff1a;None 介绍 深度估计任务作为基础环境感知任务&#xff0c;在基础上构建的3D感知才能更加准确&#xff0c;并且泛化能力更强。单目的自监督深度估计已经有MonoDepth、ManyDepth这些经典深度估计模型了&#xff0c;而这篇文章是对多目自监督深度估计进行探…
阅读更多...
three.js实现vr全景图

three.js实现vr全景图

方法: 可以利用Threejs中的立方体或者球体实现全景图功能&#xff0c;把立方体或球体当成天空盒子&#xff0c;将无缝衔接的图片贴上&#xff0c;看起来就像在一个场景中&#xff0c;相机一般放置在中央。 three.js中文网 1、立方体实现 立方体6个面要贴上6个方向的图片&…
阅读更多...
Pytorch深度学习-----神经网络之非线性激活的使用(ReLu、Sigmoid)

Pytorch深度学习-----神经网络之非线性激活的使用(ReLu、Sigmoid)

系列文章目录 PyTorch深度学习——Anaconda和PyTorch安装 Pytorch深度学习-----数据模块Dataset类 Pytorch深度学习------TensorBoard的使用 Pytorch深度学习------Torchvision中Transforms的使用&#xff08;ToTensor&#xff0c;Normalize&#xff0c;Resize &#xff0c;Co…
阅读更多...
html：去除input/textarea标签的拼写检查

html：去除input/textarea标签的拼写检查

默认情况下&#xff0c;textarea 会启动拼写和语法检查&#xff0c;表现效果就是单词拼写错误会出现红色下划线提示 <textarea></textarea>效果 有时&#xff0c;我们并不需要拼写检查&#xff0c;可以通过配置属性spellcheck"false" 去除拼写和语法检…
阅读更多...
最新文章

Copyright @ 2022~2023