10.多线程_detached thread-优快云博客

本文深入介绍了多线程编程的概念，通过C语言示例展示了从单线程到多线程的转换。详细解析了线程的创建、同步以及线程同步中的互斥锁和条件变量。同时，通过生产者消费者问题和多线程Web服务器的实现，探讨了线程的使用场景和可能遇到的问题，如僵尸线程和SIGPIPE信号。文章还讨论了多线程相对于多进程的优缺点，强调了线程安全和资源管理的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

单线程

#include <stdio.h>

void *f(void *message){
    int i=0;
    for(i=0;i<5;i++){
        printf("%s\n", (char *)message);
        sleep(1);
    }
}

main(){
    f("hello");
    f("world");
}

main是程序的入口，首先执行f(“hello”)，进入f函数，循环5次，返回main，运行f(“world”)，进入f函数，循环5次，返回main，运行结束。

我们把刚才整个运行过程用手指比划一下（不要离开纸面），你能不能看到一根“thread”？这就是一个线程。

多线程

#include <stdio.h>
#include <pthread.h>

void *f(void *message){
    int i=0;
    for(i=0;i<5;i++){
        printf("%s\n", (char *)message);
        sleep(1);
    }
}

main(){
    pthread_t t1, t2;
    pthread_create(&t1, NULL, f, "hello");
    pthread_create(&t2, NULL, f, "world");
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
}

这个程序与单线程的那个程序唯一的区别是并没有直接去调用f函数，而是用了一个pthread_create函数间接地去调用f函数。编译（稍后会讲解）运行，发现奇怪的事情发生了。

我们看到hello和world同时输出到终端了，看起来f("hello")和f("world")并发执行了。

pthread_create用于根据某个函数创建一个线程，创建后f函数可以独立地运行，而main函数接着往下执行。如果说进程是一个运行着的程序，则线程就是一个运行着的函数。单线程的例子中同一时刻只能运行某一个函数，因此它只有一个线程。而多线程这个例子最多的时候有三个函数同时运行，因此是三个线程。

线程概念

线程（thread）是操作系统中CPU调度的最小单位。一个进程可以拥有一个或一个以上的线程。线程是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。线程也被称为轻量进程。

线程是独立调度和分派的基本单位。同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但每个线程拥有各自的栈（stack）、寄存器环境（register context）以及线程本地存储（thread-local storage）。

多线程的优点

首先，现代的计算机硬件为多线程提供了更高的运行效率。大家知道，距离CPU距离越近，存储速度越快，但价格越高。CPU想执行一条指令，必须将内存中的指令放入指令寄存器中，操作一个寄存器中数据后，也需要写回内存——当然，现代CPU里有cache，但它的速度，还是慢！这就导致了CPU在执行一条指令后，还得等下一条指令放到寄存器里，对于CPU太慢了。但是，如果CPU中有多组寄存器，CPU就可以在某一组寄存器尚未准备好时执行下一组寄存器中的指令（多组轮流执行），这就是CPU多线程。使用多线程编程，我们可以保证一个进程中的多个线程的大部分上下文相同，才能充分的利用CPU多线程。

其次，对于GUI程序，往往需要同时做很多事，使用多线程编程可以非常容易地实现这一需求。

由于Linux使用COW，进程是轻量级的。早期Linux的多线程甚至是用进程模拟的，因而从资源占用角度来看，多线程并无优势。

多线程的缺点

多线程的缺点就是不如进程健壮。如果不做特殊的处理，一个进程中的任何一个线程崩溃就会导致整个程序崩溃。而多进程程序中任何一个进程崩溃都不会影响其他进程。

多线程程序的编写

无论使用什么语言，多线程编程都很相似。

既然线程是一个运行着的函数，则第一步就要准备一个函数。这个函数往往是有预先的要求的，不能随便一个函数。以POSIX线程库为例：

这个函数一定是形如void *(*start_routine) (void *)的。

第二步，不可直接调用这个函数。我们的单线程例子就是如此，直接调用这个函数，与普通的函数无异。而必须通过其他手段将其变成一个线程。POSIX线程库使用的pthread_create。

比如Java，多线程编程与POSIX线程库没有本质不同，Java需要准备的函数是Thread.run()或者Runnable.run()——它们本质是一样的。将这个函数变成线程执行的是Thread.start()。

pthread_join与wait相似，它既是让主线程等待线程结束，又是对线程进行回收。——当然，你可能会想到了，如果不使用pthread_join对线程进行回收，是否会出现僵尸线程？答案是肯定的。

线程同步

多线程编程的一个便利之一，就是一个进程的多个线程，可以共享全部的全局变量，因此它们可以通过全局变量进行通信。但显然，对共享变量的并发访问一定会造成race condition。比如下面的例子。

例：存在race condition的变量并发访问

#include <stdio.h>
#include <pthread.h>

int tickets=100;

void *sell(void *station){
        while(tickets>0){
                printf("%s sells No. %d ticket\n", (char *)station, tickets);
                sleep(1);
                tickets--;
        }
}

main(){
        pthread_t p1, p2;
        int i;
        pthread_create(&p1, NULL, sell, "Shenyang");
        pthread_create(&p2, NULL, sell, "Shenyangnan");

        pthread_join(p1, NULL);
        pthread_join(p2, NULL);
}

这个例子中，有全局变量tickets用于存放火车票的数量，初始为100张。两个线程，“沈阳”和“沈阳北”并发售票，即并发访问共享变量tickets。运行结果如下：

一开始就不对劲，100号票被卖了两次。

很显然，对共享变量tickets的访问的代码是critical section，至少要保证线程在运行这部分的代码，是互斥的。

例：用互斥锁进行线程同步

#include <stdio.h>
#include <pthread.h>

int tickets=100;
pthread_mutex_t mutex_lock=PTHREAD_MUTEX_INITIALIZER;

void *sell(void *station){
        while(1){
                if(tickets<=0)
                        break;

                pthread_mutex_lock(&mutex_lock);
                if(tickets>0){
                        printf("%s sells No. %d ticket\n", (char *)station, tickets);
                        tickets--;
                }
                pthread_mutex_unlock(&mutex_lock);

        }
}

main(){
        pthread_t p1, p2;
        int i;
        pthread_create(&p1, NULL, sell, "Shenyang");
        pthread_create(&p2, NULL, sell, "Shenyangnan");

        pthread_join(p1, NULL);
        pthread_join(p2, NULL);
}

pthread_mutex_t mutex_lock=PTHREAD_MUTEX_INITIALIZER;声明并初始化了一个pthread的互斥锁。在运行critical section之前，用pthread_mutex_lock(&mutex_lock);加锁。critical section运行结束后，用pthread_mutex_unlock(&mutex_lock);解锁。

生产者消费者问题

要想实现生产者消费者问题的解答，除了要有互斥锁之外，还需要利用条件变量。

#include <stdio.h>
#include <pthread.h>

#define NUM 5

int buf[NUM];
int n=0;

pthread_mutex_t mutex_lock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t flag=PTHREAD_COND_INITIALIZER;

void *producer(void *v){
    while(1){
    /*
        printf("produce? presss enter\n");
        getchar();
    */
        pthread_mutex_lock(&mutex_lock);
        if(n<NUM){
            buf[n]=1;
            printf("produce: %d\n", n);
            n++;
            pthread_cond_signal(&flag);
        }else{
            pthread_cond_wait(&flag, &mutex_lock);
        }
        pthread_mutex_unlock(&mutex_lock);
    }
}

void *consumer(void *v){
    while(1){
        pthread_mutex_lock(&mutex_lock);
        if(n>0){
            n--;
            buf[n]=0;
            printf("consume: %d\n", n);
            pthread_cond_signal(&flag);
        }else{
            pthread_cond_wait(&flag, &mutex_lock);
        }   
        pthread_mutex_unlock(&mutex_lock);
    }
}

main(){
    pthread_t p, c, c2;
    pthread_create(&p, NULL, producer, NULL);
    pthread_create(&c, NULL, consumer, NULL);
    pthread_create(&c2, NULL, consumer, NULL);

    pthread_join(p, NULL);
    pthread_join(c, NULL);
    pthread_join(c2, NULL);
}

僵尸线程

与进程相似，线程占用资源，并需要由pthread_join来回收线程。如果程序员忘记回收，则会产生僵尸线程（zombie thread），导致内存泄漏。

在有些程序中，我们需要等待线程返回，必须需要得该线程的计算结果。但有些时候我们并不需要等待线程返回，比如Web server中一个处理用户请求的线程。这时我们可以将其设置位独立线程（detached thread）。独立线程运行结束后会自动释放其所占用的资源，而不会称为僵尸线程。

有两种方式可以创建独立线程。

方法1：在void *(*start_routine) (void *)的最开始使用pthread_detach设置自己为独立线程：

void *(*start_routine) (void *param){
    pthread_detach(pthread_self()); /*设置自己为独立线程*/
    
    /*代码段*/
    
    pthread_exit(param);            /*可不写，函数运行结束则线程结束*/    
}

方法2：在创建线程时就声明其为独立线程：

pthread_t t;
pthread_attr_t attr_detached;
pthread_attr_init(&attr_detached);
pthread_attr_setdetachstate(&attr_detached, PTHREAD_CREATE_DETACHED);

pthread_crate(&t, &attr_detached, start_routine, arg);

多线程的Web服务器

现在我们将之前的多进程Web服务器改写为多线程的。

#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <signal.h>
#include <pthread.h>

void handle_get(int sockfd, char *path){
    int fd;
    char buf[1024];
    int n;

    if((fd=open(path+1, O_RDONLY))==-1){
        return;
    }
    write(sockfd, "HTTP/1.0 200 OK\r\n\r\n", 19);
    while((n=read(fd, buf, sizeof(buf)))>0){
        if(write(sockfd, buf, n)!=n){
            break;  
        }
    }
    close(fd);
}

void *handlefd(void *sockfd){
    char buf[1024];
    char cmd[512];
    char path[512];
    int n;
    int fd;
    pthread_detach(pthread_self());
    fd=*((int *)sockfd);
    free(sockfd);
    n=read(fd, buf, sizeof(buf));   
    sscanf(buf, "%s%s", cmd, path);

    if(strcmp(cmd, "GET")==0){
        handle_get(fd, path);
    }
    close(fd);
}

main(int ac, char *av[]){
    int tcp_socket;
    struct sockaddr_in sockaddr;
    int fd;
    int *tmp;
    
    pthread_t t;

    tcp_socket  =  socket(AF_INET,  SOCK_STREAM, 0);

    sockaddr.sin_family=AF_INET;
    sockaddr.sin_port=htons(atoi(av[1]));
    sockaddr.sin_addr.s_addr=INADDR_ANY;

    if(bind(tcp_socket, (const struct sockaddr *)&sockaddr, sizeof(struct sockaddr_in))==-1){
        perror("cannot bind");
        exit(1);
    }

    listen(tcp_socket, 1);
    while(1){
        fd=accept(tcp_socket, NULL, NULL);

        tmp=malloc(sizeof(int));
        *tmp=fd;
        pthread_create(&t, NULL, handlefd, tmp);
    }
}

这里有一个细节需要注意一下。我们在pthread_create(&t, NULL, handlefd, tmp);需要把socket fd传给新创建的线程。但是，main()线程马上要把accept的返回值赋给fd，这就会导致子线程还未对原来的fd进行操作，就被main()线程修改了。因此，我们需要用malloc在堆中创建一个变量来保存上一次accept得到的fd的值。待子线程用完这个变量之后，用free()释放——如果忘记释放就会出现内存泄漏。

编译运行：

试着刷新几下页面，发现server进程死掉了。

发现进程是被SIGPIPE杀死的。导致这一问题的原因如下。当服务器与客户端三次握手完成建立之后，客户端发送一个一个RST（复位）——因为浏览器刷新了。当一个服务器进程向某个已收到RST的socket执行写操作时，内核会向该进程发送一个SIGPIPE信号。因此整个进程就被杀死了。之前我们编写的多进程程序之所以能够正常运行，是因为子进程被杀死/单个进程被杀死不会影响其他进程，因而整个服务不会收到影响。

将main里设置忽略SIGPIPE：

#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <signal.h>
#include <pthread.h>

void handle_get(int sockfd, char *path){
    int fd;
    char buf[1024];
    int n;

    if((fd=open(path+1, O_RDONLY))==-1){
        return;
    }
    write(sockfd, "HTTP/1.0 200 OK\r\n\r\n", 19);
    while((n=read(fd, buf, sizeof(buf)))>0){
        if(write(sockfd, buf, n)!=n){
            break;  
        }
    }
    close(fd);
}

void *handlefd(void *sockfd){
    char buf[1024];
    char cmd[512];
    char path[512];
    int n;
    int fd;
    pthread_detach(pthread_self());
    fd=*((int *)sockfd);
    free(sockfd);
    n=read(fd, buf, sizeof(buf));   
    sscanf(buf, "%s%s", cmd, path);

    if(strcmp(cmd, "GET")==0){
        handle_get(fd, path);
    }
    close(fd);
}

main(int ac, char *av[]){
    int tcp_socket;
    struct sockaddr_in sockaddr;
    int fd;
    int *tmp;
    
    pthread_t t;
    signal(SIGPIPE, SIG_IGN);

    tcp_socket  =  socket(AF_INET,  SOCK_STREAM, 0);

    sockaddr.sin_family=AF_INET;
    sockaddr.sin_port=htons(atoi(av[1]));
    sockaddr.sin_addr.s_addr=INADDR_ANY;

    if(bind(tcp_socket, (const struct sockaddr *)&sockaddr, sizeof(struct sockaddr_in))==-1){
        perror("cannot bind");
        exit(1);
    }

    listen(tcp_socket, 1);
    while(1){
        fd=accept(tcp_socket, NULL, NULL);

        tmp=malloc(sizeof(int));
        *tmp=fd;
        pthread_create(&t, NULL, handlefd, tmp);
    }
}

这次怎么刷新都不会退出了。但多线程程序相对来说就是不如多进程健壮，因为任何线程的错误/异常都会导致整个进程的退出。
r=INADDR_ANY;

if(bind(tcp_socket, (const struct sockaddr *)&sockaddr, sizeof(struct sockaddr_in))==-1){
    perror("cannot bind");
    exit(1);
}

listen(tcp_socket, 1);
while(1){
    fd=accept(tcp_socket, NULL, NULL);

    tmp=malloc(sizeof(int));
    *tmp=fd;
    pthread_create(&t, NULL, handlefd, tmp);
}

}


这次怎么刷新都不会退出了。但多线程程序相对来说就是不如多进程健壮，因为任何线程的错误/异常都会导致整个进程的退出。