线程类封装
#include<thread>
#include<iostream>
#include<string>
using namespace std::chrono_literals;
class MyThread {
public:
void Main() {
std::cout << "MyThread Main" << name << ":" << age;
}
private:
std::string name;
int age = 100;
};
class XThread {
public:
virtual void Start() {
_is_exit = false;
_th = std::thread(&XThread::Main, this);
}
virtual void Stop() {
_is_exit = true;
Wait();
}
virtual void Wait() {
if (_th.joinable())
_th.join();
}
bool is_exit() { return _is_exit; }
private:
virtual void Main() = 0;
std::thread _th;
bool _is_exit = false;
};
class TestXThread:public XThread {
public:
void Main() override {
while (!is_exit()) {
std::this_thread::sleep_for(100ms);
std::cout << "." << std::flush;
}
}
std::string name;
};
锁
超时锁
超时锁是一种同步机制，用于在尝试获取锁时设置一个超时时间。如果线程在指定的时间内无法获取锁，它将放弃，而不是无限期地等待。这种机制对于避免死锁和提高系统的响应性非常有用
try_lock_for(duration): 这个方法允许线程尝试在指定的时间段内获取锁。如果在这段时间内锁未被获取，则返回 false。这里的 duration 是一个表示时间长度的对象，比如可以使用 std::chrono 库来指定
try_lock_for 是 std::timed_mutex 或类似互斥体（如 std::recursive_timed_mutex）的一个成员函数，它尝试在指定时间段内获取锁。如果在这个时间段内成功获得锁，它会返回 true；如果时间段结束时仍未获得锁，它会返回 false。这种机制允许线程不会无限期地等待锁的释放，提高了程序的响应性和灵活性。
递归锁
共享锁
共享锁（Shared Lock），在多线程编程和数据库管理系统中，是一种用于控制对共享资源的并发访问的同步机制。与互斥锁（独占锁）不同，共享锁允许多个线程或进程同时读取同一资源，但在写入时仍然需要独占访问权限。
lock_shared()函数用于获取共享锁，也称为读锁。当你希望多个线程能够同时读取某个共享数据时使用。在任何时刻，可以有多个线程持有共享锁，只要没有线程持有独占锁。这允许多个读操作并行执行，而不会互相冲突，因为读操作通常不会改变数据状态。
lock()函数用于获取独占锁，也称为写锁。当你希望确保只有一个线程能够写入或修改共享数据时使用。独占锁保证了没有其他线程可以同时读取或写入共享资源，确保了对共享资源的独占访问权。
利用RAII
#include <thread>
#include <iostream>
#include <string>
#include <mutex>
#include <shared_mutex>
//Linux -lpthread
using namespace std;
// RAII
class XMutex
{
public:
XMutex(mutex& mux):mux_(mux)
{
cout << "Lock" << endl;
mux.lock();
}
~XMutex()
{
cout << "Unlock" << endl;
mux_.unlock();
}
private:
mutex& mux_;
};
static mutex mux;
void TestMutex(int status)
{
XMutex lock(mux);
if (status == 1)
{
cout << "=1" << endl;
return;
}
else
{
cout << "!=1" << endl;
return;
}
}
int main(int argc, char* argv[])
{
TestMutex(1);
TestMutex(2);
getchar();
return 0;
}
lock_guard
std::lock_guard 是 C++ 标准库中的一个模板类，用于简化互斥锁（如 std::mutex）的管理。它实现了一种被称为“范围锁定”（RAII, Resource Acquisition Is Initialization）的模式，确保在持有锁的线程的执行范围内，锁一定会被持有，并在范围结束时自动释放。
#include <thread>
#include <iostream>
#include <string>
#include <mutex>
#include <shared_mutex>
//Linux -lpthread
using namespace std;
// RAII
class XMutex
{
public:
XMutex(mutex& mux):mux_(mux)
{
cout << "Lock" << endl;
mux.lock();
}
~XMutex()
{
cout << "Unlock" << endl;
mux_.unlock();
}
private:
mutex& mux_;
};
static mutex mux;
void TestMutex(int status)
{
XMutex lock(mux);
if (status == 1)
{
cout << "=1" << endl;
return;
}
else
{
cout << "!=1" << endl;
return;
}
}
static mutex gmutex;
void TestLockGuard(int i)
{
gmutex.lock();
{
//�Ѿ�ӵ��������lock
lock_guard<mutex> lock(gmutex,adopt_lock);
//�����ͷ���
}
{
lock_guard<mutex> lock(gmutex);
cout << "begin thread " << i << endl;
}
for (;;)
{
{
lock_guard<mutex> lock(gmutex);
cout << "In " << i << endl;
}
this_thread::sleep_for(500ms);
}
}
int main(int argc, char* argv[])
{
for (int i = 0; i < 3; i++)
{
thread th(TestLockGuard, i + 1);
th.detach();
}
TestMutex(1);
TestMutex(2);
getchar();
return 0;
}unique_lock
在 C++ 中的多线程编程里，锁的标签（或锁策略标签）是一些用于指定锁的行为的标记。这些标签通常与锁管理器（如 std::unique_lock 或 std::lock_guard）一起使用，来控制互斥量的锁定和解锁行为。以下是一些常见的锁的标签：
-
std::adopt_lock： 这个标签用于指示锁管理器对象，互斥量在传递给锁管理器之前已经被当前线程锁定。锁管理器将“采用”这个已经存在的锁，并在其析构时释放它。使用std::adopt_lock需要确保互斥量在传递之前已经被锁定。 -
std::defer_lock： 使用这个标签创建的锁管理器对象不会立即锁定互斥量。这允许延迟锁定操作，直到显式调用锁定方法。这提供了更多的控制，允许在需要时进行锁定。 -
std::try_to_lock： 用这个标签构造的锁管理器会尝试锁定互斥量，但不会阻塞等待。如果互斥量当前不可用（已被其他线程锁定），锁管理器不会持有锁。
shared_lock
scope_lock
std::scoped_lock 是 C++17 标准引入的一个锁管理器，用于简化多个互斥锁的获取和释放，从而帮助避免死锁。它是一种作用域锁（scope-based locking），能够在构造时自动获取一个或多个互斥锁，并在离开作用域（即对象被销毁）时自动释放这些锁。
互斥锁+list模拟线程通信
条件变量
生产者消费者模型
#include <thread>
#include <iostream>
#include <mutex>
#include <list>
#include <string>
#include <sstream>
using namespace std;
list<string> msgs_;
mutex mux;
condition_variable cv;
void ThreadWrite() {
for (int i = 0;; i++) {
stringstream ss;
ss << "Write msg" << i;
unique_lock<mutex>lock(mux);
msgs_.push_back(ss.str());
cv.notify_one();
this_thread::sleep_for(3s);
}
}
void ThreadRead(int i) {
while (true) {
unique_lock<mutex>lock(mux);
cout << "read msg" << endl;
cv.wait(lock, [i] {
cout << i << "wait" << endl;
return !msgs_.empty();
});
}
while (!msgs_.empty()) {
cout << i << "read" << msgs_.front() << endl;
msgs_.pop_front();
}
}
int main() {
}线程的异步和通信
线程池
