互斥锁与条件变量的使用(c || c++ || python)

python

import threading

# 创建Event对象
event = threading.Event()

# 线程函数
def thread_function():
    print("Thread is waiting for event to be set")
    event.wait()
    print("Event is set. Thread is continuing")

# 创建线程
thread = threading.Thread(target=thread_function)

# 启动线程
thread.start()

# 触发事件
event.set()

# 等待线程结束
thread.join()

set()是用于创建一个空集合的语法。集合是一种无序且不重复的数据结构
wait()是threading.Event()对象的一个方法，用于使线程等待事件的发生

---

1.创建了一个Event对象event
2.定义了一个线程函数thread_function()，该函数首先打印一条消息，然后调用event.wait()来等待事件的触发
3.创建了一个线程，并启动该线程
4.调用event.set()来触发事件
5.使用thread.join()等待线程结束

---

c

#include 
#include 

// 共享资源
int shared_resource = 0;

// 互斥锁和条件变量
pthread_mutex_t mutex;
pthread_cond_t cond;

// 线程函数
void* thread_function(void* arg) {
    // 获取互斥锁
    pthread_mutex_lock(&mutex);
    
    // 等待条件变量
    while (shared_resource == 0) {
        pthread_cond_wait(&cond, &mutex);
    }
    
    // 条件满足，访问共享资源
    printf("Thread is accessing shared resource: %d\n", shared_resource);
    
    // 释放互斥锁
    pthread_mutex_unlock(&mutex);
    
    return NULL;
}

int main() {
    // 初始化互斥锁和条件变量
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);
    
    // 创建线程
    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);
    
    // 修改共享资源
    pthread_mutex_lock(&mutex);
    shared_resource = 42;
    // 发送信号通知条件已满足
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);
    
    // 等待线程结束
    pthread_join(thread, NULL);
    
    // 销毁互斥锁和条件变量
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    
    return 0;
}

在C语言中，可以使用互斥锁（Mutex）和条件变量（Condition Variable）来实现线程同步。

互斥锁用于保护共享资源，确保在任何时候只有一个线程可以访问共享资源。当一个线程获得互斥锁时，其他线程将被阻塞，直到该线程释放互斥锁。

条件变量用于线程间的通信和同步。它允许一个线程等待某个条件成立，而其他线程可以通过发送信号来通知该条件已经满足。

---

1.使用pthread_mutex_t定义了互斥锁mutex，并使用pthread_cond_t定义了条件变量cond
2.在线程函数中使用pthread_mutex_lock()获取互斥锁，并使用pthread_cond_wait()等待条件变量
3.在主线程中，修改共享资源，并使用pthread_cond_signal()发送信号通知条件已满足
4.使用pthread_join()等待线程结束，并使用pthread_mutex_destroy()和pthread_cond_destroy()销毁互斥锁和条件变量

---

c++

在C++中，可以使用std::mutex和std::condition_variable来实现线程同步。这些类提供了与C语言中的互斥锁和条件变量类似的功能

#include 
#include 
#include 
#include 

// 共享资源
int shared_resource = 0;

// 互斥锁和条件变量
std::mutex mutex;
std::condition_variable cond;

// 线程函数
void thread_function() {
    // 获取互斥锁
    std::unique_lock lock(mutex);
    
    // 等待条件变量
    cond.wait(lock, [](){ return shared_resource != 0; });
    
    // 条件满足，访问共享资源
    std::cout << "Thread is accessing shared resource: " << shared_resource << std::endl;
}

int main() {
    // 创建线程
    std::thread thread(thread_function);
    
    // 修改共享资源
    {
        std::lock_guard lock(mutex);
        shared_resource = 42;
    }
    // 发送信号通知条件已满足
    cond.notify_one();
    
    // 等待线程结束
    thread.join();
    
    return 0;
}

1.使用std::mutex定义了互斥锁mutex，并使用std::condition_variable定义了条件变量cond
2.在线程函数中使用std::unique_lock获取互斥锁，并使用cond.wait()等待条件变量
3.在主线程中，我们修改了共享资源，并使用cond.notify_one()发送信号通知条件已满足
4.使用thread.join()等待线程结束

总结起来，C语言和C++中的互斥锁和条件变量提供了一种线程同步的机制，以保护共享资源并实现线程间的通信。在Python中，可以使用threading.Lock()和threading.Event()来实现类似的功能

扩展

// 接受一个参数的lambda表达式
int x = 42;
auto lambda1 = [](int y) { return y + 1; };
int result1 = lambda1(x);  // result1 = 43

// 返回值为bool类型的lambda表达式
auto lambda2 = []() -> bool { return true; };
bool result2 = lambda2();  // result2 = true

// 返回值为void类型的lambda表达式
auto lambda3 = []() { std::cout << "Hello, World!" << std::endl; };
lambda3();  // 输出：Hello, World!

在C++中，<>是模板参数列表的标识符，用于指定模板的参数类型。
在std::unique_lockstd::mutex lock(mutex);这行代码中，std::unique_lock是一个模板类，它接受一个模板参数std::mutex，表示使用std::mutex作为互斥锁的类型。因此，std::unique_lockstd::mutex实际上是一个互斥锁的封装。

而在cond.wait(lock, { return shared_resource != 0; });这行代码中，{ return shared_resource != 0; }是一个lambda表达式。
lambda表达式是一种匿名函数，可以在代码中直接定义和使用，而不需要单独定义一个函数。它的语法是[] (参数列表) { 函数体 }。

在这个特定的例子中，lambda表达式被用作std::condition_variable的wait()函数的第二个参数。lambda表达式的函数体return shared_resource != 0;返回一个布尔值，表示条件是否满足。cond.wait()函数会在等待条件变量时检查这个lambda表达式的返回值，只有当返回值为true时，才会继续执行

lambda表达式是C++11引入的一项功能强大的特性，可以方便地定义匿名函数。它在很多情况下可以简化代码，并提高代码的可读性和可维护性