当前位置：首页 > news >正文

做家常便饭网站chatgpt入口

news 2025/8/2 3:19:07

做家常便饭网站,chatgpt入口,网站宣传活动怎么做,利用网站文件下载做推广在现代软件开发中，多线程编程是提升应用程序性能和响应能力的重要手段。然而，多线程编程也带来了数据竞争和死锁等复杂问题。为了确保线程间的同步和共享数据的一致性，C标准库提供了多种锁机制。 1. std::mutex std::mutex是最基础的互斥锁…

在现代软件开发中，多线程编程是提升应用程序性能和响应能力的重要手段。然而，多线程编程也带来了数据竞争和死锁等复杂问题。为了确保线程间的同步和共享数据的一致性，C++标准库提供了多种锁机制。

1. `std::mutex`

std::mutex是最基础的互斥锁，用于保护共享数据，防止多个线程同时访问该数据。

#include <iostream>
#include <thread>
#include <mutex>std::mutex mtx;void print_thread_id(int id) {mtx.lock();std::cout << "Thread " << id << std::endl;mtx.unlock();
}int main() {std::thread t1(print_thread_id, 1);std::thread t2(print_thread_id, 2);t1.join();t2.join();return 0;
}

在上述代码中，mtx.lock()和mtx.unlock()分别用于加锁和解锁，确保同一时刻只有一个线程可以访问临界区（std::cout操作）。

2. `std::recursive_mutex`

std::recursive_mutex允许同一线程多次获得同一锁，而不会导致死锁。适用于递归调用中需要加锁的场景。

#include <iostream>
#include <thread>
#include <mutex>std::recursive_mutex rec_mtx;void recursive_function(int count) {if (count <= 0) return;rec_mtx.lock();std::cout << "Count: " << count << std::endl;recursive_function(count - 1);rec_mtx.unlock();
}int main() {std::thread t(recursive_function, 5);t.join();return 0;
}

3. `std::timed_mutex`

std::timed_mutex支持尝试在一定时间内获取锁。这在避免死锁和提高程序响应性方面很有用。

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>std::timed_mutex tmtx;void try_lock_for_example() {if (tmtx.try_lock_for(std::chrono::seconds(1))) {std::cout << "Lock acquired" << std::endl;std::this_thread::sleep_for(std::chrono::seconds(2));tmtx.unlock();} else {std::cout << "Failed to acquire lock" << std::endl;}
}int main() {std::thread t1(try_lock_for_example);std::thread t2(try_lock_for_example);t1.join();t2.join();return 0;
}

4. `std::recursive_timed_mutex`

std::recursive_timed_mutex结合了std::recursive_mutex和std::timed_mutex的特性

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>std::recursive_timed_mutex rtmtx;void recursive_timed_function(int count) {if (count <= 0) return;if (rtmtx.try_lock_for(std::chrono::seconds(1))) {std::cout << "Count: " << count << std::endl;recursive_timed_function(count - 1);rtmtx.unlock();} else {std::cout << "Failed to acquire lock" << std::endl;}
}int main() {std::thread t(recursive_timed_function, 5);t.join();return 0;
}

5. `std::shared_mutex`（C++17引入）

std::shared_mutex允许多个线程同时读取共享数据，但只允许一个线程写入数据。这种机制适用于读多写少的场景。

#include <iostream>
#include <thread>
#include <shared_mutex>std::shared_mutex smtx;void read_function() {smtx.lock_shared();std::cout << "Reading data" << std::endl;smtx.unlock_shared();
}void write_function() {smtx.lock();std::cout << "Writing data" << std::endl;smtx.unlock();
}int main() {std::thread t1(read_function);std::thread t2(read_function);std::thread t3(write_function);t1.join();t2.join();t3.join();return 0;
}

6. `std::shared_timed_mutex`（C++14引入）

std::shared_timed_mutex结合了std::shared_mutex和std::timed_mutex的特性。

#include <iostream>
#include <thread>
#include <shared_mutex>
#include <chrono>std::shared_timed_mutex stmtx;void shared_timed_read_function() {if (stmtx.try_lock_shared_for(std::chrono::seconds(1))) {std::cout << "Reading data" << std::endl;std::this_thread::sleep_for(std::chrono::seconds(2));stmtx.unlock_shared();} else {std::cout << "Failed to acquire shared lock" << std::endl;}
}void shared_timed_write_function() {if (stmtx.try_lock_for(std::chrono::seconds(1))) {std::cout << "Writing data" << std::endl;std::this_thread::sleep_for(std::chrono::seconds(2));stmtx.unlock();} else {std::cout << "Failed to acquire exclusive lock" << std::endl;}
}int main() {std::thread t1(shared_timed_read_function);std::thread t2(shared_timed_read_function);std::thread t3(shared_timed_write_function);t1.join();t2.join();t3.join();return 0;
}

7. `std::lock_guard`

std::lock_guard提供一种异常安全的方式来管理锁的生命周期，通常用于自动解锁。

#include <iostream>
#include <thread>
#include <mutex>std::mutex mtx;void lock_guard_example() {std::lock_guard<std::mutex> lock(mtx);std::cout << "Lock acquired using lock_guard" << std::endl;// mtx is automatically unlocked when lock goes out of scope
}int main() {std::thread t(lock_guard_example);t.join();return 0;
}

8. `std::unique_lock`

std::unique_lock比std::lock_guard更加灵活，支持延迟加锁、解锁和重新加锁。

#include <iostream>
#include <thread>
#include <mutex>std::mutex mtx;void unique_lock_example() {std::unique_lock<std::mutex> lock(mtx);std::cout << "Lock acquired using unique_lock" << std::endl;lock.unlock();std::cout << "Lock released" << std::endl;lock.lock();std::cout << "Lock reacquired" << std::endl;
}int main() {std::thread t(unique_lock_example);t.join();return 0;
}

9. `std::shared_lock`（C++17引入）

std::shared_lock用于管理共享互斥量（std::shared_mutex或std::shared_timed_mutex），提供了一种简单的方式来处理读锁。

#include <iostream>
#include <thread>
#include <shared_mutex>std::shared_mutex smtx;void shared_lock_example() {std::shared_lock<std::shared_mutex> lock(smtx);std::cout << "Shared lock acquired" << std::endl;
}int main() {std::thread t1(shared_lock_example);std::thread t2(shared_lock_example);t1.join();t2.join();return 0;
}