四：线程 互斥锁 pthread_lock （八）

互斥锁原理：
         互斥锁防止共享数据被并发修改，全局变量属于共享数据。
         如果互斥锁处于锁定状态，默认阻塞等待

基本操作函数

初始化：      pthread_mutex_init
申请  ：       pthread_mutex_lock
释放  :         pthread_mutex_unlock
非阻塞申请：   pthread_mutex_trylock
销毁   ：        pthrea_mutex_destroy

下面的实例：
    主线程负责从 stdin 输入数据到全局数据区，work_area[]，子线程负责将读入的数据输出到标准输出设备。
    1. 在输入数据时，需要占有全局数据区 work_area[]， 首先上锁，在输入数据完毕后，解锁
    2. 在输出数据时，需要占有全局数据区 work_area[],  首先上锁，后解锁

使用互斥锁，很好的解决了两个线程之间的同步机制

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

void *thread_fun(void *a);  //子线程函数
void print_res(int *res,char *s); //判断 成功
pthread_mutex_t work_mutex;      //全局互斥锁对象
         /*  typedef struct
             {
                int volatile value;    到磁盘上数据读入，不再内存中
             }pthread_mutex_t*/

#define WORK_SIZE 1024
char work_area[WORK_SIZE];   //全局共享数据区

int time_to_exit = 0;  //全局数据
                       //互斥锁：防止对共享数据(全局变量) 并发修改

int main(int argc, char *argv[])
{
    int res;
    pthread_t a_thread;    //unsigned long
    void *thread_result;    //thread_join() 的第二个参数

    //初始化 互斥锁         NULL 默认属性
    res = pthread_mutex_init(&work_mutex, NULL);
    print_res(&res, "pthread_mutex_init");

    //创建新线程
    res = pthread_create(&a_thread, NULL, thread_fun, NULL);
    print_res(&res, "pthread_create");

    //接受输入前，给互斥锁上锁                //假设，子线程先执行，但是在子线程中 sleep(1);
    pthread_mutex_lock(&work_mutex);       //所以，还是主线程 mutex_lock 先获得 锁，
                                          
//所以，还是 主线程，执行 输入数据 先
    printf("input some text.enter 'end' to finish\n");

    while(!time_to_exit) //time_to_exit 由另一个线程修改  //初始值 0
    {
        fgets(work_area, WORK_SIZE, stdin); //冲stdin 读取一行信息
        pthread_mutex_unlock(&work_mutex);//解锁，两个线程抢占互斥锁

        while(1)
        {
            pthread_mutex_lock(&work_mutex);  //上锁
            if(work_area[0] != '\0')//检查读入的内容输出没有
            {                  //输出线程将信息输出后设置为 work_area[0] = '\0'
                pthread_mutex_unlock(&work_mutex);
                sleep(1);
            }
            else   //如果已经输出，执行下一轮读入
            {
                break;
            }
        }
    }

    //解锁
    pthread_mutex_unlock(&work_mutex); //解锁
    printf("\nwaiting for thread to finish...\n");

    //等待退出线程
    res =pthread_join(a_thread, (void **)&thread_result);
    print_res(&res, "pthread_join");

    //销毁互斥锁
    pthread_mutex_destroy(&work_mutex);

    exit(EXIT_SUCCESS);
}

void print_res(int *res,char *s)
{
    if(*res != 0)
    {
        printf("%s failed.\n",s);
        exit(EXIT_FAILURE);
    }
    else
    {
        printf("%s success\n",s);
    }
}

void *thread_fun(void *a)
{
    sleep(1); //假如，子线程先执行，那么等待 1 秒，可以使主线程
                  //首先抢到 锁，进行输入数据

    //上锁，抢占资源
    pthread_mutex_lock(&work_mutex);

    while(strncmp("end",work_area,3) != 0)  //判断是否为结束信息 end
    {
        printf("you input %d characters\n",strlen(work_area)-1);  //输出输入的字符数
        printf("the characters is:%s",work_area);
        work_area[0]='\0';  //输出输入的字符后，设置 输出标志

        pthread_mutex_unlock(&work_mutex); //解锁

        sleep(1);//等待 主线程抢占锁 ，可以输入数据

        pthread_mutex_lock(&work_mutex);

        while(work_area[0] =='\0')  //判断第一位 是否为  0
        {        //  = 0 ,主线程没有输入 数据
                                // ！= 0 ,有输入，执行下一轮输出操作
            pthread_mutex_unlock(&work_mutex);
            sleep(1);  //使主线程，进行输入数据
            pthread_mutex_lock(&work_mutex);  //上锁，再次返回判断
        }
    }

    time_to_exit = 1;
    work_area[0] = '\0';
    pthread_mutex_unlock(&work_mutex);

    pthread_exit(0);
}

ywx@yuweixian:~/yu/professional/4$ ./mutex
pthread_mutex_init success
pthread_create success
input some text.enter 'end' to finish
love linux
you input 10 characters
the characters is:love linux
ssssss
you input 6 characters
the characters is:ssssss
end

waiting for thread to finish...
pthread_join success