基本概念

同步：协同步调，按预定的先后次序运行

线程同步：

    指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据

    一致性，不能调用该功能。

举例：

    内存中 100 字节，线程 T1 欲填入全 1， 线程 T2 欲填入全 0。但如果 T1 执行了 50 个字节失去 cpu，T2

    执行，会将 T1 写过的内容覆盖。当 T1 再次获得 cpu 继续 从失去 cpu 的位置向后写入 1，当执行结束，内存中的

    100 字节，既不是全 1，也不是全 0。

    产生的现象叫做“与时间有关的错误”(time related)。为了避免这种数据混乱，线程需要同步。

    同步的目的，是为了避免数据混乱，解决与时间有关的错误。实际上，不仅线程间需要同步，进程间、信

    号间等等都需要同步机制。

数据混乱原因：

    1. 资源共享（独享资源则不会）

    2. cpu调度随机（意味着数据访问会出现竞争）

    3. 线程间缺乏必要的同步机制。

    以上 3 点中，前两点不能改变，欲提高效率，传递数据，资源必须共享。只要共享资源，就一定会出现竞争。

    只要存在竞争关系，数据就很容易出现混乱。

    所以只能从第三点着手解决。使多个线程在访问共享资源的时候，出现互斥。

互斥锁

互斥锁mutex：

    Linux 中提供一把互斥锁 mutex（也称之为互斥量）。

    每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。

    同一时刻，只能有一个线程持有该锁。

互斥锁使用注意事项：

    举例：当 A 线程对某个全局变量加锁访问，B 在访问前尝试加锁，拿不到锁，B 阻塞。C 线程不去加锁，而直接访问

    该全局变量，依然能够访问，但会出现数据混乱。

    原因：互斥锁实质上是操作系统提供的一把“建议锁”（又称“协同锁”），建议程序中有多线程访问共享资源

    的时候使用该机制。但，并没有强制限定。

    即使有了 mutex，如果有线程不按规则来访问数据，依然会造成数据混乱。

使用mutex(互斥量、互斥锁)一般步骤：

    pthread_mutex_t 类型。 

    1. pthread_mutex_t lock;  创建锁

    2  pthread_mutex_init; 初始化      1

    3. pthread_mutex_lock;加锁        1-- --> 0

    4. 访问共享数据（stdout)       

    5. pthrad_mutext_unlock();解锁        0++ --> 1

    6. pthead_mutex_destroy；销毁锁


    初始化互斥量：

        pthread_mutex_t mutex;

        1. pthread_mutex_init(&mutex, NULL);            动态初始化。

        2. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;   静态初始化。

    注意事项：

        尽量保证锁的粒度， 越小越好。（访问共享数据前，加锁。访问结束【立即】解锁。）

        互斥锁，本质是结构体。 我们可以看成整数。 初值为 1。（pthread_mutex_init() 函数调用成功。）

        加锁： --操作， 阻塞线程。

        解锁： ++操作， 换醒阻塞在锁上的线程。

        try锁：尝试加锁，成功--。失败，返回。同时设置错误号 EBUSY

restrict关键字：

    用来限定指针变量。被该关键字限定的指针变量所指向的内存操作，必须由本指针完成。

使用 mutex 互斥锁进行同步：

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

pthread_mutex_t mutex;

void *tfn(void *arg)
{
    srand(time(NULL));

    while (1) {
        pthread_mutex_lock(&mutex);
        printf("hello ");
        sleep(rand() % 3);  /*模拟长时间操作共享资源，导致cpu易主，产生与时间有关的错误*/
        printf("world\n");
        pthread_mutex_unlock(&mutex);
        sleep(rand() % 3);

    }

    return NULL;
}

int main(void)
{
    pthread_t tid;
    srand(time(NULL));

    pthread_mutex_init(&mutex, NULL);

    pthread_create(&tid, NULL, tfn, NULL);
    while (1) {

        pthread_mutex_lock(&mutex);
        printf("HELLO ");
        sleep(rand() % 3);
        printf("WORLD\n");
        pthread_mutex_unlock(&mutex);
        sleep(rand() % 3);


    }
    pthread_join(tid, NULL);
    pthread_mutex_destroy(&mutex);

    return 0;
}

思考：

    将 unlock 挪至第二个 sleep 后，会产生什么现象？

        交替现象很难出现，原因是线程在操作完共享资源后本应该立即解锁，但修改后，线程抱着锁睡眠。睡醒解锁后

        又立即加锁，因此，另外一个线程很难得到加锁的机会

死锁

死锁 不是一种锁。是使用锁不恰当导致的现象：

    1. 一个线程对一个锁反复lock。第一次成功 mutex--   在没解锁的情况下第二次在lock,  将会阻塞，等待解锁，

    但是持有这把锁的线程是自己，已经阻塞了======> 自己阻塞自己

    2. 两个线程，各自持有一把锁，请求另一把。 线程 1 拥有 A 锁，请求获得 B 锁；线程 2 拥有 B 锁，请求获得 A 锁===========>相互阻塞

读写锁

读写锁：

    锁只有一把。以读方式给数据加锁——读锁。以写方式给数据加锁——写锁。

    读共享，写独占。

    写锁优先级高。有读有写时，写锁先得到。前提：读锁，写锁一起来，锁没被拿到 mutex = 1

    若读锁已经被占用，此时，有3个线程r, w, w。此时还遵循写锁优先级高----》读在写之前没有意义：读一个马上要修改的数据没有意义

    相较于互斥量而言，当读线程多的时候，提高访问效率

    pthread_rwlock_t  rwlock;

    pthread_rwlock_init(&rwlock, NULL);

    pthread_rwlock_rdlock(&rwlock);     try

    pthread_rwlock_wrlock(&rwlock);     try

    pthread_rwlock_unlock(&rwlock);

    pthread_rwlock_destroy(&rwlock);

读写锁现象测试代码：

/* 3个线程不定时 "写" 全局资源，5个线程不定时 "读" 同一全局资源 */

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

int counter;                          //全局资源
pthread_rwlock_t rwlock;

void *th_write(void *arg)
{
    int t;
    int i = (int)arg;

    while (1) {
        t = counter;                    // 保存写之前的值
        usleep(1000);

        pthread_rwlock_wrlock(&rwlock);
        printf("=======write %d: %lu: counter=%d ++counter=%d\n", i, pthread_self(), t, ++counter);
        pthread_rwlock_unlock(&rwlock);

        usleep(9000);               // 给 r 锁提供机会
    }
    return NULL;
}

void *th_read(void *arg)
{
    int i = (int)arg;

    while (1) {
        pthread_rwlock_rdlock(&rwlock);
        printf("----------------------------read %d: %lu: %d\n", i, pthread_self(), counter);
        pthread_rwlock_unlock(&rwlock);

        usleep(2000);                // 给写锁提供机会
    }
    return NULL;
}

int main(void)
{
    int i;
    pthread_t tid[8];

    pthread_rwlock_init(&rwlock, NULL);

    for (i = 0; i < 3; i++)
        pthread_create(&tid[i], NULL, th_write, (void *)i);

    for (i = 0; i < 5; i++)
        pthread_create(&tid[i+3], NULL, th_read, (void *)i);

    for (i = 0; i < 8; i++)
        pthread_join(tid[i], NULL);

    pthread_rwlock_destroy(&rwlock);            //释放读写琐

    return 0;
}