线程间通信

线程间通信

　　参考博客：https://blog.csdn.net/a987073381/article/details/52029070

　　推荐博客：pthread_mutex_t

　　

　　线程间通信，一般指的是同一进程中的不同线程通信。不同进程中的线程通信其实属于进程间通信。

　　线程间通信方式：

　　1、全局变量：进程中线程间共享内存。同一进程中的不同线程共享同一全局内存区域，包括初始化数据段，未初始化数据段以及堆内存数据段。因此线程间可以方便、快速的共享信息。只需要将数据复制到共享（全局/堆）变量中即可。

　　注：要避免多个线程试图同时修改同一份信息。

　　　   定义全局变量时最好使用volatile定义，以防编译器对此变量优化。

　下图为多线程的进程地址空间：

　　2、Message消息机制

　　3、CEvent对象

线程安全

　　进程中的多个线程同时运行，当多个线程同时访问一段代码时，若每次运行结果和单线程运行结果一样，其他变量的值也和预期值一样，那么线程就是安全的，即多线程访问同一段代码不会产生不确定结果。如何保证线程安全——线程间同步。

线程间同步：

　　同步指的是多个任务按照约定的先后次序互相配合完成一件事情。Dijikstra基于信号量的概念，提出一个同步机制——由信号量来决定线程是否继续运行还是阻塞。

　　线程间同步的信号量采用POSIX的信号量接口。

　　信号量代表某一类资源，其值代表系统中该资源的数量。信号量是一个受保护的变量，只能通过三种操作来访问：

　　1）初始化

　　2）P操作（申请资源）

　　3）V操作（释放资源）

　　pthread库常用信号量操作函数如下：

#include <semaphore.h>

sem_t sem_event;
int sem_init(sem_t *sem, int pshared, unsigned int value);//初始化一个信号量 
int sem_destroy(sem_t * sem); //销毁信号量
int sem_post(sem_t * sem); //V操作：信号量增加1,
int sem_wait(sem_t * sem); //P操作：信号量减少1,如果信号量计数是0就会发生阻塞。直到成功使信号量减1
int sem_getvalue(sem_t * sem, int * sval); //获取当前信号量的值

　　测试：写线程，读线程对buf实现PV操作。

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>

char buffer[100];
sem_t sem; //定义信号量

void *write(void* arg)
{
    //detach改变线程状态为unjoinable,
    //在线程结束后，会自动回收资源
    pthread_detach(pthread_self());
    while(1)
    {
        fgets(buffer,20,stdin); //通过键盘输入
        sem_post(&sem); //写线程，写后释放资源.
    }
}
 //read和write中的两个while循环，程序运行后会一直在这两个线程的while切换进行写-读
void *read(void* arg)
{
    pthread_detach(pthread_self());
    while(1)
    {
        memset(buffer,0,100);
        sem_wait(&sem); //读线程等待写线程的资源,就算先调用read，但因value=0，wait函数阻塞，直到value加1,之后再wait之后减1
        printf("%s
",buffer); //等待写进程释放资源后，退出阻塞，执行至此打印buf内容
    }
}

int main()
{
    int re,i=0;
    pthread_t tid1,tid2;
　　//pshared 控制信号量的类型，值为 0 代表该信号量用于多线程间的同步，值如果大于 0 表示可以共享，用于多个相关进程间的同步
    sem_init(&sem,0,0); //参数:信号量对象，默认０
    
    re = pthread_create(&tid1,NULL,read,(void *)i);
    if(re!=0)
    {
        printf("pthread_create:%s
",strerror(re));
        exit(0);
    }

    re = pthread_create(&tid2,NULL,write,(void *)i);
    if(re!=0)
    {
        printf("pthread_create:%s
",strerror(re));
        exit(0);
    }

    while(1)   //一直阻塞在此，否则顺序执行下来，就直接退出了，对应线程也不会执行。可以使用pthread_join等待线程退出
        sleep(1);
}

结果：

 写线程通过键盘输入将内容写入buf，释放sem，探测sem有资源，读线程读buf，打印。

多个线程实现同步，定义多个信号量

#include<stdio.h>
#include <pthread.h>
#include <semaphore.h>


#define N 64
typedef struct message{
    char buf[N];
    int len;
}msg_t;

sem_t sem_reverse;  //定义用于逆置的信号量
sem_t sem_printf;   //定义用于打印的信号量

void* reverse_msgbuf(void* arg)
{
    msg_t *msg = (msg_t *)arg;
    int i = 0;
    char tmp;
    while(1){
        sem_wait(&sem_reverse);
        printf("reverse_msgbuf -------------
");
            //printf("hello reverse_msgbuf.
");
#if 1
            for(i = 0; i < msg->len/2; i ++){
                tmp             = msg->buf[i];
                msg->buf[i]  = msg->buf[msg->len - i - 1];
                msg->buf[msg->len - i -1] = tmp;
            }
#endif 
            sleep(1);
            printf("reverse_msgbuf :%s
",msg->buf);
        sem_post(&sem_printf);
    }
}

void* printf_msgbuf(void* arg)
{
    msg_t *msg = (msg_t *)arg;
    while(1){
        sem_wait(&sem_printf);
            printf("printf_msgbuf :***********
");
            printf("printf_msgbuf :%s
",msg->buf);
        sem_post(&sem_reverse);
    }
}

int main(int argc, const char *argv[])
{
    msg_t msg = {"123456789",9};
    pthread_t tid[2];
    
    //初始化信号量
    sem_init(&sem_reverse,0,1);  //value=1，表示有资源可用，即让reverse先执行
    sem_init(&sem_printf,0,0);   //实现先逆置在打印，先逆置在打印，以此循环
    
    pthread_create(&tid[0],NULL,reverse_msgbuf,(void *)&msg);
    pthread_create(&tid[1],NULL,printf_msgbuf,(void *)&msg);

    pause();

    return 0;
}

线程互斥：

　　前面提到了同步，同步是一种直接制约关系，是指多个线程（或进程）为了合作完成任务，必须严格按照先后次序来运行。如上的读写操作，必须先进行写操作，写入内容，才可执行读操作，且写的过程不可以读。

　　互斥，是一种间接制约关系，指系统中的一些共享资源（临界资源），当访问了解资源时，其他线程必须等待。

　　互斥量本质上说是一把锁，在访问共享资源前对互斥量进行上锁，在访问完成后释放互斥量。对互斥量进行上锁以后，其他试图再次对互斥量加锁的线程都会被阻塞，直到当前线程释放该互斥锁。

#include <pthread.h>

/********互斥锁初始化********/
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);

//成功返回0，失败返回错误码
//mutex指向要初始化的互斥锁对象
//attr 互斥锁属性，NULL缺省

eg.pthread_t mutex;
pthread_mutex_init(&mutex, NULL);

/*******互斥锁上锁**********/
int pthread_mutex_lock(pthread_mutex_t *mutex);
//成功返回0，失败返回错误码
//mutex指向要初始化的互斥锁对象
//如果无法获得锁，任务阻塞

/********互斥锁解锁********/
int pthread_mutex_unlock(pthread_mutex_t *mutex);
//成功返回0，失败返回错误码
//mutex指向要初始化的互斥锁对象
//执行完临界区要及时释放锁

测试程序：

创建两个写线程write1、write2，分别向缓冲区写入字符串：I am pthread_write1与I am pthread_write2。并打印输出。

分析：可以分别在线程写前后加互斥锁，解互斥锁。

 加互斥锁前：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>

FILE *fp; //定义文件流指针

void *write1(void* arg)
{
    char *c1 = "I am pthread_write1";
    char *c2;
    int len,i;
    len = strlen(c1);
    pthread_detach(pthread_self());
    c2 = c1;
    while(1)
    {
        for(i=0;i<len;i++)
        {
            fputc(*c1,fp); //每次写一个字符
            fflush(fp);
            c1++; //指针移动
            usleep(10000); //挂起10000微秒即10毫秒
        }
        c1 = c2; //恢复指针到字符串头部
        sleep(1);
    }
}

void *write2(void* arg)
{
    int len,i;
    char *c2;
    char *c1 = "I am pthread_write2";
    len = strlen(c1);
    c2 = c1;
    pthread_detach(pthread_self());
    while(1)
    {
        for(i=0;i<len;i++)
        {
            fputc(*c1,fp);
            fflush(fp);
            c1++;
            usleep(10000);
        }
        c1 = c2;
        sleep(1);
    }
}

int main()
{
    int re,i=0;
    pthread_t tid1,tid2;

    fp = fopen("1.txt","w");
    if(!fp)
    {
        perror("fopen");
        return -1;
    }
    re = pthread_create(&tid1,NULL,write1,(void *)i);
    if(re!=0)
    {
        printf("pthread_create:%s
",strerror(re));
        exit(0);
    }

    re = pthread_create(&tid2,NULL,write2,(void *)i);
    if(re!=0)
    {
        printf("pthread_create:%s
",strerror(re));
        exit(0);
    }

    while(1)
    {
        sleep(1);
    }
}

 写入文件中的内容乱序。

加锁后：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>

FILE *fp; //定义文件流指针

pthread_mutex_t mutex; //定义锁

void *write1(void* arg)
{
    char *c1 = "I am pthread_write1
";
    char *c2;
    int len,i;
    len = strlen(c1);
    pthread_detach(pthread_self());
    c2 = c1;
    while(1)
    {
        pthread_mutex_lock(&mutex); //上锁
        for(i=0;i<len;i++)
        {
            fputc(*c1,fp); //每次写一个字符
            fflush(fp);
            c1++; //指针移动
            usleep(10000); //挂起10000微秒即10毫秒
        }
        pthread_mutex_unlock(&mutex); //解锁
        c1 = c2; //恢复指针到字符串头部
        sleep(1);
    }
}

void *write2(void* arg)
{
    int len,i;
    char *c2;
    char *c1 = "I am pthread_write2
";
    len = strlen(c1);
    c2 = c1;
    pthread_detach(pthread_self());
    while(1)
    {
        pthread_mutex_lock(&mutex);
        for(i=0;i<len;i++)
        {
            fputc(*c1,fp);
            fflush(fp);
            c1++;
            usleep(10000);
        }
        pthread_mutex_unlock(&mutex);
        c1 = c2;
        sleep(1);
    }
}

int main()
{
    int re,i=0;
    pthread_t tid1,tid2;

    pthread_mutex_init(&mutex,NULL); //锁初始化
    fp = fopen("1.txt","w");
    if(!fp)
    {
        perror("fopen");
        return -1;
    }
    re = pthread_create(&tid1,NULL,write1,(void *)i);
    if(re!=0)
    {
        printf("pthread_create:%s
",strerror(re));
        exit(0);
    }

    re = pthread_create(&tid2,NULL,write2,(void *)i);
    if(re!=0)
    {
        printf("pthread_create:%s
",strerror(re));
        exit(0);
    }

    while(1)
    {
        sleep(1);
    }
}

 注：一个互斥量表示的是一个临界资源，

　　如果多个线程会对同一个临界资源进行访问，又想让他们互斥执行，就为他们定义同一个互斥量。
　　如果各自有各自的临界资源，希望自己在执行的时候，不被其他线程打断，就单独为自己定义一个互斥量。

 1、关于互斥锁与条件变量的使用见博客:

条件变量pthread_cond_t怎么用

pthread_mutex_t

2、pthread_join与 pthread_detach详见：

https://baike.baidu.com/item/pthread_join

linux中pthread_join()与pthread_detach()详解

 线程有两种分离状态：joinable与unjoinable

 1、线程创建后默认是可结合的---joinable，当线程函数自己返回退出时或pthread_exit时，都不会释放线程所占用堆栈和线程描述符（总计8K多）。

 只有当你调用了pthread_join之后这些资源才会被释放。若是unjoinable状态的线程，这些资源在线程函数退出时或pthread_exit时自动会被释放。

 2、unjoinable属性可以在pthread_create时指定，或在线程创建后在线程中pthread_detach自己, 如：pthread_detach(pthread_self())，将状态改为unjoinable状态，确保资源的释放。或者将线程置为 joinable,然后适时调用pthread_join.

pshared 控制信号量的类型，值为 0 代表该信号量用于多线程间的同步，值如果大于 0 表示可以共享，用于多个相关进程间的同步