2. 程式人生 > >c++11 多執行緒入門教程（一）

c++11 多執行緒入門教程（一）

阿新 • • 發佈：2019-05-29

　

原文作者：aircraft

原文連結：https://www.cnblogs.com/DOMLX/p/10945309.html

　　　　

 

　　　　　　最近是恰好寫了一些c++11多執行緒有關的東西，就寫一下筆記留著以後自己忘記回來看吧，也不是專門寫給讀者看的，我就想到哪就寫到哪吧

 

　　c++11呢，就是c++升級之後的一個版本，現在馬上就出c++20了，裡面增加了很多對多執行緒支援的類，讓多執行緒程式設計更加簡單了，好了廢話不多說，先來建立一個簡單的多執行緒程式設計案例，看看c++11下多執行緒程式設計建立到底有多麼的簡單。

 

1.建立一個簡單的多執行緒案例：

首先匯入#include<thread>---用於建立執行緒

其次匯入#include<chrono>--用於時間延時 獲取時間之類的

定義一個執行緒物件t1，這就自動建立了一個執行緒，引數就是你要執行緒去執行的函式，t1是變數名字 隨便取

std::thread t1(func);

下面這裡返回一個毫秒級別的時間間隔引數值，間隔10毫秒 

std::chrono::milliseconds(10)

this_thread::sleep_for（）就是讓此執行緒休眠，可以傳入休眠的時間

this_thread::sleep_for(std::chrono::milliseconds(10));讓本執行緒休眠10毫秒

 

好了知道這些引數意思就行了，看一下程式碼：

#include<windows.h>
#include <iostream>
#include <chrono>
#include <thread>
using namespace std;

int number = 1;

int ThreadProc1()
{
    while (number < 100)
    {
        cout << "thread 1 :" << number << endl;
        ++number;
       this_thread::sleep_for(std::chrono::milliseconds(10));
    }

    return 0;
}

int ThreadProc2()
{
    while (number < 100)
    {
        cout << "thread 2 :" << number << endl;
        ++number;
        this_thread::sleep_for(std::chrono::milliseconds(10));
    }

    return 0;
}

int main()
{
    thread t1(ThreadProc1);
    thread t2(ThreadProc2);

    t1.join();
    t2.join();

    system("pause");
    return 0;
}

　　join()就是阻塞執行緒，直到執行緒函式執行完畢，如果函式有返回值，在這裡會直接忽略。阻塞的目的就是讓Main主執行緒等待一下建立的執行緒，免得我函式還在跑，程式就直接結束了。

　　如果不想阻塞在這裡就將join()換成使用執行緒的detach()方法，將執行緒與執行緒物件分離，執行緒就可以繼續執行下去，並且不會造成影響。

　　從示例可以看到c++11下建立多執行緒多麼方便了吧 ，比在Linux下用posix建立還簡便，而這個也是可以在windows使用的（想想windows下多執行緒的程式碼,看著都頭疼好吧，亂七八糟一大堆）。

 

2.互斥量的使用

　　跟往常的多執行緒一樣，多執行緒在執行過程中都會對臨界區進行訪問，也就是一起訪問共享資源。這樣就會造成一個問題，當兩個執行緒都要對一個變數int value值假如為11，加一時，執行緒一取出11 進行加一還沒有存入value,這時候執行緒二又取得value的11進行加一，然後執行緒一存入12，執行緒二又存入12，這就匯入兩個執行緒訪問衝突，也就是臨界區問題。所以引進互斥量來解決。

匯入#include <mutex>

程式碼案例：

一個執行緒對變數number進行加一100次，另外一個減一100次，最後結果應該還是原來的值0。

 

#include<windows.h>
#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
using namespace std;

int number = 0;
mutex g_lock;

int ThreadProc1()
{
    
    for (int i = 0; i < 100; i++)
    {
        g_lock.lock();
        ++number;
        cout << "thread 1 :" << number << endl;
        g_lock.unlock();
        this_thread::sleep_for(std::chrono::milliseconds(10));
    }
    
    return 0;
}

int ThreadProc2()
{
    
    for (int i = 0; i < 100; i++)
    {
        g_lock.lock();
        --number;
        cout << "thread 2 :" << number << endl;
        g_lock.unlock();
        this_thread::sleep_for(std::chrono::milliseconds(10));
    }
    
    return 0;
}

int main()
{
    thread t1(ThreadProc1);
    thread t2(ThreadProc2);

    t1.detach();
    t2.detach();

    system("pause");
    return 0;
}

 

 

上面的每次都要對mutex變數進行鎖以及解鎖，有時候忘記解鎖就涼涼了。所以c++11還提供了一個lock_guard類，它利用了RAII機制可以保證安全釋放mutex。

在std::lock_guard物件構造時，傳入的mutex物件(即它所管理的mutex物件)會被當前執行緒鎖住。在lock_guard物件被析構時，它所管理的mutex物件會自動解鎖，不需要程式設計師手動呼叫lock和unlock對mutex進行上鎖和解鎖操作。lock_guard物件並不負責管理mutex物件的生命週期，lock_guard物件只是簡化了mutex物件的上鎖和解鎖操作，方便執行緒對互斥量上鎖，即在某個lock_guard物件的生命週期內，它所管理的鎖物件會一直保持上鎖狀態；而lock_guard的生命週期結束之後，它所管理的鎖物件會被解鎖。程式設計師可以非常方便地使用lock_guard，而不用擔心異常安全問題。

程式碼：

 

#include<windows.h>
#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
using namespace std;

int number = 0;
mutex g_lock;

int ThreadProc1()
{
    lock_guard<mutex> loker(mutex);
    for (int i = 0; i < 100; i++)
    {
        ++number;
        cout << "thread 1 :" << number << endl;
        
    }
    //this_thread::sleep_for(std::chrono::milliseconds(100));
    return 0;
}

int ThreadProc2()
{
    lock_guard<mutex> loker(mutex);
    for (int i = 0; i < 100; i++)
    {
        --number;
        cout << "thread 2 :" << number << endl;
        //this_thread::sleep_for(std::chrono::milliseconds(10));
    }
    
    return 0;
}

int main()
{
    thread t1(ThreadProc1);
    thread t2(ThreadProc2);

    t1.detach();
    t2.detach();

    system("pause");
    return 0;
}

 

除了lock_guard，之外c++11還提供了std::unique_lock

類 unique_lock 是通用互斥包裝器，允許延遲鎖定、鎖定的有時限嘗試、遞迴鎖定、所有權轉移和與條件變數一同使用。
unique_lock比lock_guard使用更加靈活，功能更加強大。
使用unique_lock需要付出更多的時間、效能成本。

#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex, std::unique_lock
#include <vector>

std::mutex mtx;           // mutex for critical section
std::once_flag flag;        //定義一個once_flag型別的變數作為call_once引數，    
                                    //用std::call_once來保證多執行緒環境中只被呼叫一次
void print_block (int n, char c) {
    //unique_lock有多組建構函式, 這裡std::defer_lock不設定鎖狀態
    std::unique_lock<std::mutex> my_lock (mtx, std::defer_lock);
    //嘗試加鎖, 如果加鎖成功則執行
    //(適合定時執行一個job的場景, 一個執行緒執行就可以, 可以用更新時間戳輔助)
    if(my_lock.try_lock()){
        for (int i=0; i<n; ++i)
            std::cout << c;
        std::cout << '\n';
    }
}

void run_one(int &n){
    std::call_once(flag, [&n]{n=n+1;}); //只執行一次, 適合延遲載入; 多執行緒static變數情況
}

int main () {
    std::vector<std::thread> ver;
    int num = 0;
    for (auto i = 0; i < 10; ++i){
        ver.emplace_back(print_block,50,'*');  
        ver.emplace_back(run_one, std::ref(num));
  //emplace_back比push_back更好 是c++11增加的
    }

    for (auto &t : ver){
        t.join();
    }
    std::cout << num << std::endl;
    return 0;
}

 　

　這裡還要補充一下跟互斥量很像的條件變數的知識。

條件變數std::condition_variable的使用

　　std::condition_variable 是為了解決死鎖而生的。當互斥操作不夠用而引入的。比如，執行緒可能需要等待某個條件為真才能繼續執行，而一個忙等待迴圈中可能會導致所有其他執行緒都無法進入臨界區使得條件為真時，就會發生死鎖。所以，condition_variable例項被創建出現主要就是用於喚醒等待執行緒從而避免死鎖。std::condition_variable的 notify_one()用於喚醒一個執行緒；notify_all() 則是通知所有執行緒。
C++11中的std::condition_variable就像Linux下使用pthread_cond_wait和pthread_cond_signal一樣，可以讓執行緒休眠，直到別喚醒，現在在從新執行。執行緒等待在多執行緒程式設計中使用非常頻繁，經常需要等待一些非同步執行的條件的返回結果。
示例程式碼：

#include<iostream>
#include<thread>
#include<condition_variable>
#include<mutex>
#include<chrono>


std::mutex g_mu;
std::condition_variable g_vc;
bool g_ready = false;

void dispaly_id(int id)
{
    std::unique_lock<std::mutex> lck(g_mu);
    g_vc.wait(lck, []() {return g_ready; });   //執行緒阻塞，直到第二個引數返回值為真

    std::cout << "id:" << id << std::endl;
}

void ready()
{
    std::unique_lock<std::mutex> lck(g_mu);
    g_ready = true;
    g_vc.notify_all();    //喚醒所有的等待執行緒
}

int main()
{
    std::thread t[8];
    for (int i = 0; i < 8; i++)
    {
        t[i] = std::thread(dispaly_id, i);
    }
    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout << "all thread lock......" << std::endl;
    
    ready();
    for (auto & th : t) th.join();

    system("pause");

    return 0;
}

 

 

3.原子變數的使用

　　在新標準C++11，引入了原子操作的概念，原子操作更接近核心，並通過這個新的標頭檔案提供了多種原子操作資料型別，例如，atomic_bool,atomic_int等等，如果我們在多個執行緒中對這些型別的共享資源進行操作，編譯器將保證這些操作都是原子性的，也就是說，確保任意時刻只有一個執行緒對這個資源進行訪問，編譯器將保證，多個執行緒訪問這個共享資源的正確性。從而避免了鎖的使用，提高了效率。

　　上面我們用互斥鎖來實現加一百次，減少一百次。使用原子變數會更加簡潔。

 

#include<windows.h>
#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <atomic>
using namespace std;

atomic<int> number(0);//定義原子變數 一次只允許一個執行緒對其進行訪問
//int number = 0;
//mutex g_lock;

int ThreadProc1()
{
    //lock_guard<mutex> loker(mutex);
    for (int i = 0; i < 100; i++)
    {
        ++number;
        cout << "thread 1 :" << number << endl;
        
    }
    //this_thread::sleep_for(std::chrono::milliseconds(100));
    return 0;
}

int ThreadProc2()
{
    //lock_guard<mutex> loker(mutex);
    for (int i = 0; i < 100; i++)
    {
        --number;
        cout << "thread 2 :" << number << endl;
        //this_thread::sleep_for(std::chrono::milliseconds(10));
    }
    
    return 0;
}

int main()
{
    thread t1(ThreadProc1);
    thread t2(ThreadProc2);

    t1.detach();
    t2.detach();

    system("pause");
    return 0;
}

 

可以看到使用了原子變數之後，程式碼簡化了很多，以及以後對某些共享資源我們都可以酌情的定義為原子變數型別，很方便有木有。。。。。

 

 4.future與promise的使用

　　在c++11中增加的執行緒庫很方便的讓我們去使用執行緒，但是因為做出了一些改變，我們並不能像往常一樣直接使用thread.join()獲取執行緒函式的返回值了，而我們有時候又確實要利用執行緒函式的返回值。

　　而thread庫提供了future用來訪問非同步操作的結果，因為一個非同步操作的結果往往不能立即獲取，只能在未來的某個時候從某個地方獲取，這個非同步操作的結果是一個未來的期待值，所以被稱為future

　　future和promise的作用是在不同執行緒之間傳遞資料。

假設執行緒1需要執行緒2的資料，那麼組合使用方式如下：

  1.     執行緒1初始化一個promise物件和一個future物件，promise傳遞給執行緒2，相當於執行緒2對執行緒1的一個承諾；future相當於一個接受一個承諾，用來獲取未來執行緒2傳遞的值
  2.     執行緒2獲取到promise後，需要對這個promise傳遞有關的資料，之後執行緒1的future就可以獲取資料了。
  3.     如果執行緒1想要獲取資料，而執行緒2未給出資料，則執行緒1阻塞，直到執行緒2的資料到達

示例程式碼：

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <atomic>
#include <future>
#include <vector>

void disPlay(std::future<int>& value)
{
    std::cout << "wait some times......" << std::endl;
    auto result = value.get();    //沒有獲取到值會阻塞等待獲取
    std::cout << "Value:" << result << std::endl;
}


int main()
{
    std::promise<int> promise;    
    std::future<int> value = promise.get_future(); //將promise與future繫結
    
    std::thread t1(disPlay, std::ref(value));  //建立執行緒並且函式傳參，ref()是傳一個引用
    std::this_thread::sleep_for(std::chrono::seconds(1)); //執行緒延時1秒

    //給執行緒傳值進去
    promise.set_value(15);
    t1.join();
    
    
    system("pause");

    return 0;
}

　　獲取future的結果有三種方式上面是get()獲取非同步結果值返回，還有wait()等待非同步操作完成，以及wait_for（）超時等待返回結果。

 

 5.future與package_task的使用

　　std::packaged_task包裝一個可呼叫的物件，並且允許非同步獲取該可呼叫物件產生的結果。
std::packaged_task將其包裝的可呼叫物件的執行結果傳遞給一個std::future物件，與std::promise某種程度上是很像的，promise儲存一個共享狀態的值，而package_task儲存的是一個函式。

 

示例程式碼：

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <atomic>
#include <future>
#include <vector>

inline int func(int x)
{
    return x + 6;
}

int main()
{
    std::packaged_task<int(int)> tsk(func);
    std::future<int> fut = tsk.get_future(); //獲取future繫結起來
    
    std::thread(std::move(tsk), 2).detach();//直接將task轉移作為執行緒函式使用

    auto value = fut.get();
    std::cout << "result:" << value << std::endl;
    
    system("pause");

    return 0;
}

 

 6.執行緒非同步操作函式async的用法

　　，std::async比std::packaged_task，std::promise中，std::thread更高一層，它可以直接用來建立非同步的task，非同步的結果也儲存在future中。完成後，外面再通過future.get/wait來獲取這個未來的結果，強烈推薦使用async，我們不需要關注非同步任務的結果，只要等待任務完成獲取值就行了。

　　現在來看看std::async的原型async(std::launch::async | std::launch::deferred, f, args...)，第一個引數是執行緒的建立策略，有兩種策略，預設的策略是立即建立執行緒：

 

  • std::launch::async：在呼叫async就開始建立執行緒。
  • std::launch::deferred：延遲載入方式建立執行緒。呼叫async時不建立執行緒，直到呼叫了future的get或者wait時才建立執行緒。

 

第二個引數是執行緒函式，第三個引數是執行緒函式的引數。

程式碼示例：

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <atomic>
#include <future>
#include <vector>


int main()
{
    std::future<int> fut = std::async(std::launch::async, []() {
        return 9;
    });
    
    std::cout << "result:" << fut.get() << std::endl;
    system("pause");

    return 0;
}

　　[]()這是c++11裡面lambda表示式用法

 

7.std::future::wait_for（）函式作用

　　函式原型：

template< class Rep, class Period >
std::future_status wait_for( const std::chrono::duration<Rep,Period>& timeout_duration ) const;  

　　等待結果變得可用。阻塞直至經過指定的 timeout_duration ，或結果變為可用，兩者的先到來者。返回值鑑別結果的狀態。

此函式可能由於排程或資源爭議延遲而阻塞長於 timeout_duration 。

推薦標準庫用穩定時鐘度量時長。若實現用系統時鐘代替，則等待時間可能也對時鐘調整敏感。

若呼叫此函式前 valid()== false 則行為未定義。

引數

timeout_duration - 要阻塞的最大時長

返回值

 
常量 解釋
future_status::deferred 要計算結果的函式仍未啟動
future_status::ready 結果就緒
future_status::timeout 已經過時限

異常

時鐘、時間點或時長在執行中可能拋的任何異常（標準庫提供的時鐘、時間點和時長決不丟擲）。

注意

鼓勵實現在呼叫前檢測 valid == false 的情況並丟擲以 future_errc::no_state 為 error_condition 的 future_error

 

程式碼示例：

#include <iostream>
#include <future>
#include <thread>
#include <chrono>
 
int main()
{
    std::future<int> future = std::async(std::launch::async, [](){ 
        std::this_thread::sleep_for(std::chrono::seconds(3));
        return 8;  
    }); 
 
    std::cout << "waiting...\n";
    std::future_status status;
    do {
        status = future.wait_for(std::chrono::seconds(1));
        if (status == std::future_status::deferred) {
            std::cout << "deferred\n";
        } else if (status == std::future_status::timeout) {
            std::cout << "timeout\n";
        } else if (status == std::future_status::ready) {
            std::cout << "ready!\n";
        }
    } while (status != std::future_status::ready); 
 
    std::cout << "result is " << future.get() << '\n';
}

可能結果：

waiting...
timeout
timeout
ready!
result is 8

 

後面還會出很多一系列的入門教程，可以關注我噢。。。。。hhhhhhhh

 

也可以補一下基礎多執行緒程式設計教程如下：

c++ 網路程式設計課設入門超詳細教程 ---目

相關推薦

c++11 多執行緒入門教程（一）

　 原文作者：aircraft 原文連結：https://www.cnblogs.com/DOMLX/p/10945309.html 　　　　   　　　　　　最近是恰好寫了一些c++11多執行緒有關的東西，就寫一下筆記留著以後自己忘記回來看吧，也不是專門寫給讀者看的，我就想到哪就寫到哪吧

c++11多執行緒詳解（一）

　 原文作者：aircraft 原文連結：https://www.cnblogs.com/DOMLX/p/10914162.html 　　　　   　　　　　　最近是恰好寫了一些c++11多執行緒有關的東西，就寫一下筆記留著以後自己忘記回來看吧，也不是專門寫給讀者看的，我就想到哪就寫到哪吧 &nbs

C++11多執行緒程式設計系列（二）實戰

C++11 新標準中引入了多個頭檔案來支援多執行緒程式設計，他們分別是<atomic> ,<thread>,<mutex>,<condition_variable>和<future>。 <

用C++實現多執行緒Mutex鎖（Win32）

    本文目的：用C++和Windows的互斥物件（Mutex）來實現執行緒同步鎖。     準備知識：1，核心物件互斥體（Mutex）的工作機理，WaitForSingleObject函式的用法，這些可以從MSDN獲取詳情； 2，當兩個或更多執行緒需要同時訪問一個共享資

c++多執行緒重點難點（一）interlocked系列原子操作

_beginthreadex()函式在建立新執行緒時會分配並初始化一個_tiddata塊。這個_tiddata塊自然是用來存放一些需要執行緒獨享的資料。事實上新執行緒執行時會首先將_tiddata塊與自己進一步關聯起來。然後新執行緒呼叫標準C執行庫函式如st

多執行緒詳解（一）

[多執行緒詳解（一）](http://www.neilx.com) 一、概念準備 1、程序 (1）直譯：正在進行中的程式 (2)解釋：執行一個程式時，會在記憶體中為程式開闢空間，這個空間就是一個程序。 (3)注意：一個程序中不可能沒有執行緒，只有有了執行緒才能執行; 程序只

多執行緒學習總結（一）

一、程序和執行緒的定義 程序：程序是資源（CPU、記憶體等）分配的基本單位，它是程式執行時的一個例項。程式執行時系統就會建立一個程序，併為它分配資源，然後把該程序放入程序就緒佇列，程序排程器選中它的時候就會為它分配CPU時間，程式開始真正執行。 執行緒：執行緒是程式執行時的最小單位，它是程序

Java多執行緒-基礎篇（一）

多執行緒---基礎篇，本文主要針對多執行緒的基礎進行復習，內容包括執行緒的理解，建立方式，Thread類函式理解； 1、執行緒的理解：OS系統角度：每個執行的程式都會被作業系統建立對應的程序（包括分配的資源、PCB等），程序是作業系統分配資源的基本單位（理解：程式執行需要空間，作業系統建立對應程序時

Java面向物件與多執行緒綜合實驗（一）之封裝、繼承與多型

編寫一個程式，實現檔案管理系統中的使用者管理模組。要求模組中實現使用者的模擬登入過程。通過使用者輸入，獲取使用者名稱和口令；與事先記錄在程式中的使用者資訊進行對比，通過口令驗證後才能使用系統。使用者分為系統管理人員、檔案錄入人員，檔案瀏覽人員三類，相關類圖如下所示。 （1）要求在使用者類中

多執行緒學習筆記（一）

一. 新建執行緒（兩種方法） 第一種：繼承Thread 1.定義一個類繼承Thread 2.該類重寫run方法。其中的getName是獲取執行緒名方法；有參構造可以在新建時指定執行緒名 3.建立子類物件就是建立新執行緒 4.子類物件呼叫start方法 ，開啟執行

Java多執行緒學習筆記（一）之中斷中的Interrupt，interrupted()，isInterrupted()

1、關於中斷 在Java中中斷最初是通過stop()來終止執行緒的，後來發現這樣簡單粗暴的停止執行緒會產生很多問題（例如物件monitor的釋放），所以改為deprecated，推薦使用interrupt()來中斷執行緒。而對於執行緒來說，會持有一個inter

Java多執行緒與併發（一）

多執行緒與併發的基礎問題 併發就是指程式同時處理多個任務的能力（一個程式被多個使用者訪問都能看到自己預期的結果） 併發的根源在於對多工情況下訪問資源的有效控制！ 併發背後的問題 public class DownloadSimple {

Java多執行緒乾貨系列—（一）Java多執行緒基礎

多執行緒併發程式設計是Java程式設計中重要的一塊內容，也是面試重點覆蓋區域，所以學好多執行緒併發程式設計對我們來說極其重要，下面跟我一起開啟本次的學習之旅吧。 正文 執行緒與程序 1 執行緒：程序中負責程式執行的執行單元 執行緒本身依靠程式進行執行 執行緒是程式中的順序控制流，只能使用分配給程式的資源和環

多執行緒基礎知識（一） 執行緒的概念及建立任務與執行緒

執行緒的概念及建立任務與執行緒 引言 多執行緒使得程式中的多個任務可以同時執行。 java的重要功能之一就是內部支援多執行緒————在一個程式中運行同時執行多個任務。在許多程式設計語言中，多執行緒都是通過呼叫依賴於系統的過程或函式來實現的。在本文中，將介紹執行緒的該

Java多執行緒--Monitor物件（一）

1. 什麼是Monitor？     Monitor其實是一種同步工具，也可以說是一種同步機制，它通常被描述為一個物件，主要特點是： 物件的所有方法都被“互斥”的執行。好比一個Monitor只有一個執行“許可”，任一個執行緒進入任何一個方法都需要獲得這個“許可”，離開時

【JAVA秒會技術之玩轉多執行緒】多執行緒那些事兒（一）

多執行緒那些事兒（一） 現在只要出去面試，關於“Java多執行緒”的問題，幾乎沒有一家單位不問的，可見其重要性。於是博主抽空研究了一下，確實很有意思！以下是我綜合整理了網上的各種資料，和個人的一些理解，寫的一篇總結博文，僅供學習、交流。 （一）多執行緒的概念      

Qt多執行緒程式設計總結（一）

Qt對執行緒提供了支援，基本形式有獨立於平臺的執行緒類、執行緒安全方式的事件傳遞和一個全域性Qt庫互斥量允許你可以從不同的執行緒呼叫Qt方法。 這個文件是提供給那些對多執行緒程式設計有豐富的知識和經驗的聽眾的。推薦閱讀： 警告：所有的GUI類（比如，QWidget和它的

Qt多執行緒程式設計總結（一）（所有GUI物件都是執行緒不安全的）

Qt對執行緒提供了支援，基本形式有獨立於平臺的執行緒類、執行緒安全方式的事件傳遞和一個全域性Qt庫互斥量允許你可以從不同的執行緒呼叫Qt方法。 這個文件是提供給那些對多執行緒程式設計有豐富的知識和經驗的聽眾的。推薦閱讀： 警告：所有的GUI類（比如，QWidget和它的子類），作業系統核心類（比如，QPr

對於java多執行緒的理解（一）

解釋：程序的顆粒度太大，每次都要有上下的調入，儲存，調出。如果我們把程序比喻為一個執行在電腦上的軟體，那麼一個軟體的執行不可能是一條邏輯執行的，必定有多個分支和多個程式段，就好比要實現程式A，實際分成 a，b，c等多個塊組合而成。那麼這裡具體的執行就可能變成：程式A得到CPU =》CPU載入上下文，開始執行程

Linux執行緒入門學習（一）-認識執行緒

1. 執行緒的概念 執行緒，又稱輕量級程序，是程序中執行運算的最小單位，是程序中的一個實體，是被系統獨立排程和分派的基本單位，主要有以下特點： 1）執行緒自己不擁有系統資源，只擁有一點在執行中必不可少的資源； 2）與同屬一個程序的其它執行緒共享程序所擁有的全