【Linux 线程】线程同步《一》

1、线程同步概念

线程同步：在多个线程访问共享数据时，有先后次序。

在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。但是多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就要使线程同步。

线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，目前实现线程同步的方法有很多，临界区对象就是其中一种。

常见的多线程同步的方式：临界区、互斥量、事件、信号量。

临界区（Critical Section）、互斥量（Mutex）、信号量（Semaphore）、事件（Event）的区别如下：

1、临界区：通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。在任意时刻只允许一个线程对共享资源进行访问，如果有多个线程试图访问公共资源，那么在有一个线程进入后，其他试图访问公共资源的线程将被挂起，并一直等到进入临界区的线程离开，临界区在被释放后，其他线程才可以抢占。

2、互斥量：采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享。

3、信号量：它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。

4、事 件： 通过通知操作的方式来保持线程的同步，还可以方便实现对多个线程的优先级比较的操作。

 

2、互斥锁

posix下抽象了一个锁类型的结构：ptread_mutex_t。通过对该结构的操作，来判断资源是否可以访问。顾名思义，加锁(lock)后，别人就无法打开，只有当锁没有关闭(unlock)的时候才能访问资源。

主要有如下5个函数：

（1）pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex attr_t *attr);
// 初始化锁变量mutex。
// attr为锁属性（自己的值只能被自己的指针改变），NULL值为默认属性。

（2）pthread_mutex_lock(pthread_mutex_t *mutex);
// 加锁（阻塞操作）

（3）pthread_mutex_trylock(pthread_mutex_t *mutex);
// 试图加锁（不阻塞操作）
// 当互斥锁空闲时将占有该锁；否则立即返回
// 但是与2不一样的是当锁已经在使用的时候，返回为EBUSY，而不是挂起等待。

（4）pthread_mutex_unlock(pthread_mutex_t *mutex);
// 释放锁

（5）pthread_mutex_destroy(pthread_mutex_t *mutex);
// 使用完后删除

举例1：

/*************************************************************************
    > File Name: pthread_mutex1.c
    > Summary: 互斥锁举例1
    > Author: xuelisheng 
    > Created Time: 2018年12月17日
 ************************************************************************/
/*
#include <stdio.h>
#include <stdlib.h>  
#include <unistd.h>  
#include <pthread.h>  
typedef struct ct_sum  
{   
    int sum;  
    pthread_mutex_t lock;  
}ct_sum;  

void * add1(void * cnt)  
{       
    // 加互斥锁
    pthread_mutex_lock(&(((ct_sum*)cnt)->lock));  
    int i;  
    for(i=0; i<50; i++)
    {  
        (*(ct_sum*)cnt).sum+=i;
    } 
    printf("thread 1 printf sum = %d
", ((ct_sum *)cnt)->sum);
    pthread_mutex_unlock(&(((ct_sum*)cnt)->lock));  
    pthread_exit(NULL);  
    return 0;  
}  

void * add2(void *cnt)  
{       
    int i;  
    cnt= (ct_sum*)cnt;  
    pthread_mutex_lock(&(((ct_sum*)cnt)->lock));  
    for(i=50; i<101; i++)  
    {    
        (*(ct_sum*)cnt).sum+=i;         
    }  
    printf("thread 2 printf sum = %d
", ((ct_sum *)cnt)->sum);
    pthread_mutex_unlock(&(((ct_sum*)cnt)->lock));  
    pthread_exit(NULL);  
    return 0;  
}  

int main(void)  
{   
    int i;  
    pthread_t ptid1, ptid2;  
    int sum = 0;  
    ct_sum cnt;  
    //初始化互斥锁
    pthread_mutex_init(&(cnt.lock),NULL);  
    cnt.sum=0;  
    // 创建线程1
    pthread_create(&ptid1,NULL,add1,&cnt);  
    // 创建线程2
    pthread_create(&ptid2,NULL,add2,&cnt);  

    pthread_mutex_lock(&(cnt.lock));  
    printf("sum %d
",cnt.sum);  
    pthread_mutex_unlock(&(cnt.lock));  
    pthread_join(ptid1,NULL);  
    pthread_join(ptid2,NULL);  
    pthread_mutex_destroy(&(cnt.lock));  
    return 0;  
}
*/

/*
关于pthread_exit和pthread_join的联合使用
一般都是pthread_exit在线程内退出，然后返回一个值。这个时候就跳到主线程的pthread_join了（因为一直在等你结束），这个返回值会直接送到pthread_join，实现了主与分线程的通信。
*/
#include <stdio.h>
#include <stdlib.h>  
#include <unistd.h>  
#include <pthread.h>  
typedef struct ct_sum1 
{   
    int sum;  
    pthread_mutex_t lock;  
};  

struct ct_sum1 ct_sum;

void * add1()  
{       
    // 加互斥锁
    pthread_mutex_lock(&ct_sum.lock);  
    int i;  
    for(i=0; i<50; i++)
    {  
        ct_sum.sum+=i;
    } 
    printf("thread 1 printf sum = %d
", ct_sum.sum);
    // 解锁
    pthread_mutex_unlock(&ct_sum.lock);  
    // pthread_exit用于强制退出一个线程（非执行完毕退出），一般用于线程内部。
    pthread_exit(NULL);  
    return 0;  
}  

void * add2()  
{       
    int i;   
     // 加互斥锁
    pthread_mutex_lock(&ct_sum.lock);  
    for(i=50; i<101; i++)  
    {    
        ct_sum.sum+=i;         
    }  
    printf("thread 2 printf sum = %d
", ct_sum.sum);
    // 解锁
    pthread_mutex_unlock(&ct_sum.lock);  
    // pthread_exit用于强制退出一个线程（非执行完毕退出），一般用于线程内部。
    pthread_exit(NULL);  
    return 0;  
}  

int main(void)  
{   
    ct_sum.sum = 0;
    pthread_t ptid1, ptid2;  
    int sum = 0;  
    //初始化互斥锁
    pthread_mutex_init(&(ct_sum.lock),NULL);  
    // 创建线程1
    pthread_create(&ptid1,NULL,add1,NULL);  
    // 创建线程2
    pthread_create(&ptid2,NULL,add2,NULL);  
    // 阻塞主线程，回收子线程
    pthread_join(ptid1,NULL);  
    pthread_join(ptid2,NULL);  
     
    printf("sum %d
",ct_sum.sum);  
    // 销毁互斥锁
    pthread_mutex_destroy(&(ct_sum.lock));  
    return 0;  
}

运行结果：

thread 1 printf sum = 1225
thread 2 printf sum = 5050
sum 5050

举例2：

/*************************************************************************
    > File Name: pthread_mutex2.c
    > Summary: 互斥锁举例2（多线程写文件---没有加锁的情形）
    > Author: xuelisheng 
    > Created Time: 2018年12月17日
 ************************************************************************/
#include <stdio.h> 
#include <pthread.h> 
#include <malloc.h> 

const char filename[] = "hello"; 
void* thread(void *id)
{ 
    int num = *(int *)id; // 写文件的操作 
    FILE *fp = fopen(filename, "a+"); 
    int start = *((int *)id); 
    int end = start + 1; 
    setbuf(fp, NULL);// 设置缓冲区的大小 
    fprintf(stdout, "%d
", start); 
    for (int i = (start * 10); i < (end * 10); i ++)
    { 
        // 写文件
        fprintf(fp, "%d	", i); 
    } 
    fprintf(fp, "
"); 
    fclose(fp); 
    return NULL; 
}

int main()
{ 
    // 设置线程个数
    int num_thread = 5;
    // 堆上申请指向每个线程的指针 
    pthread_t *pt = (pthread_t *)malloc(sizeof(pthread_t) * num_thread); 
    int * id = (int *)malloc(sizeof(int) * num_thread); 
    for (int i = 0; i < num_thread; i++)
    { 
        id[i] = i; 
        if (pthread_create(&pt[i], NULL, thread, &id[i]) != 0)
        { 
            printf("thread create failed!
"); 
            return 1; 
        } 
    } 
    for (int i = 0; i < num_thread; i++)
    { 
        pthread_join(pt[i], NULL); 
    } // 释放资源 
    free(pt); 
    free(id); 
    return 0; 
}

运行结果：

屏幕输出：

1
0
2
3
4

输出文件（hello）：

举例3（更改举例2出现的问题）：

/*************************************************************************
    > File Name: pthread_mutex3.c
    > Summary: 互斥锁举例3（多线程写文件---加锁的情形）
    > Author: xuelisheng 
    > Created Time: 2018年12月17日
 ************************************************************************/
#include <stdio.h> 
#include <pthread.h> 
#include <malloc.h> 

pthread_mutex_t mutex;
const char filename[] = "hello"; 
void* thread(void *id)
{ 
    int num = *(int *)id; // 写文件的操作
    // 加锁
    if (pthread_mutex_lock(&mutex) != 0){
                fprintf(stdout, "lock error!
");
    } 
    FILE *fp = fopen(filename, "a+"); 
    int start = *((int *)id); 
    int end = start + 1; 
    setbuf(fp, NULL);// 设置缓冲区的大小 
    fprintf(stdout, "%d
", start); 
    for (int i = (start * 10); i < (end * 10); i ++)
    { 
        // 写文件
        fprintf(fp, "%d	", i); 
    } 
    fprintf(fp, "
"); 
    fclose(fp); 
    // 解锁
    pthread_mutex_unlock(&mutex);
    return NULL; 
}

int main()
{ 
    // 设置线程个数
    int num_thread = 5;
    // 堆上申请指向每个线程的指针 
    pthread_t *pt = (pthread_t *)malloc(sizeof(pthread_t) * num_thread); 
    int * id = (int *)malloc(sizeof(int) * num_thread); 
    // 初始化互斥锁 
    if (pthread_mutex_init(&mutex, NULL) != 0)
    { 
        // 互斥锁初始化失败 
        free(pt); 
        free(id); 
        return 1; 
    }

    for (int i = 0; i < num_thread; i++)
    { 
        id[i] = i; 
        if (pthread_create(&pt[i], NULL, thread, &id[i]) != 0)
        { 
            printf("thread create failed!
"); 
            return 1; 
        } 
    } 
    for (int i = 0; i < num_thread; i++)
    { 
        pthread_join(pt[i], NULL); 
    } // 释放资源 

    pthread_mutex_destroy(&mutex);
    free(pt); 
    free(id); 
    return 0; 
}

运行结果：

屏幕输出：

0
1
2
3
4

输出文件（hello）：