1.1、线程和进程的关系
线程是计算机中独立运行的最小单位，运行时占用很少的系统资源，每个线程占用的CPU时间是由系统分配的，因此可以把线程看成是操作系统分配CPU时间的基本单位。在用户看来，多个线程是同时执行的，但从操作系统的调度上看，各个线程是交替执行的。系统不停在各个线程之间切换，每个线程只有在系统分配给它的时间片内才能取得CPU的控制权，执行线程中的代码。
注意：这里只是单CPU单核的情况，在多CPU多核的主机上，多个线程是可以同时运行的。
Linux系统是支持多线程的，它在一个进程内生成了许多个线程，一个进程可以拥有一至多个线程。那么为什么在支持多进程的情况下又要引入多线程呢？这是因为多线程相对于多进程有以下优点：
- 在多进程情况下，每个进程都有自己独立的地址空间，而在多线程情况下，同一进程内的线程共享进程的地址空间。因此，进程的资源开销要比线程大得多
- 系统调度方面，由于进程地址空间独立而线程共享同一个进程的地址空间，线程间的切换速度要远快于进程间的切换速度
- 通信机制方面，进程间的数据空间相互独立，彼此通信要用专门的通信方式进行，通信时必须通过操作系统。而同一进程内的多个线程共享数据空间，一个线程的数据可以直接提供给另一个线程使用，而不必经过操作系统。因此，线程间的通信更加方便和省时。
以上线程的优点可以用2个字概括：“节约”：节约资源、节约时间。这些对操作系统的设计来说是非常重要的，线程还有以下优点：
- 提高应用程序的响应速度，在图形界面程序中，如果有一个非常耗时的操作，它会导致其它操作不能进行而等待，这时界面响应用户的操作速度就会变得很慢。多线程环境下，可以将这个非常耗时的操作放到一个单独的线程中来完成
- 可以提高多处理器效率
- 可以改善程序的结构，对于要处理多个命令的应用程序，可以将对每个命令的处理设计为一个线程，从而避免设计大程序时，造成的程序结构复杂
虽然线程共享进程的地址空间、打开的文件描述符等资源，但是线程也有自己私有的数据信息，包括：
- 线程号（Thread ID）：每个线程都有一个唯一的线程ID号
- 寄存器：包括程序计数器和堆栈指针
- 堆栈
- 信号掩码
- 优先级
- 线程私有的存储空间
Linux支持POSIX多线程接口，称为pthread(Posix Thread的简称)。编写Linux下的多线程应用程序，需要使用头文件pthread.h，链接时需要使用库pthread.a.
1.2、创建线程
1.2.1、线程创建函数pthread_create
如果在主线程里面创建线程，程序就会在创建线程的地方产生分支，变成2个分支执行，这似乎和多进程一样，其实不然，子进程是通过拷贝父进程的地址空间来实现的；而线程与进程内的线程共享程序代码，一段代码可以同时被多个线程执行。
线程的创建通过函数pthread_create来完成，该函数的声明如下：
#include <pthread.h>
int pthread_create(pthread_t *thread,pthread_attr_t *attr, void* (*start_routine)(void*), void* arg);- thread：该参数是一个指针，当线程创建成功时，用来返回创建的线程ID
- attr：该参数用于指定线程的属性，NULL表示使用默认属性
- start_routine：该参数为一个函数指针，指向线程创建后要调用的函数。这个被线程调用的函数也称为线程函数
- arg：该参数指向传递给线程函数的参数
注意：线程创建成功时，pthread_create函数返回0，若不为0则说明线程创建失败，常见的错误码为EAGAIN和EINVAL。前者表示系统限制创建新的线程，例如：线程数目过多；后者表示第二个参数代表的线程属性值非法。线程创建成功后，创建的线程开始运行第三个参数所指向的函数，原来的线程继续运行。
pthread_t pthread_self(void);//获取本线程的线程ID
int pthread_equal(pthread_t thread1, pthread_t thread2);//判断2个线程的ID是否指向同一个线程
int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));//用来保证init_routine线程函数在进程中仅执行一次#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
void* thread(void* arg)
{
pthread_t newthid;
printf("this is new thread, thread id = %x\n", pthread_self());
return NULL;
}
int main(void)
{
pthread_t thid;
printf("main thread ID is %x\n", pthread_self());//main thread id
if(pthread_create(&thid, NULL, (void*)thread, NULL) != 0){
printf("thread creation failed.\n");
exit(1);
}
sleep(1);
return 0;
}
说明：程序首先打印出主线程的ID，然后打印新创建的线程ID。
有些情况下，函数执行次数被限制为一次，这种情况下要使用pthread_once函数，下面例子说明了该函数的用法：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
pthread_once_t once = PTHREAD_ONCE_INIT;
void run()
{
printf("Function run is running in thread %u\n", pthread_self());
}
void* thread1(void* arg)
{
pthread_t thid = pthread_self();
printf("Current thread's ID is %x\n", thid);
pthread_once(&once,run);
printf("thread1 ends\n");
}
void* thread2(void* arg)
{
pthread_t thid = pthread_self();
printf("Current thread's ID is %x\n", thid);
pthread_once(&once,run);
printf("thread2 ends\n");
}
int main(void)
{
pthread_t thid1,thid2;
pthread_create(&thid1, NULL, thread1, NULL);
pthread_create(&thid2, NULL, thread2, NULL);
printf("main thread exit.\n");//main thread id
sleep(3);
return 0;
}
从执行结果可以看出来，线程函数执行了一次。
2.2.2、线程属性
线程创建函数pthread_create有一个参数类型为pthread_attr_t，该结构定义如下：
typedef struct{
int datachstate;
int schedpolicy;
struct sched_param schedparam;
int inheritsched;
int scope;
size_t quardsize;
int stackaddr_set;
void* stackaddr;
size_t stacksize
}pthread_attr_t;- datachstate:表示新创建的线程是否与进程中的其它线程脱离同步。datachstate的缺省值为PTHREAD_CREATE_JOINABLE状态，这个属性也可以用函数pthread_detach()来设置。如果将datachstate设置为PTHREAD_CREATE_DETACH状态，则datachstate不能再恢复到PTHREAD_CREATE_JOINABLE状态。
- schedpolicy:表示新线程的调度策略，主要包括SCHED_OTHER(正常、非实时)、SCHED_RR(实时、轮转法)、SCHED_FIFO(实时、先入先出)这三种，缺省为SCHED_OTHER(正常、非实时)，后两种调度策略仅对超级用户有效。
- schedparam：一个struct sched_param结构体，其中有一个sched_priority成员，表示线程的运行优先级。这个参数仅当调度策略为实时（SCHED_RR或SCHED_FIFO）时才有效，缺省为0.
- inheritsched:有两种值可供选择，PTHREAD_EXPLICIT_SCHED和PTHREAD_INHERIT_SCHED,前者表示新线程显式指定调度策略和调度参数（即attr中的值），后者表示继承调用者线程的值，缺省为PTHREAD_EXPLICIT_SCHED.
- scope：表示线程间竞争CPU的范围，也就是说，线程优先级的有效范围，POSIX标准中定义了两个值，PTHREAD_SCOPE_SYSTEM:表示与系统中所有线程一起竞争CPU。PTHREAD_SCOPE_PROCESS:表示仅与同进程中的线程竞争CPU。
- guardsize：警戒堆栈的大小
- stackaddr_set：堆栈地址集
- stacksize：堆栈的大小
2.3、线程终止
Linux下有2种方式可以使线程终止，一种是return从线程函数直接返回，另一种是通过调用函数pthread_exit()使线程退出。pthread_exit()在头文件pthread.h中声明，该函数的原型如下：
#include <pthread.h>
void pthread_exit(void* retval);
线程终止最重要的问题是资源释放的问题，特别是一些临界资源。临界资源在一段时间内只能被一个线程所持有，当线程需要使用临界资源时提出需求，如果该资源未被使用则申请成功，否则等待。临界资源使用完毕后要释放以便其它线程可以使用。例如，某线程要写一个文件，在该线程写文件时不允许其它线程对该文件进行写操作，否则会导致文件数据混乱，这里的文件就是一种临界资源，临界资源为一个线程所独占，当一个线程终止时如果不释放占用的临界资源，其它需要使用该资源的线程可能就会一直等待下去，这就形成了死锁，而往往这是灾难性的。
为此，Linux系统提供了一对函数pthread_cleanup_push()和pthread_cleanup_pop()用于自动释放资源。从pthread_cleanup_push()的调用点到pthread_cleanup_pop()之间的程序段中的终止动作（如调用pthread_exit函数）都将执行pthread_cleanup_push()所指定的清理函数，这两个函数是以宏的形式提供的。
注意：pthread_cleanup_push()带有一个“{”，而pthread_cleanup_pop()带有一个“}”，因此这两个函数必须成对出现，而且必须位于程序的同一代码段中才能通过编译。
线程终止的另外一个需要注意的问题是线程间的同步问题。一般情况下，进程中各个线程的运行是相互独立的，线程的终止并不会相互通知，也不会影响其它线程，终止的线程所占用的资源也不会随着线程的终止而归还系统，而是仍为线程所在的进程所持有。正如进程之间可以使用wait系统函数来等待其它进程结束一样，线程也有类似的函数，pthread_join()函数，该函数在pthread.h中声明：
线程终止的另外一个需要注意的问题是线程间的同步问题。一般情况下，进程中各个线程的运行是相互独立的，线程的终止并不会相互通知，也不会影响其它线程，终止的线程所占用的资源也不会随着线程的终止而归还系统，而是仍为线程所在的进程所持有。正如进程之间可以使用wait系统函数来等待其它进程结束一样，线程也有类似的函数，pthread_join()函数，该函数在pthread.h中声明：
#include <pthread.h>
void pthread_exit(void* retval);
int pthread_join(pthread_t th, void* thread_return);
int pthread_detach(pthread_t th);
一个可join的线程所占用的内存仅当有线程对其执行了pthread_join后才会释放，因此为了避免内存泄露，所有的线程终止时，要么已被设为DETACHED,要么使用pthread_join来回收资源。
注意：一个线程不能被多个线程等待，否则第一个接收到信号的线程成功返回，其余调用pthread_join的线程返回错误代码ESRCH.
示例代码如下：
#include <stdio.h>
#include <pthread.h>
void* assisthread(void* arg)
{
printf("I am helping to do some jobs\n");
sleep(3);
pthread_exit(0);
}
int main(void)
{
pthread_t assistthid;
int status;
pthread_create(&assistthid, NULL, (void*) assisthread, NULL);
pthread_join(assistthid, (void*)&status);
printf("assisthread's exit is caused %d\n", status);
return 0;
}
从运行结果可以看出pthread_join会阻塞主线程，等待assistthread结束。pthread_exit结束时的退出码为0，pthread_join通过参数获得的status也是0，两者是一致的。
2.4、私有数据
在多线程环境下，进程内的所有线程共享进程的数据空间，因此全局变量为所有线程共有，在程序设计中有时需要保存线程自己的全局变量，这个特殊的变量仅在某个线程内部有效。如常见的变量errno，它返回标准的出错代码。errno不应该是一个局部变量，几乎每个函数都应该可以访问它，但它又不能作为一个全局变量，否则在一个线程里输出的很可能是另一个线程的出错信息。这个问题可以通过创建线程的私有数据（Thread-specific Data 或TSD）来解决。在线程内部，线程私有数据可以被各个函数访问，但它对其它线程都是屏蔽的。
线程私有数据采用了一种被称为一键多值的技术，即一个键对应多个值。访问数据时都是通过键来访问，就像是对一个变量进行访问，其实是在访问不同的数据。使用线程私有数据时，首先要为每个线程数据创建一个相关联的键。在各个线程内部，使用这个公用的键来指代线程数据，但是在不同的线程中，这个键代表的数据是不同的。操作线程私有数据的函数主要有4个，声明如下：
#include <pthread.h>
int pthread_key_create(pthread_key_t *key, void (*destr_function) (void*));//创建一个键
int pthread_setspecific(pthread_key_t key, const void* pointer);//为一个键设置线程私有数据
void* pthread_getspecific(pthread_key_t key);//从一个键读取线程私有数据
int pthread_key_delete(pthread_key_t key);//删除一个键- pthread_key_create：从Linux的TSD池中分配一项，将其值赋给key供以后访问使用，它的第一个参数key为指向键值的指针，第二个参数为一个函数指针，如果指针不为空，则在线程退出时，将以key所关联的数据作为参数调用destr_function()，释放分配的缓冲区。key一旦被创建，所有线程都可以访问它，但各个线程可以根据自己的需要往key中填入不同的值，这就相当于提供了一个同名而不同值的全局变量，一键多值。一键多值靠的是一个关键数据结构数组，机TSD池，其结构如下：
创建一个TSD就相当于将结构数组中的某一项设置为“in_use”,并将其索引返回个*key，然后设置destructor函数为destr_function。static struct pthread_key_struct pthread_keys[PTHREAD_KEYS_MAX] = {(0,NULL)}; - pthread_setspecific:该函数将pointer的值（不是内容）与key相关联，用pthread_setspecific为一个键指定新的线程数据时，线程必须先释放原有的线程数据用以回收空间
- pthread_getspecific:该函数获得与key相关联的数据
- pthread_key_delete:该寒水鱼用来删除一个键，删除后，键所占用的内存将被释放。需要注意的是，键占用的内存被释放，与键关联的线程数据所占用的内存并不释放，因此，线程数据的释放必须在释放键之前完成。
如何创建和使用线程的私有数据，具体示例代码如下：
#include <stdio.h>
#include <string.h>
#include <pthread.h>
pthread_key_t key;
void* thread2(void* arg)
{
int tsd = 5;
printf("Thread2 start running.\n");
pthread_setspecific(key, (void*)tsd);
printf("Thread2 end running return tsd is %d\n", pthread_getspecific(key));
}
void* thread1(void* arg)
{
int tsd = 0;
pthread_t thid2;
printf("Thread1 start running.\n");
pthread_setspecific(key, (void*)tsd);
pthread_create(&thid2, NULL, thread2, NULL);
sleep(1);
printf("Thread1 end running return tsd is:%d\n",pthread_getspecific(key));
}
int main(void)
{
pthread_t thid1;
printf("main thread begins running\n");
pthread_key_create(&key, NULL);
pthread_create(&thid1, NULL, thread1, NULL);
sleep(3);
pthread_key_delete(key);
printf("main thread exit.\n");
return 0;
}
2.5、线程同步
线程最大的特点就是资源的共享，然而资源共享中的同步问题是多线程编程的难点。Linux系统提供了多种方式处理线程间的同步问题，其中最常用的有互斥锁、条件变量、异步信号，下面主要介绍这3种同步技术的使用。
2.5.1、互斥锁
互斥锁通过锁机制来实现线程间的同步，在同一时刻它通常只允许一个线程执行关键部分代码。下面互斥锁的几个常用函数，这些函数在pthread.h中定义：
pthread_mutex_init函数----------初始化一个互斥锁
pthread_mutex_destroy函数-------注销一个互斥锁
pthread_mutex_lock函数----------加锁，如果不成功，阻塞等待
pthread_mutex_unlock函数--------解锁
pthread_mutex_trylock函数-------测试加锁，如果不成功则立即返回，错误码为EBUSYpthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
初始化以后就可以使用互斥锁了，加锁有2个函数，pthread_mutex_lock和pthread_mutex_trylock().它们的函数原型如下：
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t * mutex);
注意：加锁时不论哪种类型的锁，都不可能被两个不同的线程同时得到，其中一个必须等待解锁，在同一进程中的线程，如果加锁后没有解锁，则其它线程就无法再获得该锁。
pthread_mutex_unlock用来解锁，函数原型如下：
int pthread_mutex_unlock(pthread_mutex_t *mutex);
当一个互斥锁使用完毕后，必须进行清除，清除互斥锁使用函数pthread_mutex_destroy，该函数的原型如下：
int pthread_mutex_destroy(pthread_mutex_t *mutex);
下面的代码展示了互斥锁的用法：
#include <stdio.h>
#include <pthread.h>
pthread_mutex_t number_mutex;
int globalnumber;
void write_globalnumber()
{
pthread_mutex_lock(&number_mutex);
globalnumber++;
pthread_mutex_unlock(&number_mutex);
}
int read_globalnumber()
{
int temp;
pthread_mutex_lock(&number_mutex);
temp = globalnumber;
pthread_mutex_unlock(&number_mutex);
return temp;
}
2.5.2、条件变量
条件变量是利用线程间共享的全局变量进行同步的一种机制。条件变量宏观上类似if语句，符合条件就能执行某段代码，否则只能等待条件成立。使用条件变量主要包括2个动作，一个等待使用资源的线程等待“条件变量被设置为真”；另一个线程在使用完资源后“设置条件为假”，这样就可以保证线程同步了。这种机制存在一个问题，就是要保证条件变量能被正确的修改，条件变量要受到特殊的保护，实际使用中互斥锁扮演着这样一个保护者的角色。Linux也提供了一系列对条件变量操作的函数，如下：
- pthread_cond_init函数----------初始化条件变量
- pthread_cond_wait函数----------基于条件变量阻塞，无条件等待
- pthread_cond_timedwait函数-----阻塞直到指定事件发生，计时等待
- pthread_cond_signal函数--------解除特定线程的阻塞，存在多个等待线程时按入队顺序激活其中一个
- pthread_cond_broadcast函数-----解除所有线程阻塞
- pthread_cond_destroy函数-------清除条件变量
与互斥锁一样，条件变量的初始化也有2种方式，一种是静态赋值法，将宏结构常量PTHREAD_COND_INITIALIZER赋给互斥锁，操作语句如下：
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
等待条件成立有2个函数，函数原型如下：
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timewait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec* abstime);
1297
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
