linux 线程同步之互斥锁、读写锁

线程同步

举例： 内存中100字节，线程T1欲填入全1， 线程T2欲填入全0。但如果T1执行了50个字节失去cpu，T2执行，会将T1写过的内容覆盖。当T1再次获得cpu继续 从失去cpu的位置向后写入1，当执行结束，内存中的100字节，既不是全1，也不是全0。
线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据一致性，不能调用该功能。
因此，所有“多个控制流，共同操作一个共享资源”的情况，都需要同步。

数据混乱原因：

1.资源共享（独享资源则不会）
2.调度随机（意味着数据访问会出现竞争）
3.线程间缺乏必要的同步机制。
以上3点中，前两点不能改变，欲提高效率，传递数据，资源必须共享。只要共享资源，就一定会出现竞争。只要存在竞争关系，数据就很容易出现混乱。
所以只能从第三点着手解决。使多个线程在访问共享资源的时候，出现互斥。

互斥量mutex

Linux中提供一把互斥锁mutex（也称之为互斥量）。
每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。
资源还是共享的，线程间也还是竞争的，
但通过“锁”就将资源的访问变成互斥操作，而后与时间有关的错误也不会再产生了。

但应注意：同一时刻，只能有一个线程持有该锁。
当A线程对某个全局变量加锁访问，B在访问前尝试加锁，拿不到锁，B阻塞。C线程不去加锁，而直接访问该全局变量，依然能够访问，但会出现数据混乱。
所以，互斥锁实质上是操作系统提供的一把“建议锁”（又称“协同锁”），建议程序中有多线程访问共享资源的时候使用该机制。但并没有强制限定。
因此，即使有了mutex，如果有线程不按规则来访问数据，依然会造成数据混乱。

pthread_mutex_init函数

初始化一个互斥锁(互斥量) —> 本质是结构体，但为了简化理解，初值可看作1

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

参1：传出参数，调用前在外面先创建锁，pthread_mutex_t mutex;
restrict关键字：只用于限制指针，告诉编译器，所有修改该指针指向内存中内容的操作，只能通过本指针完成。不能通过除本指针以外的其他变量或指针修改
参2：互斥量属性。是一个传入参数，通常传NULL，选用默认属性(线程间共享)。 参APUE.12.4同步属性
1.静态初始化：如果互斥锁 mutex 是静态分配的（定义在全局，或加了static关键字修饰），可以直接使用宏进行初始化。e.g. pthead_mutex_t muetx = PTHREAD_MUTEX_INITIALIZER;
2.动态初始化：局部变量应采用动态初始化。e.g. pthread_mutex_init(&mutex, NULL);

pthread_mutex_destroy函数

销毁一个互斥锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);

pthread_mutex_lock函数

加锁。可理解为将mutex–（或-1）

int pthread_mutex_lock(pthread_mutex_t *mutex);

如果没成功拿到锁，会阻塞。

pthread_mutex_unlock函数

解锁。可理解为将mutex ++（或+1）

int pthread_mutex_unlock(pthread_mutex_t *mutex);

pthread_mutex_trylock函数

尝试加锁

int pthread_mutex_trylock(pthread_mutex_t *mutex);

如果没成功拿到锁，不会阻塞。

加锁与解锁

lock与unlock：

lock尝试加锁，如果加锁不成功，线程阻塞，阻塞到持有该互斥量的其他线程解锁为止。
unlock主动解锁函数，同时将阻塞在该锁上的所有线程全部唤醒，至于哪个线程先被唤醒，取决于优先级、调度。默认：先阻塞、先唤醒。
可假想mutex锁init成功初值为1。lock 功能是将mutex–。unlock将mutex++
lock与trylock：
lock加锁失败会阻塞，等待锁释放。
trylock加锁失败直接返回错误号（如：EBUSY），不阻塞。

例：使用mutex互斥锁进行同步。

#include 
#include 
#include 
#include 
#include 

pthread_mutex_t mutex;      //定义锁
/*线程之间共享资源stdout*/
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)
{
     
    int flg = 5;
    pthread_t tid;
    srand(time(NULL));

    pthread_mutex_init(&mutex, NULL);  // 可以简单理解为把mutex初始化为1
    pthread_create(&tid, NULL, tfn, NULL);
    while (flg--) 
	{
     

        pthread_mutex_lock(&mutex);

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

        sleep(rand() % 3);

    }
    pthread_cancel(tid);
    pthread_join(tid, NULL);

    pthread_mutex_destroy(&mutex);  

    return 0;
}

如果不加锁的话，显然，输出顺序是乱的。
此外，这里很重要的一点是：在访问共享资源前加锁，访问结束后立即解锁。锁的“粒度”应越小越好。 否则，另外一个线程很难再次拿到锁。

死锁

1.线程试图对同一个互斥量A加锁两次。
2.线程1拥有A锁，请求获得B锁；线程2拥有B锁，请求获得A锁
解决2的两种方法：
1.当不能获取所有锁时，主动放弃已有的锁
2.保证资源的获取顺序一致，即要求每个线程获取锁的顺序一致，以上面这个例子来说，就是要求线程1和线程2都先拿A锁再拿B锁。

读写锁

与互斥量类似，但读写锁允许更高的并行性。其特性为：写独占，读共享。
读写锁状态：
一把读写锁具备三种状态：（注意，读写锁只有一把！！）
1.读模式下加锁状态 (读锁)
2.写模式下加锁状态 (写锁)
3.不加锁状态

读写锁特性：

1.读写锁是“写模式加锁”时， 解锁前，所有对该锁加锁的线程都会被阻塞。
2.读写锁是“读模式加锁”时， 如果线程以读模式对其加锁会成功；如果线程以写模式加锁会阻塞。
3.读写锁是“读模式加锁”时， 既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么解锁后，读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞，写锁优先级高
读写锁也叫共享-独占锁。当读写锁以读模式锁住时，它是以共享模式锁住的；当它以写模式锁住时，它是以独占模式锁住的。写独占、读共享。
读写锁非常适合于对数据结构读的次数远大于写的情况。

pthread_rwlock_init函数

初始化一把读写锁

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);

参1：传出参数
参2：attr表读写锁属性，通常使用默认属性，传NULL即可。

pthread_rwlock_destroy函数

销毁一把读写锁

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

pthread_rwlock_rdlock函数

以读方式请求读写锁。（常简称为：请求读锁）

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

pthread_rwlock_wrlock函数

以写方式请求读写锁。（常简称为：请求写锁）

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

pthread_rwlock_unlock函数

解锁

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

pthread_rwlock_tryrdlock函数

非阻塞以读方式请求读写锁（非阻塞请求读锁）

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

pthread_rwlock_trywrlock函数

非阻塞以写方式请求读写锁（非阻塞请求写锁）

int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

读写锁例子：多个线程对同一全局数据进行读、写操作。

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

#include 
#include 
#include 

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(5000);
    }
    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(900);
    }
    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;
}