《UNP》随笔——多线程服务器

文章目录

- 1. 线程的概念
- - 1.1 为何引入线程
  - 1.2 线程和进程的差异
- 2. 线程的使用
- - 2.1 线程的创建和执行
  - 1.3 工作（Worker）线程模式
- 2 线程存在的问题和临界区
- - 2.1 线程同步
  - 2.2 互斥量
  - 2.3信号量
- 3.线程的销毁和多线程并发服务器端的实现
- - 3.1 销毁线程的3种方法
  - 3.2 多线程服务器

1. 线程的概念 1.1 为何引入线程

已经学过多进程服务端的实现方法，多进程相比select和epoll相比的确有自身的优点，但同时也有自身的问题。创建（复制）进程的⼯作本⾝会给操作系统带来相当沉重的负担。而且，每个进程都具有独⽴的内存空间，所以进程间通信的实现难度也会随之提⾼。换⾔之，多进程的缺点可概括为：

创建进程的过程会带来一定的开销
为了完成进程间的数据交换，需要特殊的IPC(Inter-Process Communication)技术
每秒少则 10 次，多则千次的「上下⽂切换」是创建进程的最⼤开销

“上下⽂切换”是指运⾏程序前需要将相应进程信息读⼊内存，如果运⾏进程 A 后紧接着需要运⾏进程 B，就应该将进程 A 相关信息移出内存，并读⼊进程 B 相关信息。这就是上下⽂切换。但是此时进程 A 的数据将被移动到硬盘，所以上下⽂切换要很⻓时间，即使通过优化加快速度，也会存在⼀定的局限。

为了保持多进程的优点，同时在一定程度上克服多进程的缺点，于是引入了线程。这是为了将进程的
各种劣势降⾄最低程度（不是直接消除）而设⽴的⼀种「轻量级进程」。线程⽐进程具有如下优点：

线程的创建和上下文切换比进程的创建和上下文切换更快
线程间交换数据无需特殊技术

1.2 线程和进程的差异

线程是为了解决：为了得到多条代码执行流而复制整个内存区域的负担太重了。

每个进程的内存空间都由保存全局变量的「数据区」、向 malloc 等函数动态分配提供空间的堆（Heap）、函数运⾏时间使⽤的栈（Stack）构成。每个进程都有独⽴的这种空间，多个进程的内存结构如图所⽰：

但如果以获得多个代码执⾏流为⽬的，则不应该像上图那样完全分离内存结构，而只需分离栈区域。通过这种⽅式
可以获得如下优势：

上下文切换时不需要切换数据区和堆
可以利用数据区和堆来交换数据

如图所示，多个线程共享数据区和堆。为了保持这种结构，线程将在进程内创建并运行。也就是说，进程和线程可以定义如下：
进程：在操作系统构成单独执行流的单位
线程：在进程构成单独执行流的单位

因此，操作系统、进程、线程之间的关系可以表示为下图：

2. 线程的使用 2.1 线程的创建和执行

线程有单独的执行流，所有它应定义单独的main函数，还需要请求操作系统在单独的执行流中执行该函数，函数定义如下：

#include 

int pthread_create(pthread_t *restrict thread,
                   const pthread_attr_t *restrict attr,
                   void *(*start_routine)(void *),
                   void *restrict arg);

可通过下面这个例子了解该函数的功能：

#include 
#include 
#include 
void *thread_main(void *arg);

int main(int argc, char *argv[])
{
    pthread_t t_id;
    int thread_param = 5;
    // 请求创建一个线程，从 thread_main 调用开始，在单独的执行流中运行。同时传递参数
    if (pthread_create(&t_id, NULL, thread_main, (void *)&thread_param) != 0)
    {
        puts("pthread_create() error");
        return -1;
    }
    sleep(10); //延迟进程终止时间
    puts("end of main");
    return 0;
}
void *thread_main(void *arg) //传入的参数是 pthread_create 的第四个
{
    int i;
    int cnt = *((int *)arg);
    for (int i = 0; i < cnt; i++)
    {
        sleep(1);
        puts("running thread");
    }
    return NULL;
}

在linux上执行gcc thread1.c -o thread1, 结果出现编译错误undefined reference to ‘pthread_create’。原因是pthread库不是标准linux库，所以出错。改为gcc thread1.c -o thread1 -lpthread 即可。

这样就实现了线程的创建和运行，可以从函数参数来传入线程main函数的参数。并且主进程需要一直等待，如果主进程不等待的话，主进程结束，创建的线程也会被迫结束。如下图所示。

另外，如果我们想获得创建线程的返回的参数，那应该怎么办呢？
答案很简单，就是调用pthread_join函数，能够一同解决上述两个问题，其定义如下：

#include 
int pthread_join(pthread_t thread, void **status);

函数的作用就是调用该函数的进程（或线程）将进入等待状态，直到函数中的线程结束终止为止，并且可以得到该线程main函数的返回值，下面是该函数的用法：

#include 
#include 
#include 
#include 

void *thread_main(void *arg);

int main(int argc, char* argv[]){
    pthread_t t_id;
    int thread_param = 5;
    void *thr_ret;
    // 创建一个新的线程，线程的ID会传给 t_id， thread_param作为线程参数传入
    if(pthread_create(&t_id, NULL, thread_main, (void *)&thread_param) != 0){
        puts("pthread_create() error");
        return -1;
    }
    // main函数将等待 ID 保存在 t_id 变量中的线程终⽌
    if(pthread_join(t_id, &thr_ret) != 0){
        puts("pthread_join() error");
        return -1;
    }
    printf("Thread return message : %s n", (char *)thr_ret);
    free(thr_ret);
    return 0;
}

void* thread_main(void *arg){
    int i;
    int cnt = *((int *)arg);
    char* msg = (char *)malloc(sizeof(char) * 50);
    strcpy(msg, "Hello, I'm thread~ n");
    for(int i=0; i 
编译执行：
 
 可以看到，主进程并没有sleep等待，但线程依旧输出完五次字符串，并且获得了线程的返回值。下面是该函数的执行流程图：
  
1.3 工作（Worker）线程模式 
下面的示例是计算从 1 到 10 的和，但并不是通过 main 函数进行运算，而是创建两个线程，其中一个线程计算 1 到 5 的和，另一个线程计算 6 到 10 的和，main 函数只负责输出运算结果。这种方式的线程模型称为「工作线程」。显示该程序的执行流程图：
 
 代码： 
#include 
#include 
void *thread_summation(void *arg);
int sum = 0;

int main(int argc, char *argv[])
{
    pthread_t id_t1, id_t2;
    int range1[] = {1, 5};
    int range2[] = {6, 10};

    pthread_create(&id_t1, NULL, thread_summation, (void *)range1);
    pthread_create(&id_t2, NULL, thread_summation, (void *)range2);

    pthread_join(id_t1, NULL);
    pthread_join(id_t2, NULL);
    printf("result: %d n", sum);
    return 0;
}
void *thread_summation(void *arg)
{
    int start = ((int *)arg)[0];
    int end = ((int *)arg)[1];
    while (start <= end)
    {
        sum += start;
        start++;
    }
    return NULL;
}

 
编译运行：
 
 可以看出计算结果正确，两个线程都用了全局变量 sum ,证明了 2 个线程共享保存全局变量的数据区。 
但是本例子本身存在问题。存在临界区相关问题，可以从下面的代码看出，下面的代码和上面的代码相似，只是增加了发生临界区错误的可能性，即使在高配置系统环境下也容易产生的错误： 
#include 
#include 
#include 
#include 
#define NUM_THREAD 100

void *thread_inc(void *arg);
void *thread_des(void *arg);
long long num = 0;

int main(int argc, char *argv[])
{
    pthread_t thread_id[NUM_THREAD];
    int i;

    printf("sizeof long long: %d n", sizeof(long long));
    for (i = 0; i < NUM_THREAD; i++)
    {
        if (i % 2)
            pthread_create(&(thread_id[i]), NULL, thread_inc, NULL);
        else
            pthread_create(&(thread_id[i]), NULL, thread_des, NULL);
    }

    for (i = 0; i < NUM_THREAD; i++)
        pthread_join(thread_id[i], NULL);

    printf("result: %lld n", num);
    return 0;
}

void *thread_inc(void *arg)
{
    int i;
    for (i = 0; i < 50000000; i++)
        num += 1;
    return NULL;
}
void *thread_des(void *arg)
{
    int i;
    for (i = 0; i < 50000000; i++)
        num -= 1;
    return NULL;
}

 
编译运行：
 
 理论上来说，上面代码的最后结果应该是 0 。原因同时访问同一变量，会出现一定的问题 ，这对于线程的应用是个大问题。 
2 线程存在的问题和临界区 
 
 任何内存空间，只要被同时访问，都有可能发⽣问题。 
 
因此，线程访问变量 num 时应该阻⽌其他线程访问，直到线程 1 运算完成。这就是同步（Synchronization） 
2.1 线程同步 
需要同步的情况可以从下面两个方面考虑： 
同时访问同一内存空间时发生的情况
需要指定访问同一内存空间的线程顺序的情况 
情况一之前已经解释过，下面讨论情况二。这是「控制线程执行的顺序」的相关内容。假设有 A B 两个线程，线程 A 负责向指定的内存空间内写入数据，线程 B 负责取走该数据。所以这是有顺序的，不按照顺序就可能发生问题。所以这种也需要进行同步。 
2.2 互斥量 
互斥锁（Mutual exclusion，缩写Mutex）是一种用于多线程编程中，防止两条线程同时对同一公共资源（比如全栈变量）进行读写的机制。该目的通过将代码切片成一个一个的临界区域（critical section）达成。临界区域指的是一块对公共资源进行访问的代码，并非是一种机制或是算法。一个程序、进程、线程可以拥有多个临界区域，但是并不一定会应用互斥锁。 
通俗的说就互斥量就是⼀把优秀的锁，当临界区被占据的时候就上锁，等占⽤完毕然后再放开。 
下⾯是互斥量的创建及销毁函数。 
#include 
int pthread_mutex_init(pthread_mutex_t *mutex,
                       const pthread_mutexattr_t *attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);


 
从上述函数声明中可以看出，为了创建相当于锁系统的互斥量，需要声明如下 pthread_mutex_t 型变量： 
pthread_mutex_t mutex
 
该变量的地址值传递给 pthread_mutex_init 函数，用来保存操作系统创建的互斥量（锁系统）。调用 pthread_mutex_destroy 函数时同样需要该信息。如果不需要配置特殊的互斥量属性，则向第二个参数传递 NULL 时，可以利用 PTHREAD_MUTEX_INITIALIZER 进行如下声明： 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 
推荐尽可能的使用 pthread_mutex_init 函数进行初始化，因为通过宏进行初始化时很难发现发生的错误。 
下面是利用互斥量锁住或释放临界区时使用的函数。 
#include 
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

 
函数本身含有 lock unlock 等词汇，很容易理解其含义。进入临界区前调用的函数就是 pthread_mutex_lock 。调用该函数时，发现有其他线程已经进入临界区，则 pthread_mutex_lock 函数不会返回，直到里面的线程调用 pthread_mutex_unlock 函数退出临界区位置。也就是说，其他线程让出临界区之前，当前线程一直处于阻塞状态。接下来整理一下代码的编写方式： 
pthread_mutex_lock(&mutex);
//临界区开始
//...
//临界区结束
pthread_mutex_unlock(&mutex);
 
简言之，就是利用 lock 和 unlock 函数围住临界区的两端。此时互斥量相当于一把锁，阻止多个线程同时访问，还有一点要注意，线程退出临界区时，如果忘了调用 pthread_mutex_unlock 函数，那么其他为了进入临界区而调用 pthread_mutex_lock 的函数无法摆脱阻塞状态。这种情况称为「死锁」。需要格外注意，下面是利用互斥量解决1.3 节中遇到的问题代码： 
#include 
#include 
#include 
#include 
#define NUM_THREAD 100

void *thread_inc(void *arg);
void *thread_des(void *arg);
long long num = 0;

pthread_mutex_t mutex; // 保存互斥量读取值的变量

int main(int argc, char *argv[])
{
    pthread_t thread_id[NUM_THREAD];
    int i;

    pthread_mutex_init(&mutex, NULL); // 创建互斥量

    printf("sizeof long long: %ld n", sizeof(long long));
    for (i = 0; i < NUM_THREAD; i++)
    {
        if (i % 2)
            pthread_create(&(thread_id[i]), NULL, thread_inc, NULL);
        else
            pthread_create(&(thread_id[i]), NULL, thread_des, NULL);
    }

    for (i = 0; i < NUM_THREAD; i++)
        pthread_join(thread_id[i], NULL);

    printf("result: %lld n", num);
    return 0;
}

void *thread_inc(void *arg)
{
    int i;
    pthread_mutex_lock(&mutex); // 上锁
    for (i = 0; i < 50000000; i++)
        num += 1;
    pthread_mutex_unlock(&mutex); //解锁
    return NULL;
}
void *thread_des(void *arg)
{
    int i;
    pthread_mutex_lock(&mutex); // 上锁
    for (i = 0; i < 50000000; i++)
        num += 1;
    pthread_mutex_unlock(&mutex); //解锁
    return NULL;
}
 
编译运行：
 
 从运行结果可以看出，通过互斥量机制得出了正确的运行结果。 
在代码中： 
void *thread_inc(void *arg)
{
    int i;
    pthread_mutex_lock(&mutex); //上锁
    for (i = 0; i < 50000000; i++)
        num += 1;
    pthread_mutex_unlock(&mutex); //解锁
    return NULL;
}
 
以上代码的临界区划分范围较大，但这是考虑如下优点所做的决定: 
 
 最大限度减少互斥量 lock unlock 函数的调用次数 
 
2.3信号量 
信号量（英语：Semaphore）又称为信号标，是一个同步对象，用于保持在0至指定最大值之间的一个计数值。 
当线程完成一次对该semaphore对象的等待（wait）时，该计数值减一；
当线程完成一次对semaphore对象的释放（release）时，计数值加一。当计数值为0，则线程等待该semaphore对象不再能成功直至该semaphore对象变成signaled状态。
semaphore对象的计数值大于0，为signaled状态；
semaphore对象的计数值等于0，为nonsignaled状态。 
semaphore对象适用于控制一个仅支持有限个用户的共享资源，是一种不需要使用忙碌等待（busy waiting）的方法。 
在系统中，给予每一个进程一个信号量，代表每个进程当前的状态，未得到控制权的进程会在特定地方被强迫停下来，等待可以继续进行的信号到来。如果信号量是一个任意的整数，通常被称为计数信号量（Counting semaphore），或一般信号量（general semaphore）；如果信号量只有二进制的0或1，称为二进制信号量（binary semaphore）。在linux系统中，二进制信号量（binary semaphore）又称互斥锁（Mutex）。 
下面介绍信号量，在互斥量的基础上，很容易理解信号量。此处只涉及利用「二进制信号量」（只用 0 和 1）完成「控制线程顺序」为中心的同步方法。下面是信号量的创建及销毁方法： 
#include 
int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_destroy(sem_t *sem);

 
调用 sem_init 函数时，操作系统将创建信号量对象，此对象中记录这「信号量值」（Semaphore Value）整数。该值在调用 sem_post 函数时增加 1 ，调用 wait_wait 函数时减一。但信号量的值不能小于 0 ，因此，在信号量为 0 的情况下调用 sem_wait 函数时，调用的线程将进入阻塞状态（因为函数未返回）。当然，此时如果有其他线程调用 sem_post 函数，信号量的值将变为 1 ，而原本阻塞的线程可以将该信号重新减为 0 并跳出阻塞状态。实际上就是通过这种特性完成临界区的同步操作，可以通过如下形式同步临界区（假设信号量的初始值为 1） 
sem_wait(&sem);//信号量变为0...
// 临界区的开始
//...
//临界区的结束
sem_post(&sem);//信号量变为1...
 
上述代码结构中，调用 sem_wait 函数进入临界区的线程在调用 sem_post 函数前不允许其他线程进入临界区。信号量的值在 0 和 1 之间跳转，因此，具有这种特性的机制称为「二进制信号量」。接下来的代码是信号量机制的代码。下面代码并非是同时访问的同步，而是关于控制访问顺序的同步，该场景为： 
 
 线程 A 从用户输入得到值后存入全局变量 num ，此时线程 B 将取走该值并累加。该过程一共进行 5 次，完成后输出总和并退出程序。 
 
下面是针对1.3节的更改： 
#include 
#include 
#include 
#include 
#include 
#define NUM_THREAD 100

void *thread_inc(void *arg);
void *thread_des(void *arg);
long long num = 0;

static sem_t sem_one;
static sem_t sem_two;

int main(int argc, char *argv[])
{
    pthread_t thread_id[NUM_THREAD];
    int i;

    sem_init(&sem_one, 0, 0);
    sem_init(&sem_two, 0, 1);

    printf("sizeof long long: %ld n", sizeof(long long));
    for (i = 0; i < NUM_THREAD; i++)
    {
        if (i % 2)
            pthread_create(&(thread_id[i]), NULL, thread_inc, NULL);
        else
            pthread_create(&(thread_id[i]), NULL, thread_des, NULL);
    }

    for (i = 0; i < NUM_THREAD; i++)
        pthread_join(thread_id[i], NULL);

    printf("result: %lld n", num);
    return 0;
}

void *thread_inc(void *arg)
{
    int i;
    for (i = 0; i < 50000000; i++){
        sem_wait(&sem_two);
        num += 1;
        sem_post(&sem_one);
    }
    return NULL;
}
void *thread_des(void *arg)
{
    int i;
    for (i = 0; i < 50000000; i++){
        sem_wait(&sem_one);
        num -= 1;
        sem_post(&sem_two);
    }
    return NULL;
}

 
编译运行：
  
3.线程的销毁和多线程并发服务器端的实现 
3.1 销毁线程的3种方法 
Linux 的线程并不是在首次调用的线程 main 函数返回时自动销毁，所以利用如下方法之一加以明确。否则由线程创建的内存空间将一直存在。 
调用 pthread_join 函数
调用 pthread_detach 函数 
之前调用过 pthread_join 函数。调用该函数时，不仅会等待线程终止，还会引导线程销毁。但该函数的问题是，线程终止前，调用该函数的线程将进入阻塞状态。因此，通过如下函数调用引导线程销毁。 
#include 
int pthread_detach(pthread_t th);

 
调用上述函数不会引起线程终止或进入阻塞状态，可以通过该函数引导销毁线程创建的内存空间。调用该函数后不能再针对相应线程调用 pthread_join 函数。 
创建一个线程默认的状态是joinable, 如果一个线程结束运行但没有被join,则它的状态类似于进程中的Zombie Process,即还有一部分资源没有被回收（退出状态码），所以创建线程者应该调用pthread_join来等待线程运行结束，并可得到线程的退出代码，回收其资源（类似于wait,waitpid) 
但是调用pthread_join(pthread_id)后，如果该线程没有运行结束，调用者会被阻塞，在有些情况下我们并不希望如此，比如在Web服务器中当主线程为每个新来的链接创建一个子线程进行处理的时候，主线程并不希望因为调用pthread_join而阻塞（因为还要继续处理之后到来的链接），这时可以在子线程中加入代码 pthread_detach(pthread_self()) 或者父线程调用 pthread_detach(thread_id)（非阻塞，可立即返回） 这将该子线程的状态设置为detached,则该线程运行结束后会自动释放所有资源。 
3.2 多线程服务器 
服务器： 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define BUF_SIZE 100
#define MAX_CLNT 256

void *handle_clnt(void *arg);
void send_msg(char *msg, int len);
void error_handling(char *msg);

int clnt_cnt = 0;
int clnt_socks[MAX_CLNT];
pthread_mutex_t mutx;

int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;
    int clnt_adr_sz;
    pthread_t t_id;
    if (argc != 2)
    {
        printf("Usage : %s n", argv[0]);
        exit(1);
    }

    pthread_mutex_init(&mutx, NULL); //创建互斥锁
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);

    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_adr.sin_port = htons(atoi(argv[1]));

    if (bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("bind() error");
    if (listen(serv_sock, 5) == -1)
        error_handling("listen() error");

    while (1)
    {
        clnt_adr_sz = sizeof(clnt_adr);
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &clnt_adr_sz);

        pthread_mutex_lock(&mutx);          //上锁
        clnt_socks[clnt_cnt++] = clnt_sock; //写入新连接
        pthread_mutex_unlock(&mutx);        //解锁

        pthread_create(&t_id, NULL, handle_clnt, (void *)&clnt_sock);       //创建线程为新客户端服务，并且把clnt_sock作为参数传递
        pthread_detach(t_id);                                               //引导线程销毁，不阻塞
        printf("Connected client IP: %s n", inet_ntoa(clnt_adr.sin_addr)); //客户端连接的ip地址
    }
    close(serv_sock);
    return 0;
}

void *handle_clnt(void *arg)
{
    int clnt_sock = *((int *)arg);
    int str_len = 0, i;
    char msg[BUF_SIZE];

    while ((str_len = read(clnt_sock, msg, sizeof(msg))) != 0)
        send_msg(msg, str_len);
    //接收到消息为0，代表当前客户端已经断开连接
    pthread_mutex_lock(&mutx);
    for (i = 0; i < clnt_cnt; i++) //删除没有连接的客户端
    {
        if (clnt_sock == clnt_socks[i])
        {
            while (i++ < clnt_cnt - 1)
                clnt_socks[i] = clnt_socks[i + 1];
            break;
        }
    }
    clnt_cnt--;
    pthread_mutex_unlock(&mutx);
    close(clnt_sock);
    return NULL;
}
void send_msg(char *msg, int len) //向连接的所有客户端发送消息
{
    int i;
    pthread_mutex_lock(&mutx);
    for (i = 0; i < clnt_cnt; i++)
        write(clnt_socks[i], msg, len);
    pthread_mutex_unlock(&mutx);
}
void error_handling(char *msg)
{
    fputs(msg, stderr);
    fputc('n', stderr);
    exit(1);
}
 
客户端 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define BUF_SIZE 100
#define NAME_SIZE 20

void *send_msg(void *arg);
void *recv_msg(void *arg);
void error_handling(char *msg);

char name[NAME_SIZE] = "[DEFAULT]";
char msg[BUF_SIZE];

int main(int argc, char *argv[])
{
    int sock;
    struct sockaddr_in serv_addr;
    pthread_t snd_thread, rcv_thread;
    void *thread_return;
    if (argc != 4)
    {
        printf("Usage : %s   n", argv[0]);
        exit(1);
    }

    sprintf(name, "[%s]", argv[3]);
    sock = socket(PF_INET, SOCK_STREAM, 0);

    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_addr.sin_port = htons(atoi(argv[2]));

    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
        error_handling("connect() error");

    pthread_create(&snd_thread, NULL, send_msg, (void *)&sock); //创建发送消息线程
    pthread_create(&rcv_thread, NULL, recv_msg, (void *)&sock); //创建接受消息线程
    pthread_join(snd_thread, &thread_return);
    pthread_join(rcv_thread, &thread_return);
    close(sock);
    return 0;
}

void *send_msg(void *arg) // 发送消息
{
    int sock = *((int *)arg);
    char name_msg[NAME_SIZE + BUF_SIZE];
    while (1)
    {
        fgets(msg, BUF_SIZE, stdin);
        if (!strcmp(msg, "qn") || !strcmp(msg, "Qn"))
        {
            close(sock);
            exit(0);
        }
        sprintf(name_msg, "%s %s", name, msg);
        write(sock, name_msg, strlen(name_msg));
    }
    return NULL;
}

void *recv_msg(void *arg) // 读取消息
{
    int sock = *((int *)arg);
    char name_msg[NAME_SIZE + BUF_SIZE];
    int str_len;
    while (1)
    {
        str_len = read(sock, name_msg, NAME_SIZE + BUF_SIZE - 1);
        if (str_len == -1)
            return (void *)-1;
        name_msg[str_len] = 0;
        fputs(name_msg, stdout);
    }
    return NULL;
}

void error_handling(char *msg)
{
    fputs(msg, stderr);
    fputc('n', stderr);
    exit(1);
}

《UNP》随笔——多线程服务器

Linux相关栏目本月热门文章