线程基础：
这段时间需要总结linux多线程编程的相关知识，所以记录一些必要的知识点。
一.什么是线程
在一个程序里的多个执行路线就叫做线程。更准确的定义是:线程是“一个进程内部的一个控制序列”。
典型的 unix 进程可以看成只有一个控制线程:
一个进程在同一时刻只做一件事情。
有了多个控制线程以后,在程序设计时可以把进程设计成在同一时刻能够做不止一件事,每个线程处理各自独立的任务。
二.线程的优点
(1) 通过为每种事件类型的处理分配单独的线程,能够简化处理异步时间的代码。
(2) 多个线程可以自动共享相同的存储地址空间和文件描述符。
(3) 有些问题可以通过将其分解从而改善整个程序的吞吐量。
(4) 交互的程序可以通过使用多线程实现相应时间的改善,多线程可以把程序中处理用户输入输出的部分与其它部分分开。
三.线程的缺点
线程也有不足之处。编写多线程程序需要更全面更深入的思考。在一个多线程程序里,因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的。调试一个多线程程序也比调试一个单线程程序困难得多。
四.线程的结构
线程包含了表示进程内执行环境必需的信息,其中包括进程中标识线程的线程 ID,一组寄存器值、栈、调度优先级和策略、信号屏蔽子,errno 变量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的,包括可执行的程序文本,程序的全局内存和堆内存、栈以及文件描述符。
五.线程标识
就像每个进程有一个进程 ID 一样,每个线程也有一个线程 ID,进程 ID 在整个系统中是唯一的,但线程不同,线程 ID 只在它所属的进程环境中有效。线程 ID 用 pthread_t 数据类型来表示,实现的时候可以用一个结构来代表 pthread_t数据类型,所以可以移植的操作系统不能把它作为整数处理。因此必须使用函数来对来对两个线程 ID 进行比较。
1：pthread_equal
| 名称: | pthread_equal |
| 功能： | 比较两个线程 ID是否相等 |
| 头文件： | #include <pthread.h> |
| 函数原型： | int pthread_equal(pthread_t tid1,pthread_t tid2); |
| 参数： | tid1 进程 1id tid2 进程 2id |
| 返回值： | 若相等返回非 0 值,否则返回 0 |
2：pthread_self
| 名称: | pthread_self |
| 功能： | 获取自身线程的 id |
| 头文件： | #include <pthread.h> |
| 函数原型： | pthread_t pthread_self(void); |
| 参数： | 无 |
| 返回值： | 调用线程的线程 id |
六.线程的创建
| 名称 | pthread_create |
| 功能 | 创建线程 |
| 头文件 | #include <pthread.h> |
| 函数原型 | int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg); |
| 参数 | |
| 返回值 | 若成功返回则返回 0,否则返回错误编号 |
当 pthread_creat 成功返回时, thread指向的内存单元被设置为新创建线程的线程ID。attr 参数用于定制各种不同的线程属性。可以把它设置为 NULL,创建默认的线程属性。新创建的线程从 start_routine 函数的地址开始运行,该函数只有一个无类型指针，参数是arg,如果需要向 start_routine 函数传递的参数不止一个,那么需要把这些参数放到一个结构中,然后把这个结构的地址作为 arg 参数传入。
下面看一个示例：
#include <pthread.h>
void printids(const char *s)
{
printf(“%s pid:%u tid:%u \n“, s,getpid(),pthread_self());
//getpid() returns the process ID of the calling process，
//pthread_self() function returns the ID of the calling thread.
}
void *thr_fn(void *arg)
{
printids(“new thread: “);
}
int main()
{
int err;
pthread_t tid;
err=pthread_create(&tid,NULL,thr_fn,NULL);
if(err==0)
printf(“can’t create thread:%s\n”,strerror(err));
printids(“main thread: “);
sleep(1);
exit(0);
}关于进程的编译我们都要加上参数 –lpthread 否则提示找不到函数的错误。
具体编译方法是 gcc –o test test.c –lpthread
执行结果为：
main thread: pid 14954 tid 134529024
new thread: pid 14954 tid 134530048
可见，它们的pid都是一样的，因为它们同属与一个进程，但是线程id就不同了。
七.线程的终止
线程是依进程而存在的,当进程终止时,线程也就终止了。当然也有在不终止整个进程的情况下停止它的控制流。
(1)线程只是从启动例程中返回,返回值是线程的退出码。
(2)线程可以被同一进程中的其他线程取消。
(3)线程调用 pthread_exit函数终止执行，就如同进程在结束时调用exit函数一样。这个函数的作用是，终止调用它的线程并返回一个指向某个对象的指针。
原型：void pthread_exit（void *retval）
用法：#include <pthread.h>
功能：使用函数pthread_exit退出线程，这是线程的主动行为；由于一个进程中的多个线程是共享数据段的，因此通常在线程退出之后，退出线程所占用的资源并不会随着线程的终止而得到释放，但是可以用pthread_join()函数来同步并释放资源。
rval_prt 是一个无类型指针,与传给启动例程的单个参数类似。进程中的其他线程可以调用 pthread_join 函数访问到这个指针。
语法：
#include <pthread.h>
int pthread_join(pthread_t thread, void ** value_ptr);
描述：
pthread_join()将挂起调用线程的执行直到目标线程终止，除非目标线程已经终止了。
在一次成功调用pthread_join()并有非NULL的参数value_ptr，传给pthread_exit()终止线程的这个值以value_ptr作为引用是可用的。
当pthread_join()成功返回，目标线程就会终止。
对同一目标线程多次同时调用pthread_join()的结果是不确定的。
如果调用pthread_join()的线程被取消，那么目标线程将不会被分离。
当一个线程通过调用 pthread_exit 退出或者简单地从启动历程中返回时,进程中的其他线程可以通过调用 pthread_join 函数获得进程的退出状态。调用pthread_join的线程将一直阻塞,直到指定的线程调用 pthread_exit,从启动例程中或者被取消。如果线程只是从它的启动历程返回,rval_ptr 将包含返回码。
#include <pthread.h>
#include <string.h>
void *thr_fn1(void *arg)
{
printf(“thread 1 returning\n”);
return((void *)1);
}
void *thr_fn2(void *arg)
{
printf(“thread 2 exiting\n”);
return((void *)2);
}
int main()
{
pthread_t tid1,tid2;
void *tret;
pthread_create(&tid1,NULL,thr_fn1,NULL);
pthread_create(&tid2,NULL,thr_fn2,NULL);
pthread_join(tid1,&tret);
printf(“thread 1 exit code %d\n”,(int)tret);
pthread_join(tid2,&tret);
printf(“thread 2 exit code %d\n”,(int)tret);
exit(0);
}thread 1 returning
thread 2 exiting
thread 1 exit code 1
thread 2 exit code 2
pthread_join一般是主线程来调用，用来等待子线程退出，因为是等待，所以是阻塞的，一般主线程会依次join所有它创建的子线程。
pthread_exit一般是子线程调用，用来结束当前线程。
子线程可以通过pthread_exit传递一个返回值，而主线程通过pthread_join获得该返回值，从而判断该子线程的退出是正常还是异常。
在默认情况下,
线程的终止状态会保存到对该线程调用 pthread_join,如果线程已经处于分离状态,线程的底层存储资源可以在线程终止时立即被收回。当线程被分离时,并不能用 pthread_join 函数等待它的终止状态。对分离状态的线程进行pthread_join 的调用会产生失败,返回 EINVAL.pthread_detach 调用可以用于使线程进入分离状态。
语法：
#include <pthread.h>
int pthread_detach(pthread_t thread);
描述：
pthread_detach()函数在所指出线程终止时，该线程的内存空间可以被回收。
如果线程没有终止，pthread_detach()函数也不会令其终止。
对同一目标线程多次调用pthread_datach()的结果是不确定的。
在默认的情况下,pthread_cancel 函数会使由 tid 标识的线程的行为表现为如同调用了参数为 PTHEAD_CANCELED 的 pthread_exit 函数,但是,线程可以选择忽略取消方式和控制取消方式。pthread_cancel 并不等待线程终止,它仅仅提出请求。
原型:int pthread_cancel(pthread_t thread)
#include<pthread.h>
发送终止信号给thread线程，如果成功则返回0，否则为非0值。发送成功并不意味着thread会终止。
若是在整个程序退出时，要终止各个线程，应该在成功发送 CANCEL 指令后，使用 pthread_join 函数，等待指定的线程已经完全退出以后，再继续执行；否则，很容易产生 “段错误”。
线程终止的清理工作
线程可以安排它退出时需要调用的函数,这样的函数称为线程清理处理程序,线程可以建立多个清理处理程序。处理程序记录在栈中,也就是说它们的执行顺序与它们注册时的顺序相反。要注意的是如果线程是通过从他的启动例程中返回而终止的,它的处理程序就不会调用。还要注意清理处理程序是按照与它们安装时相反的顺序调用的。
Posix的线程终止有两种情况：正常终止和非正常终止。
线程主动调用pthread_exit()或者从线程函数中return都将使线程正常退出，这是可预见的退出方式；
非正常终止是线程在其他线程的干预下，或者由于自身运行出错（比如访问非法地址）而退出，这种退出方式是不可预见的。
不论是可预见的线程终止还是异常终止，都会存在资源释放的问题，在不考虑因运行出错而退出的前提下，如何保证线程终止时能顺利的释放掉自己所占用的资源，特别是锁资源，就是一个必须考虑解决的问题。
最经常出现的情形是资源独占锁的使用：线程为了访问临界资源而为其加上锁，但在访问过程中被外界取消，如果线程处于响应取消状态，且采用异步方式响应，或者在打开独占锁以前的运行路径上存在取消点，则该临界资源将永远处于锁定状态得不到释放。外界取消操作是不可预见的，因此的确需要一个机制来简化用于资源释放的编程。
在POSIX线程API中提供了一个pthread_cleanup_push()/ pthread_cleanup_pop()函数,API定义如下：
void pthread_cleanup_push(void (*routine) (void *), void *arg)
void pthread_cleanup_pop(int execute)
pthread_cleanup_push()/pthread_cleanup_pop()采用先入后出的栈结构管理，void routine(void *arg)函数
在调用pthread_cleanup_push()时压入清理函数栈，多次对pthread_cleanup_push() 的调用将在清理函数栈中形成一个函数链；
从pthread_cleanup_push的调用点到pthread_cleanup_pop之间的程序段中的终止动作（包括调用pthread_exit()和异常终止，不包括return）
都将执行pthread_cleanup_push()所指定的清理函数。
在执行该函数链时按照压栈的相反顺序弹出。execute参数表示执行到 pthread_cleanup_pop()时
是否在弹出清理函数的同时执行该函数，为0表示不执行，非0为执行；这个参数并不影响异常终止时清理函数的执行。
示例代码：
#include <pthread.h>
#include <stdio.h>
void cleanup(void *arg)
{
printf(“cleanup: %s\n”,(char *)arg);
}
void *thr_fn(void *arg) /*线程入口地址*/
{
printf(“thread start\n”);
pthread_cleanup_push(cleanup,”thread first handler”);/*设置第一个线程处理程序*/
pthread_cleanup_push(cleanup,”thread second handler”); /*设置第二个线程处理程序*/
printf(“thread push complete\n”);
pthread_cleanup_pop(0); /*取消第一个线程处理程序*/
pthread_cleanup_pop(0); /*取消第二个线程处理程序*/
}
int main()
{
pthread_t tid;
void *tret;
pthread_creat(&tid,NULL,thr_fn,(void *)1); /*创建一个线程*/
pthread_join(tid,&tret); /*获得线程终止状态*/
ptinrf(“thread exit code %d\n”,(int)tret);
}有时候我们需要对一些 posix 变量只进行一次初始化,如线程键(我下面会讲到)。如果我们进行多次初始化程序就会出现错误。
在传统的顺序编程中,一次性初始化经常通过使用布尔变量来管理。控制变量被静态初始化为 0,而任何依赖于初始化的代码都能测试该变量。如果变量值仍然为 0,则它能实行初始化,然后将变量置为 1。以后检查的代码将跳过初始化。但是在多线程程序设计中,事情就变的复杂的多。如果多个线程并发地执行初始化序列代码,2 个线程可能发现控制变量为 0,并且都实行初始化,而该过程本该仅仅执行一次。初始化的状态必须由互斥量保护。如果我们需要对一个 posix 变量静态的初始化,可使用的方法是用一个互斥量对该变量的初始话进行控制。但有时候我们需要对该变量进行动态初始化,pthread_once 就会方便的多。
int pthread_once(pthread_once_t *once_control, void (*init_routine) (void))；
类型为 pthread_once_t 的变量是一个控制变量。控制变量必须使用PTHREAD_ONCE_INIT 宏静态地初始化。
pthread_once 函数首先检查控制变量,判断是否已经完成初始化,如果完成就简单地返回;否则,pthread_once 调用初始化函数,并且记录下初始化被完成。如果在一个线程初始时,另外的线程调用 pthread_once,则调用线程等待,直到那个线程完成初始化返回。
在多线程编程环境下，尽管pthread_once()调用会出现在多个线程中，init_routine()函数仅执行一次，究竟在哪个线程中执行是不定的，是由内核调度来决定。
示例代码：
#include <pthread.h>
pthread_once_t once=PTHREAD_ONCE_INIT;
pthread_mutex_t mutex; /*互斥量,我们后面会讲到*/
void once_init_routine(void)/*一次初始化函数*/
{
int status;
status=pthread_mutex_init(&mutex,NULL);/*初始化互斥量*/
if(status==0)
printf(“Init success!,My id is %u”,pthread_self());
}
void *child_thread(void *arg)
{
printf(“I’m child ,My id is %u”,pthread_self());
pthread_once(&once,once_init_routine); /*子线程调用一次性初始化函数*/
}
int main(int argc,char *argv[ ])
{
pthread_t child_thread_id;
pthread_create(&child_thread_id,NULL,child_thread,NULL);/*创建子线程*/
printf(“I’m father,my id is %u”,pthread_self());
pthread_once(&once,once_init_routine);/*父线程调用一次性初始化函数*/
pthread_join(child_thread_id,NULL);
}程序运行结果如下:
I’m father,My id is 3086874304
Init success!,My id is 3086874304
I’m child, My id is 3086871472
从上面的结果可以看到当主函数初始化成功后,子函数的初始化失败了。
九、线程的私有数据
在进程内的所有线程共享相同的地址空间,任何声明为静态或外部的变量,或在进程堆声明的变量,都可以被进程所有的线程读写。那怎样才能使线程序拥有自己的私有数据呢。posix 提供了一种方法,创建线程键。
下面说一下线程中特有的线程存储， Thread Specific Data 。
线程存储有什么用了？他是什么意思了？大家都知道，在多线程程序中，所有线程共享程序中的变量。现在有一全局变量，
所有线程都可以使用它，改变它的值。
而如果每个线程希望能单独拥有它，那么就需要使用线程存储了。表面上看起来这是一个全局变量，所有线程都可以使用它，
而它的值在每一个线程中又是单独存储的。这就是线程存储的意义
下面说一下线程存储的具体用法。
1) 创建一个类型为 pthread_key_t 类型的变量。
2)调用 pthread_key_create() 来创建该变量。该函数有两个参数，第一个参数就是上面声明的 pthread_key_t 变量，
第二个参数是一个清理函数，用来在线程释放该线程存储的时候被调用。该函数指针可以设成 NULL ，这样系统将调用默认的清理函数。
3)当线程中需要存储特殊值的时候，可以调用 pthread_setspcific() 。该函数有两个参数，第一个为前面声明的 pthread_key_t 变量，
第二个为 void* 变量，这样你可以存储任何类型的值。
4) 如果需要取出所存储的值，调用 pthread_getspecific() 。该函数的参数为前面提到的 pthread_key_t 变量，该函数返回
void * 类型的值。
下面是前面提到的函数的原型：int pthread_setspecific(pthread_key_t key, const void *value);
void *pthread_getspecific(pthread_key_t key);
int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));
示例代码：#include <pthread.h>
pthread_key_t tsd_key;
pthread_once_t key_once=PTHREAD_ONCE_INIT;
void once_routine(void)
{
int status;
status=pthread_key_create(&tsd_key,NULL);/*初始化线程私有数据键*/
if(status=0)
printf(“Key create success! My id is %u\n”,pthread_self());
}
void *child_thread(void *arg)
{
printf(“I’m child,My id is %u\n”,pthread_self());
pthread_once(&key_once,once_routine);/* 调用一次性初始化函数*/
}
int main(int argc,char *argv[ ])
{
pthread_t child_thread_id;
pthread_create(&child_thread_id,NULL,child_thread,NULL);
printf(“I’m father,my id is%u\n”,pthread_self());
pthread_once(&key_once,once_routine);
}程序运行结果如下:
I’m father,My id is 3086231232
Key create success! My id is 3086231232
I’m child,My id is 2086228400
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
