Linux系统编程——线程同步

1. 同步概念

       所谓同步，即同时起步，协调一致。不同的对象，对“同步”的理解方式略有不同。如，设备同步，是指在两个设备之间规定一个共同的时间参考；数据库同步，是指让两个或多个数据库内容保持一致，或者按需要部分保持一致；文件同步，是指让两个或多个文件夹里的文件保持一致。等等
       而编程中、通信中所说的同步与生活中大家印象中的同步概念略有差异。“同”字应是指协同、协助、互相配合。主旨在协同步调，按预定的先后次序运行。

1.1 线程同步

       同步即协同步调，按预定的先后次序运行。
       线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态。

       举例1： 银行存款 5000。柜台，折：取3000；提款机，卡：取 3000。剩余：2000
       举例2： 内存中100字节，线程T1欲填入全1， 线程T2欲填入全0。但如果T1执行了50个字节失去cpu，T2执行，会将T1写过的内容覆盖。当T1再次获得cpu继续 从失去cpu的位置向后写入1，当执行结束，内存中的100字节，既不是全1，也不是全0。

       产生的现象叫做“与时间有关的错误”(time related)。为了避免这种数据混乱，线程需要同步。
       “同步”的目的，是为了避免数据混乱，解决与时间有关的错误。实际上，不仅线程间需要同步，进程间、信号间等等都需要同步机制。
       因此，所有“多个控制流，共同操作一个共享资源”的情况，都需要同步。

1.2 数据混乱原因

1. 资源共享（独享资源则不会）
2. 调度随机（意味着数据访问会出现竞争）
3. 线程间缺乏必要的同步机制。

       以上3点中，前两点不能改变，欲提高效率，传递数据，资源必须共享。只要共享资源，就一定会出现竞争。只要存在竞争关系，数据就很容易出现混乱。所以只能从第三点着手解决。使多个线程在访问共享资源的时候，出现互斥。

2. 互斥量mutex

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

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

       资源还是共享的，线程间也还是竞争的，但通过“锁”就将资源的访问变成互斥操作，而后与时间有关的错误也不会再产生了。

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

2.1 主要应用函数

说明	函数原型
初始化一个互斥锁	int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
销毁一个互斥锁	int pthread_mutex_destroy(pthread_mutex_t *mutex);
加锁。可理解为将mutex–（或-1）	int pthread_mutex_lock(pthread_mutex_t *mutex);
解锁。可理解为将mutex ++（或+1）	int pthread_mutex_unlock(pthread_mutex_t *mutex);
尝试加锁	int pthread_mutex_trylock(pthread_mutex_t *mutex);

• 以上5个函数的返回值都是：成功返回0， 失败返回错误号。
• pthread_mutex_t 类型，其本质是一个结构体。为简化理解，应用时可忽略其实现细节，简单当成整数看待。
• pthread_mutex_t mutex; 变量mutex只有两种取值1、0。初始化成功时初值可看作1。

pthread_mutex_init函数

初始化一个互斥锁(互斥量) —> 初值可看作1
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);;

• 参1：传出参数，调用时应传 &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)

2.2 加锁与解锁

lock与unlock：

• lock尝试加锁，如果加锁不成功，线程阻塞，阻塞到持有该互斥量的其他线程解锁为止。
• unlock主动解锁函数，同时将阻塞在该锁上的所有线程全部唤醒，至于哪个线程先被唤醒，取决于优先级、调度。默认：先阻塞、先唤醒。

       例如：T1 T2 T3 T4 使用一把mutex锁。T1加锁成功，其他线程均阻塞，直至T1解锁。T1解锁后，T2 T3 T4均被唤醒，并自动再次尝试加锁。
       可假想mutex锁 init成功初值为1。 lock 功能是将mutex–。 unlock将mutex++

lock与trylock：

• lock加锁失败会阻塞，等待锁释放。
• trylock加锁失败直接返回错误号（如：EBUSY），不阻塞。

2.3 加锁步骤测试

       看如下程序：该程序是非常典型的，由于共享、竞争而没有加任何同步机制，导致产生于时间有关的错误，造成数据混乱：

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

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

        printf("hello ");
        sleep(rand() % 3);	/*模拟长时间操作共享资源，导致cpu易主，产生与时间有关的错误*/
        printf("world\n");
        sleep(rand() % 3);
    }
    return NULL;
}
int main(void)
{
    
    
    pthread_t tid;
    srand(time(NULL));
    pthread_create(&tid, NULL, tfn, NULL);
    while (1) {
    
    
        printf("HELLO ");
        sleep(rand() % 3);
        printf("WORLD\n");
        sleep(rand() % 3);
    }
    pthread_join(tid, NULL);
    return 0;
}

【练习】：修改该程序，使用mutex互斥锁进行同步。

1. 定义全局互斥量，初始化init(&m, NULL)互斥量，添加对应的destry
2. 两个线程while中，两次printf前后，分别加lock和unlock
3. 将unlock挪至第二个sleep后，发现交替现象很难出现。
   线程在操作完共享资源后本应该立即解锁，但修改后，线程抱着锁睡眠。睡醒解锁后又立即加锁，这两个库函数本身不会阻塞。
   所以在这两行代码之间失去cpu的概率很小。因此，另外一个线程很难得到加锁的机会。
4. main 中加flag = 5 将flg在while中-- 这时，主线程输出5次后试图销毁锁，但子线程未将锁释放（while循环），无法完成。
5. main 中加pthread_cancel()将子线程取消。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;

pthread_mutex_t mutex;//定义锁

void *tfunc(void *arg){
    
    
    srand(time(NULL));//随机数
    while(1){
    
    
        pthread_mutex_lock(&mutex);//加锁
        
        cout << "hello ";
        sleep(rand()%3);//模拟长时间操作共享资源(STDOUT)，导致CPU易主，产生数据混乱
        cout << "world!!!" << endl;
        sleep(rand()%3);//模拟长时间操作共享资源(STDOUT)，导致CPU易主，产生数据混乱
        
        pthread_mutex_unlock(&mutex);//解锁
    }
    return NULL;
}

int main(){
    
    
    int flag = 5;
    pthread_t tid;
    srand(time(NULL));

    //初始化锁
    pthread_mutex_init(&mutex,NULL);//初始化之后mutex==1

    pthread_create(&tid,NULL,tfunc,NULL);
    while(flag--){
    
    
        pthread_mutex_lock(&mutex);//加锁
        
        cout << "HELLO ";
        sleep(rand()%3);//模拟长时间操作共享资源(cout)，导致CPU易主，产生数据混乱
        cout << "WORLD!!!" << endl;
        
        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锁 //解决：当不能获取所有的锁时，放弃所拥有的锁
   

3. 读写锁

与互斥量类似，但读写锁允许更高的并行性。其特性为：写独占，读共享。写锁优先级高

3.1 读写锁状态

一把读写锁具备三种状态：
1. 读模式下加锁状态 (读锁)
2. 写模式下加锁状态 (写锁)
3. 不加锁状态

3.2 读写锁特性

1. 读写锁是“写模式加锁”时， 解锁前，所有对该锁加锁的线程都会被阻塞。
2. 读写锁是“读模式加锁”时， 如果线程以读模式对其加锁会成功；如果线程以写模式加锁会阻塞。
3. 读写锁是“读模式加锁”时， 既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞，写锁优先级高

       读写锁也叫共享-独占锁。当读写锁以读模式锁住时，它是以共享模式锁住的；当它以写模式锁住时，它是以独占模式锁住的。写独占、读共享。

       读写锁非常适合于对数据结构读的次数远大于写的情况。

3.3 主要应用函数

pthread_rwlock_init函数

• 初始化一把读写锁
• int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
  • 参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);

以上7 个函数的返回值都是：成功返回0， 失败直接返回错误号。

• pthread_rwlock_t类型 用于定义一个读写锁变量。
• pthread_rwlock_t rwlock;

3.4 读写锁示例

同时有多个线程对同一全局数据读、写操作。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;

int counter;//定义一个全局变量
pthread_rwlock_t rwlock;//定义一个读写锁变量

/*3个线程不定时写同一全局变量，5个线程不定时读*/
void *th_write(void *arg){
    
    //写锁的线控函数
    int t;
    long i = (long)arg;
    while(1){
    
    
        pthread_rwlock_wrlock(&rwlock);//请求写锁
        t = counter;
        usleep(1000);
        cout << "=========write " << i << ", id = " << pthread_self() << "counter = " << counter << " counter ++ = " << ++counter << endl;
        pthread_rwlock_unlock(&rwlock);//解锁
        usleep(1000);
    }
    return NULL;
}

void *th_read(void *arg){
    
    
    long i = (long)arg;
    while(1){
    
    
        pthread_rwlock_wrlock(&rwlock);//请求写锁
        cout << "--------------------------- read:  " << i << ", id = " << pthread_self() << "counter = " << counter  << endl;
        pthread_rwlock_unlock(&rwlock);//解锁
        usleep(2000);
    }
    return NULL;
}

int main(){
    
    
    long i;
    pthread_t tid[8];
    pthread_rwlock_init(&rwlock,NULL);//初始化锁

    for(i = 0; i < 3;i++){
    
    //write
        pthread_create(&tid[i],NULL,th_write,(void*)i);
    }
    for(i = 0; i < 5;i++){
    
    //read
        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;
}
											

4. 条件变量

条件变量本身不是锁！但它也可以造成线程阻塞。通常与互斥锁配合使用。给多线程提供一个会合的场所。

4.1 主要应用函数

• 以下6 个函数的返回值都是：成功返回0， 失败直接返回错误号。
• pthread_cond_t 类型 用于定义条件变量
• pthread_cond_t cond;

pthread_cond_init函数

• 初始化一个条件变量
• int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
  • 参2：attr表条件变量属性，通常为默认值，传NULL即可
• 也可以使用静态初始化的方法，初始化条件变量：
  • pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

pthread_cond_destroy函数

• 销毁一个条件变量
• int pthread_cond_destroy(pthread_cond_t *cond);

pthread_cond_wait函数

• 阻塞等待一个条件变量
• int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
  • 函数作用：
    • 1.阻塞等待条件变量cond（参1）满足
    • 2.释放已掌握的互斥锁（解锁互斥量）相当于pthread_mutex_unlock(&mutex);（1、2两步为一个原子操作。）
    • 3.当被唤醒，pthread_cond_wait函数返回时，解除阻塞并重新申请获取互斥锁pthread_mutex_lock(&mutex);

pthread_cond_timedwait函数

• 限时等待一个条件变量
• int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);

  • 参3： 参看man sem_timedwait函数，查看struct timespec结构体。

    struct timespec {
            
            
    			time_t tv_sec;		/* seconds */ 秒
    			long   tv_nsec;	/* nanosecondes*/ 纳秒
    		}
    

  • 形参abstime：绝对时间。

    • 如：time(NULL)返回的就是绝对时间。而alarm(1)是相对时间，相对当前时间定时1秒钟。

      struct timespect = {
                
                1, 0};
      pthread_cond_timedwait (&cond, &mutex, &t); 只能定时到 1970年1月1日 00:00:01秒(早已经过去) 
      

    • 正确用法：

      time_t cur = time(NULL); 获取当前时间。
      struct timespec t;	定义timespec 结构体变量t
      t.tv_sec = cur+1; 定时1秒
      pthread_cond_timedwait (&cond, &mutex, &t); 传参
      

在讲解setitimer函数时我们还提到另外一种时间类型：

struct timeval {
    
    
     time_t      tv_sec;  /* seconds */ 秒
     suseconds_t tv_usec; 	/* microseconds */ 微秒
};

pthread_cond_signal函数

• 唤醒至少一个阻塞在条件变量上的线程
• int pthread_cond_signal(pthread_cond_t *cond);

pthread_cond_broadcast函数

• 唤醒全部阻塞在条件变量上的线程
• int pthread_cond_broadcast(pthread_cond_t *cond);

4.2 生产者消费者条件变量模型

       线程同步典型的案例即为生产者消费者模型，而借助条件变量来实现这一模型，是比较常见的一种方法。
       假定有两个线程，一个模拟生产者行为，一个模拟消费者行为。两个线程同时操作一个共享资源（一般称之为汇聚），生产向其中添加产品，消费者从中消费掉产品。

       看如下示例，使用条件变量模拟生产者、消费者问题：

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
using namespace std;

struct msg{
    
    //定义一个结构体，来模拟装大饼的箩筐，一个节点代表一个饼
    int num;
    struct msg* next;
};

struct msg* head = NULL;//头指针
struct msg* mp = NULL;//头结点

//静态初始化，初始化一个互斥变量，一个条件变量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;  
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER; //模拟大饼

//生产者线程
void *producter(void* arg){
    
    
    while(1){
    
    
        mp = new msg;//创建一个节点，模拟生产一个饼
        mp->num = rand()%100 + 1;
        cout << "----------producted--------,the ID number is :" << mp->num << endl;

        pthread_mutex_lock(&mutex);//插入节点，模拟把饼放入箩筐，因为箩筐为公共资源，所以加互斥锁
        mp->next = head;
        head = mp;
        pthread_mutex_unlock(&mutex);

        pthread_cond_signal(&has_product);//将等待在该条件变量上的一个线程唤醒，此刻说明饼做好了
        sleep(rand()%5);
    }
    return NULL;
}
//消费者线程
void *consumer(void* arg){
    
    
    while(1){
    
    
        pthread_mutex_lock(&mutex);
        while(head == NULL){
    
    //头指针为空，说明没有饼，不能用if，因为可能消费者有多个，抢到资源的只有一个，其他的应该被阻塞
            pthread_cond_wait(&has_product,&mutex);
        }
        mp = head;//删除节点，模拟吃饼
        head = mp->next;
        pthread_mutex_unlock(&mutex);

        cout << "-----------------consume: " << mp->num << endl;
        delete mp;
        mp = NULL;
        sleep(rand()%5);
    }
    return NULL;    
}

int main(){
    
    
    pthread_t ptid,ctid;
    srand(time(NULL));
    //创建两个子线程，模拟生产者和消费者
    pthread_create(&ptid,NULL,producter,NULL);
    pthread_create(&ctid,NULL,consumer,NULL);
    //回收两个子线程
    pthread_join(ptid,NULL);
    pthread_join(ctid,NULL);

    return 0;
}					

4.3 条件变量的优点：

       相较于mutex而言，条件变量可以减少竞争。
       如直接使用mutex，除了生产者、消费者之间要竞争互斥量以外，消费者之间也需要竞争互斥量，但如果汇聚（链表）中没有数据，消费者之间竞争互斥锁是无意义的。有了条件变量机制以后，只有生产者完成生产，才会引起消费者之间的竞争。提高了程序效率。

5. 信号量

       进化版的互斥锁（1 --> N）
       由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。线程从并行执行，变成了串行执行。与直接使用单进程无异。
       信号量，是相对折中的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。可用于线程，也可用于进程

5.1 主要应用函数

5.1.1 相关函数

• 以下6 个函数的返回值都是：成功返回0， 失败返回-1，同时设置errno。(注意，它们没有pthread前缀)
• sem_t 类型，本质仍是结构体。但应用期间可简单看作为整数，忽略实现细节（类似于使用文件描述符）。
• sem_t sem; 规定信号量sem不能 < 0。头文件 <semaphore.h>

sem_init函数

• 初始化一个信号量
• int sem_init(sem_t *sem, int pshared, unsigned int value);
  • 参1：sem信号量
  • 参2：pshared取0用于线程间；取非0（一般为1）用于进程间
  • 参3：value指定信号量初值

sem_destroy函数

• 销毁一个信号量
• int sem_destroy(sem_t *sem);

sem_wait函数

• 给信号量加锁 sem –
• int sem_wait(sem_t *sem);

sem_post函数

• 给信号量解锁 sem ++
• int sem_post(sem_t *sem);

sem_trywait函数

• 尝试对信号量加锁 – (与sem_wait的区别类比lock和trylock)
• int sem_trywait(sem_t *sem);

sem_timedwait函数

• 限时尝试对信号量加锁
• int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
  • 参2：abs_timeout采用的是绝对时间。
    • 定时1秒：

      time_t cur = time(NULL); 获取当前时间。
      struct timespec t;	定义timespec 结构体变量t
      t.tv_sec = cur+1; 定时1秒
      t.tv_nsec = t.tv_sec +100; 
      sem_timedwait(&sem, &t); 传参
      

5.1.2 信号量基本操作

sem_wait: 1. 信号量大于0，则信号量-- （类比pthread_mutex_lock）2. 信号量等于0，造成线程阻塞
|
对应
|
sem_post： 将信号量++，同时唤醒阻塞在信号量上的线程 （类比pthread_mutex_unlock）

但，由于sem_t的实现对用户隐藏，所以所谓的++、–操作只能通过函数来实现，而不能直接++、–符号。
信号量的初值，决定了占用信号量的线程的个数。

5.2 生产者消费者信号量模型

使用信号量完成线程间同步，模拟生产者，消费者问题。
分析：

• 规定

  • 如果□中有数据，生产者不能生产，只能阻塞。
  • 如果□中没有数据，消费者不能消费，只能等待数据。

• 定义两个信号量：

  • S满 = 0， S空 = 1
  • S满代表满格的信号量，S空表示空格的信号量，程序起始，格子一定为空

• 所以有：

  T生产者主函数 {
        
        				
  	sem_wait(S空);
  	生产....
  	sem_post(S满);
  }	
  
  T消费者主函数 {
        
        
  	sem_wait(S满);
  	消费....
  	sem_post(S空);
  }
  

• 假设： 线程到达的顺序是:T生、T生、T消。

• 那么

  • T生1 到达，将S空-1，生产，将S满+1
  • T生2 到达，S空已经为0， 阻塞
  • T消 到达，将S满-1，消费，将S空+1

• 三个线程到达的顺序是：T生1、T生2、T消。

• 而执行的顺序是T生1、T消、T生2

这里，S空 表示空格子的总数，代表可占用信号量的线程总数–>1。其实这样的话，信号量就等同于互斥锁。
但，如果S空=2、3、4……就不一样了，该信号量同时可以由多个线程占用，不再是互斥的形式。因此我们说信号量是互斥锁的加强版。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
using namespace std;
#define NUM 5
int arr[NUM]; //全局数组实现队列
sem_t blank_number,product_number;//空格子信号量，产品信号量

void* productor(void *arg){
    
    
    int i = 0;
    while(1){
    
    
        sem_wait(&blank_number);//生产者将空格数--。为0时阻塞等待
        arr[i] = rand()%100 + 1;//随机产生一个数模拟生产一个产品
        cout << "------------prodect ID number : " << arr[i] << endl;
        sem_post(&product_number);//产品数++

        i = (i+1)% NUM;//借助下标实现环形机制
        sleep(rand()%3);
    }
    return NULL;
}

void* consumer(void *arg){
    
    
    int i = 0;
    while(1){
    
    
        sem_wait(&product_number);//生产者将产品数--。为0时阻塞等待
        cout << "------------consume a product : " << arr[i] << endl;
        arr[i] = 0;//消费一个产品
        sem_post(&blank_number);//空格数++

        i = (i+1)% NUM;//借助下标实现环形机制
        sleep(rand()%3);
    }    
    return NULL;
}


int main(){
    
    
    pthread_t pid,cid;
    sem_init(&blank_number,0,NUM);//初始化空格子信号量为5
    sem_init(&product_number,0,0);//初始化产品量为0

    pthread_create(&pid,NULL,productor,NULL);
    pthread_create(&cid,NULL,consumer,NULL);

    pthread_join(pid,NULL);
    pthread_join(cid,NULL);

    sem_destroy(&blank_number);
    sem_destroy(&product_number);
    return 0;
}

【推演练习】： 理解上述模型，推演，如果是两个消费者，一个生产者，是怎么样的情况。
【作业】：结合生产者消费者信号量模型，揣摩sem_timedwait函数作用。编程实现，一个线程读用户输入， 另一个线程打印“hello world”。如果用户无输入，则每隔5秒向屏幕打印一个“hello world”；如果用户有输入，立刻打印“hello world”到屏幕。

6. 进程间同步

6.1 互斥量mutex

       进程间也可以使用互斥锁，来达到同步的目的。但应在pthread_mutex_init初始化之前，修改其属性为进程间共享。mutex的属性修改函数主要有以下几个。

主要应用函数：
pthread_mutexattr_t mattr 类型： 用于定义mutex锁的【属性】

pthread_mutexattr_init函数

• 初始化一个mutex属性对象
• int pthread_mutexattr_init(pthread_mutexattr_t *attr);

pthread_mutexattr_destroy函数

• 销毁mutex属性对象 (而非销毁锁)
• int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);

pthread_mutexattr_setpshared函数

• 修改mutex属性。
• int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared);
  • 参2：pshared取值：
    • 线程锁：PTHREAD_PROCESS_PRIVATE (mutex的默认属性即为线程锁，进程间私有)
    • 进程锁：PTHREAD_PROCESS_SHARED

进程间mutex示例：进程间使用mutex来实现同步

#include <iostream>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <string.h>
using namespace std;

struct mt{
    
    
    int num;
    pthread_mutex_t mutex;
    pthread_mutexattr_t mutexattr;
};

int main(){
    
    
    int fd,i;
    struct mt *mm;
    pid_t pid;

    fd = open("mt_test", O_RDWR|O_CREAT,0777);
    ftruncate(fd,sizeof(*mm));
    mm = (struct mt *)mmap(NULL,sizeof(*mm),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);//强制类型转换，mmap返回void*
    close(fd);
    unlink("mt_test");
    memset(mm,0,sizeof(*mm));

    pthread_mutexattr_init(&mm->mutexattr);//初始化metex属性对象
    pthread_mutexattr_setpshared(&mm->mutexattr,PTHREAD_PROCESS_SHARED);//修改属性为进车间共享，默认线程间共享
    pthread_mutex_init(&mm->mutex,&mm->mutexattr);//初始化一把mutex锁

    pid = fork();
    if(pid == 0){
    
    
        for(i = 0;i < 10;i++){
    
    
              pthread_mutex_lock(&mm->mutex);
              (mm->num)++;
              cout << "child------num ++ : " << mm->num << endl;
              pthread_mutex_unlock(&mm->mutex);
              sleep(1);
        }
    }else if(pid > 0){
    
    
        for(i = 0;i < 10;i++){
    
    
            sleep(1);
            pthread_mutex_lock(&mm->mutex);
            mm->num += 2;
            cout << "parent ---- num+=2 : " << mm->num << endl;
            pthread_mutex_unlock(&mm->mutex);
        }
        wait(NULL);
    }

    pthread_mutexattr_destroy(&mm->mutexattr);
    pthread_mutex_destroy(&mm->mutex);
    munmap(mm,sizeof(*mm));//释放映射区
    return 0;
}

6.2 文件锁

       借助 fcntl函数来实现锁机制。 操作文件的进程没有获得锁时，可以打开，但无法执行read、write操作。

fcntl函数

• 获取、设置文件访问控制属性。
• int fcntl(int fd, int cmd, … /* arg */ );
  • 参2：

    F_SETLK (struct flock *)	设置文件锁（trylock）
    F_SETLKW (struct flock *)   设置文件锁（lock）W --> wait
    F_GETLK (struct flock *)	获取文件锁
    

  • 参3：

    struct flock {
            
            
          ...
          short l_type;    	锁的类型：F_RDLCK 、F_WRLCK 、F_UNLCK
          short l_whence;  	偏移位置：SEEK_SET、SEEK_CUR、SEEK_END 
          off_t l_start;   	起始偏移
          off_t l_len;     	长度：0表示整个文件加锁
          pid_t l_pid;     	持有该锁的进程ID：(F_GETLK only)
          ...
     };
    

进程间文件锁示例：多个进程对加锁文件进行访问

#include <iostream>
#include <unistd.h>
#include <fcntl.h>
using namespace std;

void sys_err(const char *str){
    
    
    perror(str);
    exit(1);
}

int main(int argc,char *argv[]){
    
    
    int fd;
    struct flock f_lock;
    
    if(argc < 2){
    
    
        cout << "./a.out filename" << endl;
        exit(1);
    }
    if((fd = open(argv[1],O_RDWR)) < 0){
    
    
        sys_err("open");
    }
    
    //加锁
    f_lock.l_type = F_RDLCK;//选用读锁，读时共享，写时读占

    f_lock.l_start = 0;
    f_lock.l_len = 0;//0表示整个文件加锁
    f_lock.l_whence = SEEK_SET;

    fcntl(fd,F_SETLKW,&f_lock);
    cout << "get flock! " << endl;

    sleep(10);//模拟文件操作过程
    
    //解锁
    f_lock.l_type = F_UNLCK;
    fcntl(fd,F_SETLKW,&f_lock);
    cout << "un flock!" << endl;
    
    close(fd);
    return 0;
}

依然遵循“读共享、写独占”特性。但！如若进程不加锁直接操作文件，依然可访问成功，但数据势必会出现混乱。
【思考】：多线程中，可以使用文件锁吗？
多线程间共享文件描述符，而给文件加锁，是通过修改文件描述符所指向的文件结构体中的成员变量来实现的。因此，多线程中无法使用文件锁。

7. 哲学家用餐模型分析

7.1 多线程版：

选用互斥锁mutex，如创建5个， pthread_mutex_t m[5];
模型抽象：

• 5个哲学家 --> 5个线程； 5支筷子 --> 5把互斥锁 int left(左手)， right(右手)
• 5个哲学家使用相同的逻辑，可通用一个线程主函数，void *tfn(void *arg)，使用参数来表示线程编号：int i = (int)arg;
• 哲学家线程根据编号知道自己是第几个哲学家，而后选定锁，锁住，吃饭。否则哲学家thinking。
• 哲学家: A B C D E
• 5支筷子，在逻辑上形成环： 0 1 2 3 4 分别对应5个哲学家：
  

所以有：

if(i == 4)	
	left = i, right = 0;
else 
	left = i, right = i+1;

振荡：如果每个人都攥着自己左手的锁，尝试去拿右手锁，拿不到则将锁释放。过会儿五个人又同时再攥着左手锁尝试拿右手锁，依然拿不到。如此往复形成另外一种极端死锁的现象——振荡。

避免振荡现象：只需5个人中，任意一个人，拿锁的方向与其他人相逆即可(如：E，原来：左：4，右：0 现在：左：0， 右：4)。
所以以上if else语句应改为：

if(i == 4)	
	left = 0, right = i;
else 
	left = i, right = i+1;

而后， 首先应让哲学家尝试加左手锁：

while {
    
     
	pthread_mutex_lock(&m[left]); 	
	/*
	如果加锁成功，函数返回再加右手锁，
	如果失败，应立即释放左手锁，等待。
	若，左右手都加锁成功 --> 吃 --> 吃完 --> 释放锁（应先释放右手、再释放左手，是加锁顺序的逆序）
	*/
}

• 主线程(main)中，初始化5把锁，销毁5把锁，创建5个线程（并将i传递给线程主函数），回收5个线程。
• 避免死锁的方法：
  1. 当得不到所有所需资源时，放弃已经获得的资源，等待。
  2. 保证资源的获取顺序，要求每个线程获取资源的顺序一致。如：A获取顺序1、2、3；B顺序应也是1、2、3。若B为3、2、1则易出现死锁现象。

7.2 多进程版

相较于多线程需注意问题：
需注意如何共享信号量 (注意：坚决不能使用全局变量 sem_t s[5])

实现：
main函数中：

	循环 sem_init(&s[i], 0, 1); 将信号量初值设为1，信号量变为互斥锁。
	循环 sem_destroy(&s[i]);
	循环 创建 5 个子进程。 if(i < 5) 中完成子进程的代码逻辑。
	循环 回收 5 个子进程。

子进程中：

if(i == 4)  
	left = 0, right == 4;
else	
	left = i, right = i+1;	
while (1) {
    
    
	使用 sem_wait(&s[left]) 锁左手，尝试锁右手，若成功 --> 吃； 若不成功 --> 将左手锁释放。
	吃完后， 先释放右手锁，再释放左手锁。
}

【重点注意】：
直接将sem_t s[5]放在全局位置，试图用于子进程间共享是错误的！应将其定义放置与mmap共享映射区中。main中：
sem_t *s = mmap(NULL, sizeof(sem_t) * 5, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON， -1， 0);
使用方式：将s当成数组首地址看待，与使用数组s[5]没有差异。