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()等待线程结束
#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++中，可以使用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引入的一项功能强大的特性，可以方便地定义匿名函数。它在很多情况下可以简化代码，并提高代码的可读性和可维护性