嵌入式linux开发多线程,多线程并发

# 多线程和并发

### 多线程

~~~

std::async() 和 std::future

async启动策略：

1. std::launch::async 执行后立刻创建对应执行线程

2. std::launch::deferred 当其他线程调用get获取状态时，执行等待

3. std::launch::async||std::launch::deferred 默认策略

//异步策略启动

std::future future1 = std::async(std::launch::async, []{

std::this_thread::sleep_for(std::chrono::seconds(1));

})

对于异步策略，不需要wait 或者 get 来等线程结束，异步策略会等待线程结束

//延时策略

std::future future1 = std::async(std::launch::deferred, []{

std::this_thread::sleep_for(std::chrono::secodes(1));

})

future1.get();

future1.wait();

//共享 Future

std::shared_future f = std::async([]{});

auto f = async([]{}).share();

//异常

try {

int number = f.get();

} catch(const exception &e) {

cerr<<:get_id>

}

~~~


### 锁

~~~

std::mutex myMutex;

线程安全函数

int peopleNumber = 10;

int getPeopleNumber()

{

static std::mutex myMytex;

myMutex.lock();

++val;

myMutex.unlock();

}

//析构自动 释放 unlock

std::lock_guard<:mutex> lg(valMutex);

//递归锁 同一线程多次加锁

std::recursive_mutex recursive_mutex;

void firstMutex()

{

std::lock_guard<:recursive_mutex> lg_recursive_mutex(mutex);

}

void secondMutex()

{

std::lock_guard<:recursive_mutex> lg_recursive_mutex(mutex);

firstMutex();

}

// 析构自动 释放 unlock 但是可以临时加锁 解锁

std::unique_lock<:mutex> guard(_mu);

//do something 1

guard.unlock(); //临时解锁

//do something 2

guard.lock(); //继续上锁

std::lock(mutex1, mutex2) //阻塞等待

std::try_lock(mutex1, mutex2) // -1成功 否则返回失败锁的索引

~~~


### 条件变量

~~~

#include

#include

std::mutex readyMutex;

std::contition_variable readyCondVar;

//唤醒线程

readyCoundVar.notify_one();

readyCoundVar.notify_all();

//等待唤醒线程

std::unique_lock<:mutex> l(readyMutex);

readyCondVar.wait(l);

~~~


### 原子操作

~~~

#include

std::atomic readyFlag(false);

readyFlag.store(true) //赋值

readyFlag.load() //取值

~~~