Linux笔记(25)-线程同步(互斥锁)

1. 数据混乱

1. 例如：
    两个线程对同一全局变量数数操作时，产生部分数据丢失
    a. 线程1：number从0数到100时，数据还没有从cpu写入内存，但此时丢了cpu资源
    b. 线程2：此时抢到cpu，但number此时任为0开始数，当数到200时，cpu写到内存，然后退出cpu
    c. 线程1：此时抢到cpu，但number写入时为保存在线程1中的100值，此时100覆盖了200，产生数据丢失(混乱)
2. 产生原因：
    a. 操作了共享资源
    b. cpu调度问题
3. 解决方法 -- 线程同步
    协同步调，按照先后顺序指向操作 -- 即等线程1回写到内存后，再让线程2执行操作

2. 线程同步思想

1. 给共享资源上锁
    a. 当线程1访问共享资源时，判断锁是否打开。
    b. 锁打开时，访问资源，同时上锁。否则阻塞等待开锁
    c. 访问完成资源后，开锁操作。

3. 互斥锁(互斥量)

1. 互斥锁类型：
    pthread_mutex_t mutex;
2. 初始化锁：
    a. 函数原型：
        pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
    b. 参数：
        restrict：修饰关键字 -- 例如：若p指针指向一块内存，有s = p，则一般情况下s同样可以访问该内存
                                      若restrict修饰p指针后，s将无法访问p指向的内存。
        mutex：只能传入创建的互斥锁的地址
        attr：线程锁的属性 -- 无要求为NULL
3. 销毁锁
    pthread_mutex_destroy(pthread_mutex_t *mutex);
4. 加锁
    a. 初始化锁时，锁默认为开锁状态
    b. 加锁函数：
        pthread_mutex_lock(pthread_mutex_t *mutex);
        <1> 如果没有上锁，则该函数调用后对锁进行上锁操作
        <2> 如果已经上锁，则当前线程阻塞，直到锁被打开后解除阻塞
    c. 尝试加锁函数：
        int pthread_mutex_trylock(pthread_mutex_t *mutex);
        <1> 如果没有上锁，则函数调用后对锁进行上锁操作
        <2> 如果已经上锁，则直接返回，不阻塞
        <3> 例如：
            if(pthread_mutex_trylock(&mutex) == 0)
            {
                //此时加锁成功，访问共享资源
            }else
            {
                //加锁失败，错误处理
            }
5. 解锁操作
    pthread_mutex_unlock(pthread_mutex_t *mutex);

4. 互斥锁使用步骤

1. 创建互斥锁：
    pthread_mutex_t mutex;
2. 初始化该互斥锁：
    pthread_mutex_init(&mutex, NULL);
3. 寻找共享资源：
    a. 在操作共享资源前加锁
        pthread_mutex_lock(&mutex);
    b. 操作共享资源
    c. 完成操作后解锁
        pthread_mutex_unlock(&mutex);
4. 注意事项：
    仅在共享操作前后对锁操作，临界区代码行数越少越好。因此在代码中也许会出现频繁的加锁解锁

5. 为何要加锁操作

1. 原子操作：
    a. cpu处理一个指令，线程/进程在处理完该指令前不会丢失cpu
2. 为了保证非原子操作的指令在执行过程中不失去cpu使得数据出错。
3. 死锁：
    所有线程阻塞在一个锁上，或者多个线程循环阻塞在下一个锁上
    解决：
        a. 让线程按照一定的顺序访问共享资源
        b. 多个共享资源时，线程访问完一个共享资源后立即解锁该共享资源
        c. trylock