泛型 前言 以前學習到「泛型」的時候，只是淺淺的知道可以限制類型，並沒有更深入理解，可以說基礎的也沒理解到位，只是浮於錶面，所以，現在回爐重造，重學泛型！打好基礎！ 什麼是泛型？ 泛型（Generic），Generic 的意思有「一般化的，通用的」。 是 JDK 5 中引入的新特性，它提供編譯時的類 ...
通過thread類編寫C++多線程程式
線程內容：
1、如何創建啟動一個線程？
std::thread定義一個線程對象，傳入線程所需的線程函數和參數，線程自動開啟
2、子線程如何結束？
子線程函數運行完成，線程就結束了
3、主線程如何處理子線程
t.join() : 等待t線程結束，當前線程繼續往下運行
t.detach() : 把t線程設置為分離線程，主線程結束，整個進程結束，所有子線程都自動結束
#include <thread>
void threadHandler1(int time){
std::this_thread::sleep_for(std::chrono::seconds(time));
std::cout<<"call thread1"<<std::endl;
}
void threadHandler2(int time){
std::this_thread::sleep_for(std::chrono::seconds(time));
std::cout<<"call thread2"<<std::endl;
}
int main(){
std::thread t1(threadHandler1,2);
std::thread t2(threadHandler2,3);
/*t1.join();
t2.join();*/
t1.detach();
t2.join();
std::cout<<"main thread done!"<<std::endl;
return 0;
}
/*
列印輸出：
call thread1
call thread2
main thread done!
*/
線程間的互斥鎖mutex和lock_guard
上鎖常用lock_guard，他是對mutex的封裝，出作用域後會自動析構，析構的時候會釋放鎖，構造函數會上鎖
普通的互斥鎖是：
std::mutex mtx;
mtx.lock();
//臨界區
mtx.unlock();
使用lock_guard是這樣：
{
std::lock_guard<std::mutex> lockGuard(mtx);//出作用域後會析構解鎖，預設構造是加鎖
//臨界區
}
互斥鎖的應用：
//模擬買票
int ticketCount=100000;
std::mutex mtx;
void sellTicket(int index){
while(ticketCount>0){//可能會發生提前進入迴圈的情況，所以需要在迴圈內再加一層判斷
// mtx.lock();
{//
std::lock_guard<std::mutex> lockGuard(mtx);//出作用域後會析構解鎖，預設構造是加鎖
if(ticketCount>0){
//下麵兩句屬於臨界區代碼，該代碼段中的操作必須是原子操作，要保證線程之間要互斥。
std::cout<<"視窗"<<index<<"賣出第"<<ticketCount<<"張票"<<std::endl;
ticketCount--;
}
}
// mtx.unlock();
}
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
int main(){
std::list<std::thread> threadList;
for(int i=1;i<=3;++i){
threadList.push_back(std::thread(sellTicket,i));
}
for(auto &th:threadList){
th.join();
}
std::cout<<"main thread done!"<<std::endl;
return 0;
}
線程間的同步通訊機制
生產者，消費者線程模型
C++ STl中的所有容器都不是線程安全的
使用條件變數condition_variable做線程間的通信操作
線程間同步通信最典型的例子就是生產者-消費者模型，生產者線程生產出產品以後，會通知消費者線程去消費產品；如果消費者線程去消費產品，發現還沒有產品生產出來，它需要通知生產者線程趕快生產產品，等生產者線程生產出產品以後，消費者線程才能繼續往下執行。
C++11 線程庫提供的條件變數condition_variable，就是Linux平臺下的Condition Variable機制，用於解決線程間的同步通信問題，下麵通過代碼演示一個生產者-消費者線程模型，仔細分析代碼：
// 定義互斥鎖(條件變數需要和互斥鎖一起使用)
std::mutex mtx;
// 定義條件變數(用來做線程間的同步通信)
std::condition_variable cv;
// 定義vector容器，作為生產者和消費者共用的容器
std::vector<int> vec;
// 生產者線程函數
void producer()
{
// 生產者每生產一個，就通知消費者消費一個
for (int i = 1; i <= 10; ++i)
{
// 獲取mtx互斥鎖資源
std::unique_lock<std::mutex> lock(mtx);
// 如果容器不為空，代表還有產品未消費，等待消費者線程消費完，再生產
while (!vec.empty())
{
// 判斷容器不為空，進入等待條件變數的狀態，釋放mtx鎖，
// 讓消費者線程搶到鎖能夠去消費產品
cv.wait(lock);
}
vec.push_back(i); // 表示生產者生產的產品序號i
std::cout << "producer生產產品:" << i << std::endl;
/*
* 容器為空，說明需要生產，生產完對其他線程進行通訊
生產者線程生產完產品，通知等待在cv條件變數上的消費者線程，
可以開始消費產品了，然後釋放鎖mtx
*/
cv.notify_all();
// 生產一個產品，睡眠100ms
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
// 消費者線程函數
void consumer()
{
// 消費者每消費一個，就通知生產者生產一個
for (int i = 1; i <= 10; ++i)
{
// 獲取mtx互斥鎖資源
std::unique_lock<std::mutex> lock(mtx);
// 如果容器為空，代表還有沒有產品可消費，等待生產者生產，再消費
while (vec.empty())
{
// 判斷容器為空，進入等待條件變數的狀態，釋放mtx鎖，
// 讓生產者線程搶到鎖能夠去生產產品
cv.wait(lock);//在等待過程中如果收到信息就會進入阻塞狀態，執行下一步操作
}
int data = vec.back(); // 表示消費者消費的產品序號i
vec.pop_back();
std::cout << "consumer消費產品:" << data << std::endl;
/*
消費者消費完產品，通知等待在cv條件變數上的生產者線程，
可以開始生產產品了，然後釋放鎖mtx
*/
cv.notify_all();
// 消費一個產品，睡眠100ms
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
int main()
{
// 創建生產者和消費者線程
std::thread t1(producer);
std::thread t2(consumer);
// main主線程等待所有子線程執行完
t1.join();
t2.join();
return 0;
}
再談lock_guard和unique_lock
互斥鎖只有一個線程可以拿到，其他線程如果試圖拿到被別的線程占用的互斥鎖的時候會進入阻塞狀態
std::lock_guard<std::mutex> lockGuard(mtx);不能用在函數參數傳遞或者返回過程中，只能用在簡單的臨界區代碼段的互斥操作中
unique_lock可以使用在簡單的臨界區代碼段的互斥操作中，也可以用在函數的調用過程中：
unque_lock<std::mutex> lck(mtx);
cv.wait(lck);//cv是condition_variable wait方法會先使線程進入等待狀態，然後調用lck.unlock()方法把mtx釋放掉。
cv.notify_all()是通知在cv上等待的線程條件成立了該幹活了，收到通知的線程會先從等待狀態切換到阻塞狀態，如果獲取到互斥鎖那麼該線程就會繼續執行。
基於CAS操作的atomic原子類型
首先要包含atomic類庫
一般在++等簡單操作中使用無鎖操作（CAS）來實現
//原子整型，CAS操作保證給count自增自減的原子操作
std::atomic_int mycount(0);
//線程函數
void sumTask()
{
//每個線程給count加1000次
for (int i = 0; i < 1000; ++i)
{
mycount++;
}
}
int main()
{
//創建10個線程放在容器當中
std::vector<std::thread> vec;
for (int i = 0; i < 10; ++i)
{
vec.push_back(std::thread(sumTask));
}
//等待線程執行完成
for (unsigned int i = 0; i < vec.size(); ++i)
{
vec[i].join();
}
//所有子線程運行結束，count的結果每次運行應該都是10000
std::cout << "count : " << mycount << std::endl;
return 0;
}
