系统编程--线程

1.线程概念

一个线程由表示一个进程里的一个执行上下文所需的信息组成。这包括一个在进程里标识线程的线程ID、一组寄存器值、栈、调用优先级和策略、信号掩码、errno变量（1.7节）、和线程指定数据（12.6节）。在一个进程内的所有东西在进程里的线程间都可以共享，包括可执行程序的代码、程序的全局和堆内存、栈、和文件描述符。

 

不共享的资源

2.线程标识

就像每个进程有一个进程ID一样，每个线程也有一个线程ID。进程ID在整个系统的唯一的，但线程ID不同，线程ID只在它所属的进程环境中有效

1).下面一个函数被用来比较两个线程ID
#include <pthreads.h>
int pthread_equal(pthread_t tid1, pthread_t tid2);
//相等返回非0，否则返回0.

2).线程可以获得它自己的线程ID，通过调用pthread_self函数。
#include <pthread.h>
pthread_t thread_self(void);
//返回调用线程的线程ID。

当线程需要识别以线程ID作为标签的数据结构时，pthread_self可以和pthread_equal一起使用

 

3.线程创建

线程可以通过调用pthread_create函数创建。

#include <pthread.h>
int pthread_create(pthread *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void), void *restrict arg);
//成功返回0，失败返回错误号。

当pthread_create成功返回时,由tidp所指向的内存单元被设置为新创建线程的线程ID，attr参数用于定制不同线程属性.

pthread_t *thread:传递一个pthread_t变量地址进来，用于保存新线程的tid（线程ID）

const pthread_attr_t *attr:线程属性设置，如使用默认属性，则传NULL

void *(*start_routine) (void *):函数指针，指向新线程应该加载执行的函数模块

void *arg:指定线程将要加载调用的那个函数的参数

返回值:成功返回0，失败返回错误号。以前学过的系统函数都是成功返回0，失败返回-1，而错误号保存在全局变量errno中，而pthread库的函数都是通过返回值返回错误号，虽然每个线程也都有一个errno，但这是为了兼容其它函数接口而提供的，pthread库本身并不使用它，通过返回值返回错误码更加清晰。

 

4.线程终止

单个线程可以用三种方式退出，在不终止整个进程的情况下停止它的控制流。

•  线程可以简单地从启动例程退出。返回值是线程的退出码。
•  线程可以被同一进程的其它线程取消。
•  线程可以调用pthread_exit。

1).退出函数pthread_exit

#include <pthread.h>
void pthread_exit(void *rval_ptr);

rval_ptr是无类型指针，和传入启动例程的单个参数相似。可以是退出值或地址，如是地址时，不能是线程内部申请的局部地址。

2).rval_ptr指针对进程里的其它线程可用，通过调用pthread_join函数。

#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);
//成功返回0，失败返回错误码。

　　调用线程将阻塞，直到指定的线程调用pthread_exit、从它的启动例程返回或被取消。如果线程简单地从它的启动例程返回，那么rval_ptr将包含返回码。如果线程被取消，那么由rval_ptr指定的内存单元被设为PTHREAD_CANCELED。可以通过调用pthread_join，我们自动把一个线程置于分离状态以便它的资源可以被恢复。如果线程已经在分离状态了，那么调用pthread_join失败，返回EINVAL。

3).线程可以通过调用pthread_cancel函数来请求同一进程内的另一个线程取消。

#include <pthread.h>
int pthread_cancel(pthread_t tid);
//成功返回0，失败返回错误号。

　　在默认情况下，pthread_cancel函数使得tid标识的线程的行为表现为如同调用参数为PTHREAD_CANCELED的pthread_exit。但是，线程可以选择忽略或控制它如何被取消。注意pthread_cancel不等待线程终止，它只是发出请求。

线程示例
打印pthread_t时使用lu
#include <unistd.h>
#include <sys/types.h>
#include <error.h>
#include <pthread.h>
#include <stdio.h>

void *thrfn1(void *arg){
    int in=(int )arg;
    printf("thread 1 is up, input arg is %d
",in);
    return (void*)1;
}
void *thrfn2(){
    printf("thread 2 is up, pthread id  is %lu
",pthread_self());
    pthread_exit((void*)2);
}
void *thrfn3(){
    printf("thread 3 is up, pthread id  is %lu
",pthread_self());
    int i=0;
    while(1){
        sleep(1);
        if(i++%2==1)
            pthread_cancel(pthread_self());
    }
    pthread_exit((void*)3);
}

int main(){
    int err;
    pthread_t tid1,tid2,tid3;
    void *tret;

    err=pthread_create(&tid1,NULL,thrfn1,(void*)14);
    if(err!=0)
        perror("create thread 1 err");
    err=pthread_create(&tid2,NULL,thrfn2,NULL);
    if(err!=0)
        perror("create thread 2 err");
    err=pthread_create(&tid3,NULL,thrfn3,NULL);
    if(err!=0)
        perror("create thread 3 err");

    err=pthread_join(tid1,&tret);
    if(err!=0)
        perror("join thread 1 err");
    printf("thread 1 exit coade is %d
",(long)tret);
    err=pthread_join(tid2,&tret);
    if(err!=0)
        perror("join thread 2 err");
    printf("thread 2 exit coade is %d
",(long)tret);
    err=pthread_join(tid3,&tret);
    if(err!=0)
        perror("join thread 3 err");
    printf("thread 3 exit coade is %d
",(long)tret);
    return 0;
}

5.线程同步

以下概念用处很多人已经很熟悉，这里只列出线程环境下，所用到的函数及其功能

1).互斥量

互斥体变量由pthread_mutex_t数据类型表示。在使用一个mutex变量之前，我们必须首先初始化它，通过把它设置为常量PTHREAD_MUTEX_INITIALIZER（只对于静态分配的互斥体），也可以通过pthread_mutex_init函数初始化。如果动态地分配互斥体（例如通过调用malloc），那么我们需要在释放内存前调用pthread_mutex_destroy

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
//成功返回0，失败返回错误码。

为了使用默认属性初始化一个互斥体，我们把attr设置为NULL

对互斥量进行加锁，需要调用pthread_mutex_lock。如果互斥体已经上锁了，调用线程将阻塞，直到互斥体被解锁。对呼哧两解锁，调用pthread_mutex_unlock。

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
//成功返回0，失败返回错误号。

如果一个线程不能容许阻塞，那么它可以使用pthread_mutex_trylock来尝试对互斥量进行加锁。如果调用pthread_mutex_trylock时互斥量出于未加锁状态，那么pthread_mutex_trylock会不阻塞地锁住互斥量并返回0。否则，pthread_mutex_trylock将会失败，返回EBUSY而不锁住这个互斥量。

互斥量示例
#include <unistd.h>
#include <sys/types.h>
#include <error.h>
#include <pthread.h>
#include <stdio.h>

pthread_mutex_t mutex;
int adder=0;
int stop=0;

void *thrfn1(void *arg){
    int in=(int )arg;
    printf("thread 1 is up, input arg is %d
",in);
    while(1){
        pthread_mutex_lock(&mutex);
        adder++;
        printf("thread 1 adder = %d
",adder);
        pthread_mutex_unlock(&mutex);
        if(stop==1)
            goto end;
    }
    end:return (void*)1;
}
void *thrfn2(){
    printf("thread 2 is up, pthread id  is %lu
",pthread_self());
    while(1){
        pthread_mutex_lock(&mutex);
        adder++;
        printf("thread 2 adder = %d
",adder);
        pthread_mutex_unlock(&mutex);
        if(stop==1)
            goto end;
    }
    end:pthread_exit((void*)2);
}
void *thrfn3(){
    printf("thread 3 is up, pthread id  is %lu
",pthread_self());
    int i=0;
    while(1){
        sleep(1);
        if(i++%2==1)
            pthread_cancel(pthread_self());
    }
    pthread_exit((void*)3);
}

int main(){
    int err;
    pthread_t tid1,tid2,tid3;
    void *tret;

    pthread_mutex_init(&mutex,NULL);

    err=pthread_create(&tid1,NULL,thrfn1,(void*)14);
    if(err!=0)
        perror("create thread 1 err");
    err=pthread_create(&tid2,NULL,thrfn2,NULL);
    if(err!=0)
        perror("create thread 2 err");
    err=pthread_create(&tid3,NULL,thrfn3,NULL);
    if(err!=0)
        perror("create thread 3 err");

    sleep(4);
    stop=1;

    err=pthread_join(tid1,&tret);
    if(err!=0)
        perror("join thread 1 err");
    printf("thread 1 exit coade is %d
",(long)tret);
    err=pthread_join(tid2,&tret);
    if(err!=0)
        perror("join thread 2 err");
    printf("thread 2 exit coade is %d
",(long)tret);
    err=pthread_join(tid3,&tret);
    if(err!=0)
        perror("join thread 3 err");
    printf("thread 3 exit coade is %d
",(long)tret);
 pthread_mutex_destroy(&mutex);
    return 0;
}

2).避免死锁

 死锁是个必要条件：

a.互斥（Mutual exclusion）：存在这样一种资源，它在某个时刻只能被分配给一个执行绪（也称为线程）使用；

b.持有（Hold and wait）：当请求的资源已被占用从而导致执行绪阻塞时，资源占用者不但无需释放该资源，而且还可以继续请求更多资源；

c.不可剥夺（No preemption）：执行绪获得到的互斥资源不可被强行剥夺，换句话说，只有资源占用者自己才能释放资源；

d.环形等待（Circular wait）：若干执行绪以不同的次序获取互斥资源，从而形成环形等待的局面，想象在由多个执行绪组成的环形链中，每个执行绪都在等待下一个执行绪释放它持有的资源

避免死锁破坏后三个条件即可(互斥不能被破坏)

 

3).读写锁

读写锁可以有三个状态：读模式下加锁状态，写模式下加锁状态，不加锁状态。一次只有一个线程可以占有写模式的读写锁，但多个线程可以同时占有读模式的读写锁。

读写锁非常适合对数据结构读的次数远大于写的情况。读写锁在写模式下时，它所保护的数据结构可以被安全地修改，因为当前只有一个线程可以拥有写模式的锁。当读写锁在读模式被下，只要线程获取了读模式的读写锁，该锁保护的数据结构可以被多个获得读模式锁的线程读取。简而言之，当读写锁以读模式锁住时，它是以共享模式锁住。当它以写模式锁住时，它是以互斥模式锁住的，所以说读写锁也叫做共享-独占锁。和互斥量一样，读写锁在使用之前必须初始化，在释放它们底层的内存前必须销毁

#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
//两者成功返回0，失败返回错误号。

读写锁通过调用phthread_rwlock_init初始化,调用pthread_rwlock_destroy来做清理工作，否则不调用pthread_rwlock_destroy或者调用pthread_rwlock_destroy之前释放了读写锁占用的内存空间，那么分配这个锁的资源就丢失了

在读模式锁定读写锁，需要调用pthread_rwlock_rdlock。为要在写模式下锁定读写锁，需要调用pthread_rwlock_wrlock。不管以何种方式锁住读写锁，都可以调用pthread_rwlock_unlock来解锁它

#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
//三者成功返回0，失败返回错误号。

在实现读写锁的时候可能对共享模式下可获取的锁的数量上加个限制，所以需要检查pthread_rwlock_rdlock的返回值

#include <pthread.h>
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
//两者成功返回0，失败返回错误号

可以获取锁时，函数返回0；否则错误EBUSY

4).条件变量

条件变量是线程可用的另一个同步机制。条件变量给多个线程提供了一个会合的场所。条件变量和互斥量一起使用时，允许线程以无竞争的方式等待特定条件的发生。

条件变量被使用前必须首先被初始化。pthread_cond_t数据类型代表的条件变量可以以两种方式初始化。可以把常量PTHREAD_COND_INITIALIZER赋给一个静态分配的条件变量，但是如果条件变量是动态分配的，可以使用pthread_cond_init函数来初始化它。

在释放它底下的内存前，可以使用pthread_cond_destroy函数对条件变量进行去除初始化。

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t *cond);
//两者成功返回0，失败返回错误号。

除非需要创建一个非默认属性条件变量，否则pthread_cond_init的attr参数可以被设置为NULL

 

使用pthread_cond_wait来等待条件为真。如果在给定的时间内条件不能满足，那么会生成一个代表出错码的返回变量

#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);
//成功返回0，失败返回错误号。

传递给pthread_cond_wait的互斥量保护这个条件。调用者把锁住的互斥量传递给这个函数，函数把调用线程放在等待这个条件的线程列表上，并解锁这个互斥体，这两个操作是原子操作。这样就关闭了条件被检查和线程进入休眠状态等待条件改变这两个操作的时间间隔，这样线程不会错过条件的任何改变。当pthread_cond_wait返回时，互斥量会再次被锁住。pthread_cond_timedwait函数和pthread_cond_wait函数类似，只是多了个timeout--超时控制

 

有两个函数来通知线程一个条件已经被满足。pthread_cond_signal函数将唤醒等待在一个条件上的某个线程，而pthread_cond_broadcast函数将唤醒等待在一个条件上的所有线程。

int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
//成功返回0，失败返回错误号。

调用pthread_cond_signal或pthread_cond_broadcast时，也称为向线程或者条件发送信号。必须注意一定要在改变条件状态之后才发送信号给线程。

条件变量
必须先解锁后发信号
#include <unistd.h>
#include <sys/types.h>
#include <error.h>
#include <pthread.h>
#include <stdio.h>

pthread_mutex_t mutex;
pthread_cond_t cond;
int adder=0;
int stop=0;

void *thrfn1(void *arg){
    int in=(int )arg;
    printf("thread 1 is up, input arg is %d
",in);
    while(1){
        pthread_mutex_lock(&mutex);
        //sleep(1);
        usleep(10000);
        if(adder%2!=0){
            adder++;
            printf("thread 1 adder = %d
",adder);
        }
        pthread_mutex_unlock(&mutex);
        if(adder%2==0)
            pthread_cond_signal(&cond); 
        if(stop==1)
            goto end;
    }
    end:return (void*)1;
}   
void *thrfn2(){
    printf("thread 2 is up, pthread id  is %lu
",pthread_self());
    while(1){
        pthread_mutex_lock(&mutex); 
        if(adder%2!=0)
            pthread_cond_wait(&cond,&mutex);
        adder++;
        printf("thread 2 adder = %d
",adder);
        pthread_mutex_unlock(&mutex);
        if(stop==1)
            goto end;
    }
    end:pthread_exit((void*)2);
}

int main(){
    int err;
    pthread_t tid1,tid2;
    void *tret;

    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&cond,NULL);

    err=pthread_create(&tid1,NULL,thrfn1,(void*)14);
    if(err!=0)
        perror("create thread 1 err");
    err=pthread_create(&tid2,NULL,thrfn2,NULL);
    if(err!=0)
        perror("create thread 2 err");

    sleep(4);
    stop=1;

    err=pthread_join(tid1,&tret);
    if(err!=0)
        perror("join thread 1 err");
    printf("thread 1 exit coade is %d
",(long)tret);
    err=pthread_join(tid2,&tret);
    if(err!=0)
        perror("join thread 2 err");
    printf("thread 2 exit coade is %d
",(long)tret);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

barrier(屏障)与互斥量，读写锁，自旋锁不同，它不是用来保护临界区的。相反，它跟条件变量一样，是用来协同多线程一起工作！！！

 

条件变量是多线程间传递状态的改变来达到协同工作的效果。屏障是多线程各自做自己的工作，如果某一线程完成了工作，就等待在屏障那里，直到其他线程的工作都完成了，再一起做别的事

创建
#include <pthread.h> 
int pthread_barrier_init(pthread_barrier_t *restrict barrier, const pthread_barrierattr_t *restrict attr, unsigned count);
barrier：pthread_barrier_t结构体指针
attr：屏障属性结构体指针
count：屏障等待的线程数目，即要count个线程都到达屏障时，屏障才解除，线程就可以继续执行

等待
#include <pthread.h>
int pthread_barrier_wait(pthread_barrier_t *barrier);
函数的成功返回值有2个，第一个成功返回的线程会返回PTHREAD_BARRIER_SERIAL_THREAD，其他线程都返回0。可以用第一个成功返回的线程来做一些善后处理工作。

销毁
#include <pthread.h>
int pthread_barrier_destroy(pthread_barrier_t *barrier);

屏障示例
#include <unistd.h>
#include <sys/types.h>
#include <error.h>
#include <pthread.h>
#include <stdio.h>

pthread_mutex_t mutex;
pthread_cond_t cond;
pthread_barrier_t bar;
int adder=0;
int stop=0;

void *thrfn1(void *arg){
    int in=(int )arg;
    printf("thread 1 is up, input arg is %d
",in);
    pthread_barrier_wait(&bar);
    while(1){
        pthread_mutex_lock(&mutex);
        //sleep(1); 
        usleep(50000);
        if(adder%2!=0){
            adder++;
            printf("thread 1 adder = %d
",adder);
        }
        pthread_mutex_unlock(&mutex);
        if(adder%2==0)
            pthread_cond_signal(&cond);
        if(stop==1) 
            goto end; 
    }
    end:return (void*)1;
}   
void *thrfn2(){
    printf("thread 2 is up, pthread id  is %lu
",pthread_self());
    pthread_barrier_wait(&bar);
    while(1){
        pthread_mutex_lock(&mutex);
        if(adder%2!=0)
            pthread_cond_wait(&cond,&mutex);
        adder++;
        printf("thread 2 adder = %d
",adder);
        pthread_mutex_unlock(&mutex);
        if(stop==1)
            goto end;
    }
    end:pthread_exit((void*)2);
}

int main(){
    int err;
    pthread_t tid1,tid2;
    void *tret;

    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&cond,NULL);
    pthread_barrier_init(&bar,NULL,2);//num is biggest pthreads

    err=pthread_create(&tid1,NULL,thrfn1,(void*)14);
    if(err!=0)
        perror("create thread 1 err");
    err=pthread_create(&tid2,NULL,thrfn2,NULL);
    if(err!=0)
        perror("create thread 2 err");

    sleep(4);
    stop=1;

    err=pthread_join(tid1,&tret);
    if(err!=0)
        perror("join thread 1 err");
    printf("thread 1 exit coade is %d
",(long)tret);
    err=pthread_join(tid2,&tret);
    if(err!=0)
        perror("join thread 2 err");
    printf("thread 2 exit coade is %d
",(long)tret);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    pthread_barrier_destroy(&bar);
    return 0;
}