（三）线程通信（二）-POSIX线程
目录
37POSIX线程（一）
POSIX线程库相关函数
用线程实现回射客户/服务器
38POSIX线程（二）
线程属性
线程特定数据
37POSIX线程（一）
由于同一进程的多个线程共享同一地址空间，因此Text Segment、Data Segment都是共享的，如果定义一个函数，在各线程中都可以调用，如果定义一个全局变量，在各线程中都可以访问到，
除此之外，各线程还共享以下进程资源和环境：
文件描述符表 每种信号的处理方式（SIG_IGN、SIG_DFL或者自定义的信号处理函数） 当前工作目录 用户id和组id但有些资源是每个线程各有一份的：
线程id 上下文，包括各种寄存器的值、程序计数器和栈指针 栈空间 errno变量 信号屏蔽字 调度优先级我们将要学习的线程库函数是由POSIX标准定义的，称为POSIX thread或者pthread。在Linux上线程函数位于libpthread共享库中，因此在编译时要加上-lpthread选项。
POSIX线程库相关函数
函数原型
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);函数功能
创建一个新的线程返回值
成功返回0；失败返回错误码参数说明
thread:返回线程ID attr:设置线程的属性，attr为NULL表示使用默认属性 start_routine:是个函数地址，线程启动后要执行的函数 arg:传给线程启动函数的参数错误检查：
以前学过的系统函数都是成功返回0，失败返回-1，而错误号保存在全局变量errno中，而pthread库的函数都是通过返回值返回错误号，虽然每个线程也都有一个errno，但这是为了兼容其它函数接口而提供的，pthread库本身并不使用它，通过返回值返回错误码更加清晰。由于pthread_create的错误码不保存在errno中，因此不能直接用perror(3)打印错误信息，可以先用strerror(3)把错误号转换成错误信息再打印。
函数原型
void pthread_exit(void *value_ptr);函数功能
线程终止返回值
无返回值，跟进程一样，线程结束的时候无法返回到它的调用者（自身）参数说明
value_ptr：value_ptr不要指向一个局部变量，因为当其它线程得到这个返回指针时线程函数已经退出了。如果需要只终止某个线程而不终止整个进程，可以有三种方法：
- 1、从线程函数return。这种方法对主线程不适用，从main函数return相当于调用exit，而如果任意一个线程调用了exit或_exit，则整个进程的所有线程都终止。
- 2、一个线程可以调用pthread_cancel 终止同一进程中的另一个线程。
- 3、线程可以调用pthread_exit终止自己。
函数原型
int pthread_join(pthread_t thread, void **value_ptr);函数功能
等待线程结束返回值
成功返回0；失败返回错误码参数说明
thread:线程ID value_ptr:它指向一个指针，后者指向线程的返回值当pthread_create 中的 start_routine返回时，这个线程就退出了，其它线程可以调用pthread_join得到start_routine的返回值，类似于父进程调用wait(2)得到子进程的退出状态。
调用该函数的线程将挂起等待，直到id为thread的线程终止。thread线程以不同的方法终止，通过pthread_join得到的终止状态是不同的，总结如下：
- 1、如果thread线程通过return返回，value_ptr所指向的单元里存放的是thread线程函数的返回值。
- 2、如果thread线程被别的线程调用pthread_cancel异常终止掉，value_ptr所指向的单元里存放的是常数PTHREAD_CANCELED。
- 3、如果thread线程是自己调用pthread_exit终止的，value_ptr所指向的单元存放的是传给pthread_exit的参数。
如果对thread线程的终止状态不感兴趣，可以传NULL给value_ptr参数。
函数原型
pthread_t pthread_self(void);函数功能
返回线程ID返回值
成功返回线程id参数说明
在Linux上，pthread_t类型是一个地址值，属于同一进程的多个线程调用getpid(2)可以得到相同的进程号，而调用pthread_self(3)得到的线程号各不相同。线程id只在当前进程中保证是唯一的，在不同的系统中pthread_t这个类型有不同的实现，它可能是一个整数值，也可能是一个结构体，也可能是一个地址，所以不能简单地当成整数用printf打印。
函数原型
int pthread_cancel(pthread_t thread);函数功能
取消一个执行中的线程返回值
成功返回0；失败返回错误码参数说明
thread:线程ID一个新创建的线程默认取消状态（cancelability state）是可取消的，取消类型（ cancelability type）是同步的，即在某个可取消点（ cancellation point，即在执行某些函数的时候）才会取消线程。具体可以man 一下。
相关函数 int pthread_setcancelstate(int state, int *oldstate); int pthread_setcanceltype(int type, int *oldtype); 为保证一个事务型处理逻辑的完整可以使用这两个函数，如下举例，主线程创建完线程睡眠一阵调用pthread_cancel，test是thread_function。
void *test(void *arg) { for (int i = 0; i < 10; i++) { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); printf("start: %d; ", i); sleep(1); printf("end: %d\n", i); if (i > 7) { pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); pthread_testcancel(); } } return (void *)0; }
函数原型
int pthread_detach(pthread_t thread);函数功能
将一个线程分离返回值
成功返回0；失败返回错误码参数说明
thread:线程ID一般情况下，线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止（僵线程）。但是线程也可以被置为detach状态，这样的线程一旦终止就立刻回收它占用的所有资源，而不保留终止状态。不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL。对一个尚未detach的线程调用pthread_join或pthread_detach都可以把该线程置为detach状态，也就是说，不能对同一线程调用两次pthread_join，或者如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。
这个函数既可以在主线程中调用，也可以在thread_function里面调用。
在主线程中通过线程属性也可以达到同样的效果，如下：
pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); pthread_t tid; pthread_create(&tid, &attr, test, "a"); // test is thread_function sleep(3); pthread_attr_destroy(&attr);
下面写个程序走一下这些函数：
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define ERR_EXIT(m) \
do { \
perror(m); \
exit(EXIT_FAILURE); \
} while(0)
void *routine(void *arg)
{
int i;
for (i = 0; i < 20; i++)
{
printf("B");
fflush(stdout);
usleep(20);
/*
if (i == 3)
pthread_exit("ABC");
*/
}
return "DEF";
}
int main(void)
{
pthread_t tid;
int ret;
if ((ret = pthread_create(&tid, NULL, routine, NULL)) != 0)
{
fprintf(stderr, "pthread create: %s\n", strerror(ret));
exit(EXIT_FAILURE);
}
int i;
for (i = 0; i < 20; i++)
{
printf("A");
fflush(stdout);
usleep(20);
}
void *value;
if ((ret = pthread_join(tid, &value)) != 0)
{
fprintf(stderr, "pthread create: %s\n", strerror(ret));
exit(EXIT_FAILURE);
}
printf("\n");
printf("return msg=%s\n", (char *)value);
return 0;
}
用线程实现回射客户/服务器
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while(0)
void echo_srv(int conn)
{
char recvbuf[1024];
while (1)
{
memset(recvbuf, 0, sizeof(recvbuf));
int ret = read(conn, recvbuf, sizeof(recvbuf));
if (ret == 0)
{
printf("client close\n");
break;
}
else if (ret == -1)
ERR_EXIT("read");
fputs(recvbuf, stdout);
write(conn, recvbuf, ret);
}
close(conn);
}
void *thread_routine(void *arg)
{
/* 主线程没有调用pthread_join等待线程退出 */
pthread_detach(pthread_self()); //剥离线程，避免产生僵线程
/*int conn = (int)arg;*/
int conn = *((int *)arg);
free(arg);
echo_srv(conn);
printf("exiting thread ...\n");
return NULL;
}
int main(void)
{
int listenfd;
if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
ERR_EXIT("socket");
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(5188);
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
int on = 1;
if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
ERR_EXIT("setsockopt");
if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
ERR_EXIT("bind");
if (listen(listenfd, SOMAXCONN) < 0)
ERR_EXIT("listen");
struct sockaddr_in peeraddr;
socklen_t peerlen = sizeof(peeraddr);
int conn;
while (1)
{
if ((conn = accept(listenfd, (struct sockaddr *)&peeraddr, &peerlen)) < 0)
ERR_EXIT("accept");
printf("ip=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
pthread_t tid;
// int ret;
/*pthread_create(&tid, NULL, thread_routine, (void*)&conn);*/ // race condition问题，竟态问题
int *p = malloc(sizeof(int));
*p = conn;
pthread_create(&tid, NULL, thread_routine, p);
/*
if ((ret = pthread_create(&tid, NULL, thread_routine, (void*)conn)) != 0) //64位系统时指针不是4个字节，不可移植
{
fprintf(stderr, "pthread_create:%s\n", strerror(ret));
exit(EXIT_FAILURE);
}
*/
}
38POSIX线程（二）
线程属性
POSIX 线程库定义了线程属性对象 pthread_attr_t ，它封装了线程的创建者可以访问和修改的线程属性。主要包括如下属性：
- 1. 作用域（scope）
- 2. 栈尺寸（stack size）
- 3. 栈地址（stack address）
- 4. 优先级（priority）
- 5. 分离的状态（detached state）
- 6. 调度策略和参数（scheduling policy and parameters）
线程属性对象可以与一个线程或多个线程相关联。当使用线程属性对象时，它是对线程和线程组行为的配置。使用属性对象的所有线程都将具有由属性对象所定义的所有属 性。虽然它们共享属性对象，但它们维护各自独立的线程 ID 和寄存器。
线程可以在两种竞争域内竞争资源：
1. 进程域（process scope）：与同一进程内的其他线程
2. 系统域（system scope）：与系统中的所有线程
作用域属性描述特定线程将与哪些线程竞争资源。一个具有系统域的线程将与整个系 统中所有具有系统域的线程按照优先级竞争处理器资源，进行调度。
分离线程是指不需要和进程中其他线程同步的线程。也就是说，没有线程会等待分离 线程退出系统。因此，一旦该线程退出，它的资源（如线程 ID）可以立即被重用。
线程的布局嵌入在进程的布局中。进程有代码段、数据段和栈段，而线程与进程中的 其他线程共享代码段和数据段，每个线程都有自己的栈段，这个栈段在进程地址空间的栈 段中进行分配。线程栈的尺寸在线程创建时设置。如果在创建时没有设置，那么系统将会 指定一个默认值，缺省值的大小依赖于具体的系统。
POSIX 线程属性对象中可设置的线程属性及其含义参见下表：
int pthread_attr_setstacksize(pthread_attr_t* attr, size_t stacksize) stacksize 决定了新创建线程的栈的最小尺寸
guardsize意思是如果我们使用线程栈超过了设定大小之后，系统还会使用部分扩展内存来防止栈溢出。而这部分扩展内存大小就是guardsize. 不过如果自己修改了栈分配位置的话，那么这个选项失效，效果相当于将guardsize设置为0.
每个线程都存在自己的堆栈，如果这些堆栈是相连的话，访问超过自己的堆栈的话那么可能会修改到其他线程的堆栈。 如果我们设置了guardsize的话，线程堆栈会多开辟guarszie大小的内存，当访问到这块内存时会触发SIGSEGV信号。
进程的调度策略和优先级属于主线程，换句话说就是设置进程的调度策略和优先级只 会影响主线程的调度策略和优先级，而不会改变对等线程的调度策略和优先级（注这句话不完全正确）。每个对等线程可以拥有它自己的独立于主线程的调度策略和优先级。
在 Linux 系统中，进程有三种调度策略：SCHED_FIFO、SCHED_RR 和 SCHED_OTHER，线程也不例外，也具有这三种策略。
在 pthread 库中，提供了一个函数，用来设置被创建的线程的调度属性：是从创建者线 程继承调度属性（调度策略和优先级），还是从属性对象设置调度属性。该函数就是：
int pthread_attr_setinheritsched (pthread_attr_t * attr, int inherit)
//其中，inherit 的值为下列值中的其一：
enum
{
PTHREAD_INHERIT_SCHED, //线程调度属性从创建者线程继承
PTHREAD_EXPLICIT_SCHED //线程调度属性设置为 attr 设置的属性
};
如果在创建新的线程时，调用该函数将参数设置为 PTHREAD_INHERIT_SCHED 时，那么当修改进程的优先级时，该进程中继承这个优先级并且还没有改变其优先级的所 有线程也将会跟着改变优先级（也就是刚才那句话部分正确的原因）。
程序测试
#include
#include
#include
#include
#include
#include
#include
#define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while(0)
int main(void)
{
pthread_attr_t attr;
pthread_attr_init(&attr);
int state;
pthread_attr_getdetachstate(&attr, &state);
if (state == PTHREAD_CREATE_JOINABLE)
printf("detachstate:PTHREAD_CREATE_JOINABLE\n");
else if (state == PTHREAD_CREATE_DETACHED)
printf("detachstate:PTHREAD_CREATE_DETACHED");
size_t size;
pthread_attr_getstacksize(&attr, &size);
printf("stacksize:%d\n", size);
pthread_attr_getguardsize(&attr, &size);
printf("guardsize:%d\n", size);
int scope;
pthread_attr_getscope(&attr, &scope);
if (scope == PTHREAD_SCOPE_PROCESS)
printf("scope:PTHREAD_SCOPE_PROCESS\n");
if (scope == PTHREAD_SCOPE_SYSTEM)
printf("scope:PTHREAD_SCOPE_SYSTEM\n");
int policy;
pthread_attr_getschedpolicy(&attr, &policy);
if (policy == SCHED_FIFO)
printf("policy:SCHED_FIFO\n");
else if (policy == SCHED_RR)
printf("policy:SCHED_RR\n");
else if (policy == SCHED_OTHER)
printf("policy:SCHED_OTHER\n");
int inheritsched;
pthread_attr_getinheritsched(&attr, &inheritsched);
if (inheritsched == PTHREAD_INHERIT_SCHED)
printf("inheritsched:PTHREAD_INHERIT_SCHED\n");
else if (inheritsched == PTHREAD_EXPLICIT_SCHED)
printf("inheritsched:PTHREAD_EXPLICIT_SCHED\n");
struct sched_param param;
pthread_attr_getschedparam(&attr, ¶m);
printf("sched_priority:%d\n", param.sched_priority);
pthread_attr_destroy(&attr);
return 0;
}
线程特定数据
- 在单线程程序中，我们经常要用到"全局变量"以实现多个函数间共享数据。
- 在多线程环境下，由于数据空间是共享的，因此全局变量也为所有线程所共有。
- 但有时应用程序设计中有必要提供线程私有的全局变量，仅在某个线程中有效，但却可以跨多个函数访问。
- POSIX线程库通过维护一定的数据结构来解决这个问题，这个些数据称为（Thread-specific Data，或 TSD）。
相关函数如下：
int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));
int pthread_key_delete(pthread_key_t key);
void *pthread_getspecific(pthread_key_t key);
int pthread_setspecific(pthread_key_t key, const void *value);
int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));
pthread_once_t once_control = PTHREAD_ONCE_INIT;
当调用pthread_key_create 后会产生一个所有线程都可见的线程特定数据（TSD）的pthread_key_t 值，调用pthread_setspecific 后会将每个线程的特定数据与pthread_key_t 绑定起来，虽然只有一个pthread_key_t，但每个线程的特定数据是独立的内存空间，当线程退出时会执行destructor 函数。
#include
#include
#include
#include
#include
#include
#include
#define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while(0)
typedef struct tsd
{
pthread_t tid;
char *str;
} tsd_t;
pthread_key_t key_tsd;
pthread_once_t once_control = PTHREAD_ONCE_INIT;
void destroy_routine(void *value)
{
printf("destory ...\n");
free(value);
}
void once_routine(void)
{
pthread_key_create(&key_tsd, destroy_routine);
printf("key init ...\n");
}
void *thread_routine(void *arg)
{
pthread_once(&once_control, once_routine);
tsd_t *value = (tsd_t *)malloc(sizeof(tsd_t));
value->tid = pthread_self();
value->str = (char *)arg;
pthread_setspecific(key_tsd, value);
printf("%s setspecific ptr=%p\n", (char *)arg, value);
value = pthread_getspecific(key_tsd);
printf("tid=0x%x str=%s ptr=%p\n", (int)value->tid, value->str, value);
sleep(2);
value = pthread_getspecific(key_tsd);
printf("tid=0x%x str=%s ptr=%p\n", (int)value->tid, value->str, value);
return NULL;
}
int main(void)
{
//pthread_key_create(&key_tsd, destroy_routine);
pthread_t tid1;
pthread_t tid2;
pthread_create(&tid1, NULL, thread_routine, "thread1");
pthread_create(&tid2, NULL, thread_routine, "thread2");
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
pthread_key_delete(key_tsd);
return 0;
}