《Linux C编程实战》笔记：线程同步

这一节主要是解决共享资源的处理。操作系统里也讲过互斥、锁之类的概念。

互斥锁

互斥锁通过锁机制来实现线程同步，同一时刻只允许一个线程执行一个关键部分的代码

以下是操作互斥锁的函数，均声明在pthread.h中。

1. pthread_mutex_init（初始化互斥锁）：

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

   该函数用于初始化互斥锁，其中mutex是指向互斥锁的指针，attr是指向互斥锁属性的指针。如果不需要特殊属性，可以将attr参数设置为NULL。

2. pthread_mutex_destroy（销毁互斥锁）：

   int pthread_mutex_destroy(pthread_mutex_t *mutex);

   该函数用于销毁互斥锁，释放相关资源。在互斥锁使用完毕后，应该调用该函数来进行清理操作。函数成功执行时返回0.

3. pthread_mutex_lock（加锁）：

   int pthread_mutex_lock(pthread_mutex_t *mutex);

   该函数用于尝试获得互斥锁的所有权。如果互斥锁已经被其他线程占用，调用线程将被阻塞，直到互斥锁可用。

4. pthread_mutex_unlock（解锁）：

   int pthread_mutex_unlock(pthread_mutex_t *mutex);

   该函数用于释放互斥锁（与加锁的必须是同一线程），允许其他线程获得该互斥锁的所有权。应该在对共享资源的访问完成后调用该函数。

5. pthread_mutex_trylock（尝试加锁）：

   int pthread_mutex_trylock(pthread_mutex_t *mutex);

   该函数尝试获得互斥锁的所有权，但如果锁已经被其他线程占用，则不会阻塞，而是立即返回错误EBUSY。可以利用这个函数来实现非阻塞的加锁操作。

互斥锁的初始化可以用静态赋值法，将一个宏结构赋给mutex

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;

或者是用初始化函数，不过用之前还要先了解pthread_mutexattr_t怎么用。

    pthread_mutexattr_t mutexattr;
    pthread_mutexattr_init(&mutexattr);
    pthread_mutexattr_settype(&mutexattr,PTHREAD_MUTEX_RECURSIVE);

这样算是设定好了锁的属性。属性一般是以下几种

1. PTHREAD_MUTEX_NORMAL：

   • 普通互斥锁，不允许递归锁。对同一线程多次调用 pthread_mutex_lock 会导致死锁。

2. PTHREAD_MUTEX_RECURSIVE：

   • 允许同一线程多次获得互斥锁，使用嵌套锁。线程每成功调用一次 pthread_mutex_lock，必须调用相同次数的 pthread_mutex_unlock 才能释放锁。
   • 如果是不同线程请求，则在解锁时重新竞争

3. PTHREAD_MUTEX_ERRORCHECK：

   • 提供错误检查，如果同一线程重复调用 pthread_mutex_lock，会返回错误EDEADLK。

4. PTHREAD_MUTEX_DEFAULT：

   • 默认类型，通常等同于 PTHREAD_MUTEX_NORMAL。

注意:加锁时，不论哪种类型的锁，都不可能被两个不同的线程同时得到，其中一个必须等待解锁。在同一进程中的线程，如果加锁后没有解锁，则其他线程将无法再获得该锁。

示例代码

以下代码演示了互斥锁保护全局变量的用法

pthread_mutex_t number_mutex;
int globalnumber;
void write_globalnumber(){
    pthread_mutex_lock(&number_mutex);
    globalnumber++;
    pthread_mutex_unlock(&number_mutex);
}
int read_globalnumber(){
    int temp;
    pthread_mutex_lock(&number_mutex);
    temp=globalnumber;
    pthread_mutex_unlock(&number_mutex);
    return temp;
}

还是很好懂的，在读写之前上锁，操作完之后解锁。

条件变量

条件变量是利用线程间共享的全局变量进行同步的一种机制。 条件变量宏观上类似if语句，
符合条件就能执行某段程序，否则只能等待条件成立。

使用条件变量主要包括两个动作：一个等待使用资源的线程等待“条件变量被设置为真”；另一个线程在使用完资源后“设置条件为真”，这样就可以保证线程间的同步了。这样就存在一个关键问题，就是要保证条件变量能被正确的修改，条件变量要收到特殊的保护。实际使用中互斥锁扮演者这样的一个保护者的角色。Linux提供了一系列对条件变量操作的函数

1. pthread_cond_init:

   int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

   该函数用于初始化条件变量。pthread_cond_t 是条件变量的类型，attr 是条件变量的属性，通常可以设置为 NULL 表示默认属性。

2. pthread_cond_destroy:

   int pthread_cond_destroy(pthread_cond_t *cond);

   该函数用于销毁条件变量。在条件变量不再使用时调用，以释放相关资源。

3. pthread_cond_wait:

   int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

   这个函数使线程等待条件变量的信号。在调用这个函数之前，线程通常需要先获取一个互斥锁（mutex），然后在等待条件变量的时候会释放这个互斥锁。

4. pthread_cond_timedwait:

   int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);

   类似于 pthread_cond_wait，但是它在指定的时间（abstime）之后超时返回。abstime 是一个绝对时间。

5. pthread_cond_signal:

   int pthread_cond_signal(pthread_cond_t *cond);

   该函数用于发送信号给一个正在等待条件变量的线程，唤醒其中一个。通常在某个条件变为真的时候调用。

6. pthread_cond_broadcast:

   int pthread_cond_broadcast(pthread_cond_t *cond);

   该函数用于发送信号给所有正在等待条件变量的线程，唤醒它们。通常在某个条件变为真的时候调用。

和互斥锁一样，条件变量的初始化也可以用静态赋值法

pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

还有一种方式自然是用初始化函数，一般attr都是空指针

pthread_cond_wait函数释放由mutex指向的互斥锁，同时使当前线程关于cond指向的条件变量阻塞，直到条件被信号唤醒。通常条件表达式在互斥锁的保护下求值，如果条件表达式为假，那么线程基于条件变量阻塞。当一个线程改变条件变量的值时，条件变量获得一个信号，使得等待条件变量的线程退出阻塞状态。

线程被条件变量阻塞后，可通过两个函数激活。

signal只激活一个等待的线程，存在多个的话按入队顺序激活；broadcast激活所有等待的线程

清除函数destory只有在没有线程等待该条件变量的时候才能清除，否则返回EBUSY

说了这么多，其实也不知道应该怎么用，看下面的代码

示例代码

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
void cleanup_handler(void *arg) {
    pthread_mutex_unlock((pthread_mutex_t *)arg);
}
void *thread1(void *arg){
    pthread_cleanup_push(cleanup_handler,&mutex);//这个在上一篇文章有讲过
    while (1)
    {
        printf("thread1 is running\n");
        pthread_mutex_lock(&mutex);
        pthread_cond_wait(&cond,&mutex);
        printf("thread1 applied the condition\n");
        pthread_mutex_unlock(&mutex);
        sleep(4);
    }
    
    pthread_cleanup_pop(0);
 
}
void *thread2(void *arg){
    while(1){
        printf("thread2 is running\n");
        pthread_mutex_lock(&mutex);
        pthread_cond_wait(&cond,&mutex);
        printf("thread2 applied the condition\n");
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
}
int main(){
    pthread_t tid1,tid2;
    printf("condition variable study!\n");
    pthread_mutex_init(&mutex,nullptr);
    pthread_cond_init(&cond,nullptr);
    pthread_create(&tid1,nullptr,thread1,nullptr);
    pthread_create(&tid2,nullptr,thread2,nullptr);
    do{
        pthread_cond_signal(&cond);
    }while (1);
    
}

执行片段

这个具体是怎么执行的呢，首先线程1给mutex上锁然后执行pthread_cond_wait，这时候mutex就解锁了，同时线程1或阻塞，线程2得以给mutex上锁并打印running那一句，然后线程2同样也阻塞了。然后cond会收到主线程发来的signal信号，按照示例的运行结果是线程2被唤醒了，这时候它会重新给mutex上锁，并打印applied这一句，然后给mutex解锁。

条件变量都是需要配合互斥量一起使用的，这样可以防止多个线程请求wait函数。

还有一小节是关于异步信号的，不过书上就讲了几行，估计不太重要吧