10.多线程

本文深入介绍了多线程编程的概念,通过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,运行结束。

image-20211231221059887

我们把刚才整个运行过程用手指比划一下(不要离开纸面),你能不能看到一根“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")并发执行了。

image-20211231222354471

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线程库为例:

image-20211231222538366

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

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

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

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

image-20211231222638589

线程同步

多线程编程的一个便利之一,就是一个进程的多个线程,可以共享全部的全局变量,因此它们可以通过全局变量进行通信。但显然,对共享变量的并发访问一定会造成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。运行结果如下:

image-20220101211921500

一开始就不对劲,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);解锁。

image-20220101212241485

生产者消费者问题

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

#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()释放——如果忘记释放就会出现内存泄漏。

编译运行:

image-20220102002511262

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

image-20220102002543856

发现进程是被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);
}

}


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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值