单线程
#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);
}
}
这次怎么刷新都不会退出了。但多线程程序相对来说就是不如多进程健壮,因为任何线程的错误/异常都会导致整个进程的退出。