c 11 多執行緒

c++11中增加了執行緒以及執行緒相關的類，很方便的支援了併發程式設計。

1. 執行緒

執行緒建立

#includevoid func(int a)
int main()

可以通過std::bind或lambda表示式來建立執行緒：

void func(int a,int b)
int main(), 1,2);
return 0;
}

join 和 detach

int main()

執行緒生命期

#includevoid func()
int main()//執行緒被移動(std::move)後，執行緒物件t就不代表任何執行緒了。

執行緒基本用法

void func()
int main()

2. 執行緒休眠

void f()

2. 互斥量

std::mutex

std::mutex g_lock;
void func()

std::recursive_mutex

std::timed_mutex

std::time_mutex mut;
void work()else
}}

lock_guard

std::mutex mut;
void func()

3. 條件變數

void put(const t& x)
m_queue.push_back(x);
m_notempty.notify_one();
}void take(t& x)
x = m_queue.front();
m_queue.pop_front();
m_notfull.notify_one();
}std::listm_queue;
std::mutex m_mutex;
std::condition_variable_any m_notempty;
std::condition_variable_any m_notfull;

4. 原子變數

c++11提供了乙個原子型別 std::atomic< t>，可以使用任意型別作為模板引數，c++11內建了整型的原子變數，可以更方便的使用原子變數，使用原子變數就不需要使用互斥量來保護該變數了。

#includestruct atomiccounter
void dec()
int get()
};

5. call_once/once_flag使用

為了保證在多執行緒環境中某個函式僅被呼叫一次，或者某個變數僅僅被初始化一次，可以使用 std::call_once來保證函式在多執行緒環境中只被呼叫一次。使用std::call_once時，需要乙個once_flag作為call_once的入參。

std::once_flag flag;
void do_once());
}

6. 非同步操作

c++11中提供了非同步操作相關的類，主要有 std::future, std::promise, std::package_task. std::future 作為非同步結果的傳輸通道，很方便的獲取執行緒函式的返回值； std::promise用來包裝乙個值，將資料和future繫結起來，方便執行緒賦值；std::package_task用來包裝乙個可呼叫物件，將函式和future幫頂起來，以便非同步呼叫。

std::future 獲取執行緒函式返回值

std::future_status st;
doelse if(st == std::future_status::timeout)else if(st == std::future_status::ready)
}while(st != std::future_status::ready);

獲得future結果的三種方式： get, wait, wait_for，其中get等待非同步操作的結果並返回結果；wait只是等待非同步操作完成，沒有返回值；wait_for是超時等待返回的結果。

std::promise 協助執行緒賦值的類

std::promisepr;
std::thread t((std::promise& p)
std::ref(pr)); //執行緒函式的引數，使用引用
std::futuref = pr.get_future(); //獲取promise的future
auto r = f.get(); //利用get等待非同步操作的結果（阻塞）

std::packaged_task 可呼叫物件的包裝類

std::packaged_tasktask();
std::thread t1(std::ref(task));
std::futuref1 = task.get_future();
auto r1 = f1.get();

std::promise, std::packaged_task, std::future三者之間的關係

#include#include#include#include#includeint func(int x)
int main(), 2, 3);
v.push_back(f);
std::cout << "the shared future result is " << v[0].get() << "\n";
return 0;
}

std::async 執行緒非同步操作函式

#include#include#include#includeint main());
std::cout << f1.get() << std::endl;
std::futuref2 = std::async(std::launch::async, ());
f2.wait();
std::futurefuture = std::async(std::launch::async, ());
std::cout << "waiting ... " << std::endl;
std::future_status status;
doelse if(status == std::future_status::timeout)
else if (status == std::future_status::ready)
} while (status != std::future_status::ready);
std::cout << "result is " << future.get() << std::endl;
return 0;
}

c 11 多執行緒

C 11 多執行緒

c 11 多執行緒

C 11 多執行緒

c 11 多執行緒

C 11 多執行緒

c 11 多執行緒

C 11 多執行緒

相關推薦