线程处理

一 ，线程相关函数

1.1 线程创建 

头文件

　　#include<pthread.h>

SRE实战 互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。

函数声明

　　int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict_attr,void*（*start_rtn)(void*),void *restrict arg);

返回值

　　若成功则返回0，否则返回出错编号

参数

　　第一个参数为指向线程标识符的指针。

　　第二个参数用来设置线程属性。

　　第三个参数是线程运行函数的地址。

　　最后一个参数是运行函数的参数。

注意

　　在编译时注意加上-lpthread参数，以调用静态链接库。因为pthread并非Linux系统的默认库。 

　　也可以用函数 pthread_t pthread_self(void); 获取线程的ID，getpid是获取进程ID,gettid()是获取线程id

1.2 pthread_join函数

函数简介

　　函数pthread_join用来等待一个线程的结束。

函数原型为：

　　extern int pthread_join __P (pthread_t __th, void **__thread_return);

参数：

　　第一个参数为被等待的线程标识符

　　第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。

注意

    这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。如果执行成功，将返回0，如果失败则返回一个错误号。

例子：

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<pthread.h>
 4 
 5 /* 声明结构体 */
 6 struct member
 7 {
 8     int num;
 9     char *name;
10 };     
11 
12 /* 定义线程pthread */
13 static void * pthread(void *arg)       
14 {
15     struct member *temp;
16     
17     /* 线程pthread开始运行 */
18     printf("pthread start!\n");
19     
20     /* 令主线程继续执行 */
21     sleep(2);
22     
23     /* 打印传入参数 */
24     temp = (struct member *)arg;      
25     printf("member->num:%d\n",temp->num);
26     printf("member->name:%s\n",temp->name);
27     
28     return NULL;
29 }
30 
31 /* main函数 */
32 int main(int agrc,char* argv[])
33 {
34     pthread_t tidp;
35     struct member *b;
36 
37     /* 为结构体变量b赋值 */
38     b = (struct member *)malloc(sizeof(struct member));           
39     b->num=1;
40     b->name="mlq";              
41 
42     /* 创建线程pthread */
43     if ((pthread_create(&tidp, NULL, pthread, (void*)b)) == -1)
44     {
45         printf("create error!\n");
46         return 1;
47     }
48     
49     /* 令线程pthread先运行 */
50     sleep(1);
51     
52     /* 线程pthread睡眠2s，此时main可以先执行 */
53     printf("mian continue!\n");
54     
55     /* 等待线程pthread释放 */
56     if (pthread_join(tidp, NULL))                  
57     {
58         printf("thread is not exit...\n");
59         return -2;
60     }
61     
62     return 0;
63 }

编译与执行结果

    编译与执行结果如下图所示，可以看到主线程main和线程pthread交替执行。也就是说是当我们创建了线程pthread之后，两个线程都在执行，证明创建成功。另外，可以看到创建线程pthread时候，传入的参数被正确打印。

1.3 线程退出 
线程的退出方式有三： 
（1）执行完成后隐式退出； 
（2）由线程本身显示调用pthread_exit 函数退出； 

pthread_exit (void * retval) ;

（3）被其他线程用pthread_cance函数终止： 

pthread_cancel (pthread_t thread) ;

　　在某线程中调用此函数，可以终止由参数thread 指定的线程。 

 

二，线程共享

2.1 条件变量函数

pthread_cond_t表示多线程的条件变量，用于控制线程等待和就绪的条件。

2.1.1 条件变量的初始化

　　API定义如下：

int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);  

2.1.2 条件变量的销毁

　　注销一个条件变量需要调用pthread_cond_destroy()，只有在没有线程在该条件变量上等待的时候才能注销这个条件变量，否则返回EBUSY。 因为Linux实现的条件变量没有分配什么资源，所以注销动作只包括检查是否有等待线程。API定义如下： 　　int pthread_cond_destroy(pthread_cond_t *cond)

2.1.3 等待和触发

1)条件等待 　　int pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t * mutex);   2)时间等待 　　int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);   　　其中计时等待方式如果在给定时刻前条件没有满足，则返回ETIMEOUT，结束等待， 其中abstime以与time()系统调用相同意义的绝对时间形式出现，0表示格林尼治时间1970年1月1日0时0分0秒。

2.2 互斥锁和条件变量

　　无论哪种等待方式，都必须和一个互斥锁配合，以防止多个线程同时请求pthread_cond_wait()（或pthread_cond_timedwait()，下同） 的竞争条件（Race Condition）。mutex互斥锁必须是普通锁（PTHREAD_MUTEX_TIMED_NP） 或者适应锁（PTHREAD_MUTEX_ADAPTIVE_NP），且在调用pthread_cond_wait()前必须由本线程加锁（pthread_mutex_lock()）。
　　当执行到pthread_cond_wait()，没有等到合适的条件，责先将mutex解锁，再进入线程挂起状态；当pthread_cond_wait接受到唤醒后信号，线程先对mutex加锁，再离开pthread_cond_wait状态，处理完事情后解锁mutex。  

使用pthread_cond_wait方式如下：

    pthread _mutex_lock(&mutex)

    while或if(线程执行的条件是否成立)

          pthread_cond_wait(&cond, &mutex);

    线程执行

    pthread_mutex_unlock(&mutex);

 

2.3 激发条件

　　激发条件有两种形式，pthread_cond_signal()激活一个等待该条件的线程，存在多个等待线程时按入队顺序激活其中一个； 而pthread_cond_broadcast()则激活所有等待线程。

2.4 为什么调用pthread_cond_wait之前要加锁

　　首先解释为什么在等待前加锁，因为线程隶属于进程，线程共享进程的资源，如果不进行加锁，就会造成多个线程同时（相对意义的同时，可能一个线程在函数A中更改此共享资源，此时函数A没结束，另一个线程也访问了这个共享资源）访问这块共享的资源，如果对临界区的内容进行更改，那么两个线程就会造成数据的不准确。所以在更改临界资源的时候要枷锁。而调用pthread_cond_wait之前要加锁也是为了避免多个线程竞争一个条件，造成共享的资源被多个线程更改。所以需要互斥的访问共有资源，

 

那么在pthread_cond_wait之前需要加锁，避免别的线程更改共有资源。

2.5 pthread_cond_wait内部调用了什么。

　　接下来思考pthread_cond_wait内部做了哪些操作。 在pthread_cond_wait调用之前，线程调用pthread_mutex_lock,设置锁，如果条件不满足，那么该线程处于阻塞等待的状态。别的线程 发现条件满足后会调用pthread_cond_signal或pthread_cond_broadcast通知他。那么问题出来了，如果该线程不解锁，别的线程是没办法 更改共享资源的，也就没办法设置条件变量使其满足该线程的等待条件，出现死锁。所以，pthread_cond_wait会在内部进行解锁操作。别的 线程可以访问共享资源，更改条件触发该线程，是该线程从阻塞状态变为就绪。 所以，pthread_cond_wait内部的操作顺序是将线程放到等待队列，然后解锁，等条件满足时进行加锁，然后返回。 整理下pthread_cond_wait内部操作

　　1，线程放在等待队列上，解锁

　　2，等待 pthread_cond_signal或者pthread_cond_broadcast信号之后去竞争锁

　　3，若竞争到互斥索则加锁。

 

2.6 使用流程

2.6.1 等待线程：

pthread_mutex_lock(&mutex);

if(条件不满足)

　　pthread_cond_wait(&cond, &mutex);

//处理共享资源

pthread_mutex_unlock(&mutex);

 

2.6.2 激活线程：

pthread_mutex_lock(&mutex);

pthread_cond_signal(&cond);

pthread_mutex_unlock(&mutex);

 

下面写了一个例子

#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <iostream>
using namespace std;

int count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 
//该函数增加count数值
void * creator(void * arg)
{
    cout << "creator add lock" << endl;
    pthread_mutex_lock(&mutex);

    count ++;

    cout << "in creator count is : " << count << endl;
    //条件满足时发送信号
    if(count > 0)
    {

        pthread_cond_signal(&cond);
    }

    
    cout << "creator release lock" << endl;
    
    pthread_mutex_unlock(&mutex);

    return NULL;

}

//该函数减少count数值
void * consumer(void * arg)
{
    cout << "consumer add lock" << endl;

    pthread_mutex_lock(&mutex);
    //当条件不满足时等待
    while(count <= 0) //防止虚假唤醒
    {
        cout << "begin wait" << endl;
        pthread_cond_wait(&cond,&mutex);
        cout << "end wait" << endl;
    }

    count --;

    cout << "in consumer count is " << count << endl;

    pthread_mutex_unlock(&mutex);

    cout << "consumer release lock" << endl;
    
    return NULL;
    
}


int main()
{
    //两个线程，一个生产者线程一个消费者线程
    pthread_t createthread,consumethread;

     pthread_create(&consumethread, NULL, consumer, NULL);
　　 sleep(2);
    pthread_create(&createthread, NULL, creator, NULL);
    
    //主进程等待两个线程结束
    pthread_join(createthread, NULL);
    pthread_join(consumethread, NULL);
    return 0;
}

因为消费者线程先跑起来，会等待生产者增加count数量，所以打印输出结果如下   下面将消费者和生产者线程增加几个，creater和consumer内部用循环处理， 这样就能看出效果了。  

void * creator(void * arg)
{
    int i = 0;
    while(i<300)
    {

        i++;
        cout << "creator add lock" << endl;
        pthread_mutex_lock(&mutex);

        count ++;

        cout << "in creator count is : " << count << endl;

        if(count > 0)
        {

            pthread_cond_signal(&cond);
        }

    
        cout << "creator release lock" << endl;
    
        pthread_mutex_unlock(&mutex);

    }

    return NULL;

}





void * consumer(void * arg)
{
    int i = 0;
    while(i < 100)
    {
        
        i++;
        cout << "consumer add lock" << endl;

        pthread_mutex_lock(&mutex);

        while(count <= 0) //防止虚假唤醒
        {
            cout << "begin wait" << endl;
            pthread_cond_wait(&cond,&mutex);
            cout << "end wait" << endl;
        }

        count --;

        cout << "in consumer count is " << count << endl;

        pthread_mutex_unlock(&mutex);

        cout << "consumer release lock" << endl;
    }
    
    return NULL;
    
}


int main()
{
     pthread_t createthread[2],consumethread[3];

     for(int i = 0; i < 3; i++)
     {
        pthread_create(&consumethread[i], NULL, consumer, NULL);
     }
     
     for(int i = 0; i < 2; i++)
     {
        pthread_create(&createthread[i], NULL, creator, NULL);
         }
     
     for(int i = 0; i < 2; i++)
      {
        pthread_join(createthread[i], NULL);
         }

     for(int i = 0; i < 3; i++)
     {
         pthread_join(consumethread[i], NULL);
     }

    
    return 0;

}

 

截取一部分结果截图，可以看出数字是连续变动的，而且

加锁解锁内数字才变动，说明我们对锁和条件变量使用合理。

扫码关注我们

微信号：SRE实战

拒绝背锅 运筹帷幄