前端項目編譯如何使用多線程

1. C++如何實現多線程

（1）Windows下使用CreateThread（_beginthread底層也是用這個API實現的）
（2）Linux下使用pthread_create
(3)C++0x中在tr1中增加了一個<thread>起多線程，不清楚最新版的gcc是不是已經增加了，VS2010還不支持

2. TC(c語言)中的多線程

可以不用。用C語言的計數器就好，不過比較麻煩。。。

如果用多線程，你首先需要了解線程的含義，另外編譯的時候需要加參數，
編程的部分比較簡單，頭文件需要：
#include <process.h>
然後創建線程使用函數：
_beginthread()
銷毀線程函數：
_endthread()

TC3.0也就是增加了個滑鼠，修改了一些bug，更新了一下界面而已，編譯器是和2.0一樣的。

3. 為什麼有時編譯選項要改成多線程才能編譯通過，而 單線程就不行呢

主要是libc（C函數）庫不同，有時鏈接時會看到libcd.lib/libc.lib/libcmt.lib...這些東東，就是針對不同的線程環境所使用的。不過在VS2005之後，不再使用單線程庫了，它只使用libc*mt.lib，也就是有很多老程序代碼在VS2005下找不到LIBCD.lib的原因。
如果你在程序中使用了_beginthread之類的函數，那麼就會鏈接到多線程的c函數庫，單線程選項當然不能使用了。
而使用FORCE:MUTIPLE和這個沒有多大關系，它可能在同時使用了單線程庫和多線程庫時起到了忽略多個重疊符號錯誤的作用。

4. 如何利用多線程，實現處理圖像的同時，實時感應滑鼠的移動，求c語言源代碼！

你這個問題可是超過200分的啊，
這個往大了說是一個比較復雜的設計方案。

實際上C語言是沒有多線程的概念的，但是我們可以通過Task來實現多任務。

簡單的說，可以採取以下方案：
定義一個主Task，將其置為常駐Task,用以進行Task調度和Task的啟動/終了和交互的管理。
定義一個Task優先順序列表，用優先順序來作為Task調度和管理的基礎。
定義一個共享域，和相應的事件分發/廣播/傳遞的管理機制，由主Task來實現各Task間的事件傳遞。
定義3個List，實現Active,Ready,Dead的Task的管理和調度。
定義各普通Task，包含Task基本信息：Task的棧指針，Task情報，Task存儲空間大小，Task的優先順序，Task的事件列表(定義可以接收/發送的事件，以及可以排隊的事件的個數)，以及如果需要的話可以定義Task的從屬(父子)關系。

另外還有幾個注意點：
1. 通過C的臨界域(critical section)結合PV操作來實現某些Task的原子性處理要求。
2. 通過Signal來實現中斷和再開
3. 如果需要處理中斷和再開的話，一定要注意現場保護
4. 同優先順序的Task可以通過時間片輪循的方式進行多任務實現

暫時就想到這么多，有不明白的通過消息進一步交流吧：）

5. Thread子類是如何實現多線程機制的

來自：開發者在線
java多線程程序設計詳細解析

一、理解多線程

多線程是這樣一種機制，它允許在程序中並發執行多個指令流，每個指令流都稱為一個線程，彼此間互相獨立。

線程又稱為輕量級進程，它和進程一樣擁有獨立的執行控制，由操作系統負責調度，區別在於線程沒有獨立的存儲空間，而是和所屬進程中的其它線程共享一個存儲空間，這使得線程間的通信遠較進程簡單。

多個線程的執行是並發的，也就是在邏輯上「同時」，而不管是否是物理上的「同時」。如果系統只有一個CPU，那麼真正的「同時」是不可能的，但是由於CPU的速度非常快，用戶感覺不到其中的區別，因此我們也不用關心它，只需要設想各個線程是同時執行即可。

多線程和傳統的單線程在程序設計上最大的區別在於，由於各個線程的控制流彼此獨立，使得各個線程之間的代碼是亂序執行的，由此帶來的線程調度，同步等問題，將在以後探討。

二：在Java中實現多線程

我們不妨設想，為了創建一個新的線程，我們需要做些什麼？很顯然，我們必須指明這個線程所要執行的代碼，而這就是在Java中實現多線程我們所需要做的一切！

真是神奇！Java是如何做到這一點的？通過類！作為一個完全面向對象的語言，Java提供了類java.lang.Thread來方便多線程編程，這個類提供了大量的方法來方便我們控制自己的各個線程，我們以後的討論都將圍繞這個類進行。

那麼如何提供給 Java 我們要線程執行的代碼呢？讓我們來看一看 Thread 類。Thread 類最重要的方法是run()，它為Thread類的方法start()所調用，提供我們的線程所要執行的代碼。為了指定我們自己的代碼，只需要覆蓋它！

方法一：繼承 Thread 類，覆蓋方法 run()，我們在創建的 Thread 類的子類中重寫 run() ,加入線程所要執行的代碼即可。下面是一個例子：

public class MyThread extends Thread
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println
("創建線程 " + number);
}
public void run() {
while(true) {
System.out.println
("線程 " + number + ":計數 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0;
i 〈 5; i++) new MyThread(i+1).start();
}
}

這種方法簡單明了，符合大家的習慣，但是，它也有一個很大的缺點，那就是如果我們的類已經從一個類繼承（如小程序必須繼承自 Applet 類），則無法再繼承 Thread 類，這時如果我們又不想建立一個新的類，應該怎麼辦呢？

我們不妨來探索一種新的方法：我們不創建Thread類的子類，而是直接使用它，那麼我們只能將我們的方法作為參數傳遞給 Thread 類的實例，有點類似回調函數。但是 Java 沒有指針，我們只能傳遞一個包含這個方法的類的實例。

那麼如何限制這個類必須包含這一方法呢？當然是使用介面！（雖然抽象類也可滿足，但是需要繼承，而我們之所以要採用這種新方法，不就是為了避免繼承帶來的限制嗎？）

Java 提供了介面 java.lang.Runnable 來支持這種方法。

方法二：實現 Runnable 介面

Runnable介面只有一個方法run()，我們聲明自己的類實現Runnable介面並提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務。但是Runnable介面並沒有任何對線程的支持，我們還必須創建Thread類的實例，這一點通過Thread類的構造函數public Thread(Runnable target);來實現。下面是一個例子：

public class MyThread implements Runnable
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println("創建線程 " + number);
}
public void run()
{
while(true)
{
System.out.println
("線程 " + number + ":計數 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0; i 〈 5;
i++) new Thread(new MyThread(i+1)).start();
}
}

嚴格地說，創建Thread子類的實例也是可行的，但是必須注意的是，該子類必須沒有覆蓋 Thread 類的 run 方法，否則該線程執行的將是子類的 run 方法，而不是我們用以實現Runnable 介面的類的 run 方法，對此大家不妨試驗一下。

使用 Runnable 介面來實現多線程使得我們能夠在一個類中包容所有的代碼，有利於封裝，它的缺點在於，我們只能使用一套代碼，若想創建多個線程並使各個線程執行不同的代碼，則仍必須額外創建類，如果這樣的話，在大多數情況下也許還不如直接用多個類分別繼承 Thread 來得緊湊。

綜上所述，兩種方法各有千秋，大家可以靈活運用。

下面讓我們一起來研究一下多線程使用中的一些問題。

三、線程的四種狀態

1. 新狀態：線程已被創建但尚未執行（start() 尚未被調用）。

2. 可執行狀態：線程可以執行，雖然不一定正在執行。CPU 時間隨時可能被分配給該線程，從而使得它執行。

3. 死亡狀態：正常情況下 run() 返回使得線程死亡。調用 stop()或 destroy() 亦有同樣效果，但是不被推薦，前者會產生異常，後者是強制終止，不會釋放鎖。

4. 阻塞狀態：線程不會被分配 CPU 時間，無法執行。

四、線程的優先順序

線程的優先順序代表該線程的重要程度，當有多個線程同時處於可執行狀態並等待獲得 CPU 時間時，線程調度系統根據各個線程的優先順序來決定給誰分配 CPU 時間，優先順序高的線程有更大的機會獲得 CPU 時間，優先順序低的線程也不是沒有機會，只是機會要小一些罷了。

你可以調用 Thread 類的方法 getPriority() 和 setPriority()來存取線程的優先順序，線程的優先順序界於1(MIN_PRIORITY)和10(MAX_PRIORITY)之間，預設是5(NORM_PRIORITY)。

五、線程的同步

由於同一進程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴重的問題。Java語言提供了專門機制以解決這種沖突，有效避免了同一個數據對象被多個線程同時訪問。

由於我們可以通過 private 關鍵字來保證數據對象只能被方法訪問，所以我們只需針對方法提出一套機制，這套機制就是 synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。

1. synchronized 方法：通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如：

public synchronized void accessVal(int newVal);

synchronized 方法控制對類成員變數的訪問：每個類實例對應一把鎖，每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執行，否則所屬線程阻塞，方法一旦執行，就獨占該鎖，直到從該方法返回時才將鎖釋放，此後被阻塞的線程方能獲得該鎖，重新進入可執行狀態。

這種機制確保了同一時刻對於每一個類實例，其所有聲明為 synchronized 的成員函數中至多隻有一個處於可執行狀態（因為至多隻有一個能夠獲得該類實例對應的鎖），從而有效避免了類成員變數的訪問沖突（只要所有可能訪問類成員變數的方法均被聲明為 synchronized）。

在 Java 中，不光是類實例，每一個類也對應一把鎖，這樣我們也可將類的靜態成員函數聲明為 synchronized ，以控制其對類的靜態成員變數的訪問。

synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法 run() 聲明為 synchronized ，由於在線程的整個生命期內它一直在運行，因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以通過將訪問類成員變數的代碼放到專門的方法中，將其聲明為 synchronized ，並在主方法中調用來解決這一問題，但是 Java 為我們提供了更好的解決辦法，那就是 synchronized 塊。

2. synchronized 塊：通過 synchronized關鍵字來聲明synchronized 塊。語法如下：

synchronized(syncObject)
{
//允許訪問控制的代碼
}

synchronized 塊是這樣一個代碼塊，其中的代碼必須獲得對象 syncObject （如前所述，可以是類實例或類）的鎖方能執行，具體機制同前所述。由於可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。

六、線程的阻塞

為了解決對共享存儲區的訪問沖突，Java 引入了同步機制，現在讓我們來考察多個線程對共享資源的訪問，顯然同步機制已經不夠了，因為在任意時刻所要求的資源不一定已經准備好了被訪問，反過來，同一時刻准備好了的資源也可能不止一個。為了解決這種情況下的訪問控制問題，Java 引入了對阻塞機制的支持。

阻塞指的是暫停一個線程的執行以等待某個條件發生（如某資源就緒），學過操作系統的同學對它一定已經很熟悉了。Java 提供了大量方法來支持阻塞，下面讓我們逐一分析。

1. sleep() 方法：sleep() 允許 指定以毫秒為單位的一段時間作為參數，它使得線程在指定的時間內進入阻塞狀態，不能得到CPU 時間，指定的時間一過，線程重新進入可執行狀態。典型地，sleep() 被用在等待某個資源就緒的情形：測試發現條件不滿足後，讓線程阻塞一段時間後重新測試，直到條件滿足為止。

2. suspend() 和 resume() 方法：兩個方法配套使用，suspend()使得線程進入阻塞狀態，並且不會自動恢復，必須其對應的resume() 被調用，才能使得線程重新進入可執行狀態。典型地，suspend() 和 resume() 被用在等待另一個線程產生的結果的情形：測試發現結果還沒有產生後，讓線程阻塞，另一個線程產生了結果後，調用 resume() 使其恢復。

3. yield() 方法：yield() 使得線程放棄當前分得的 CPU 時間，但是不使線程阻塞，即線程仍處於可執行狀態，隨時可能再次分得 CPU 時間。調用 yield() 的效果等價於調度程序認為該線程已執行了足夠的時間從而轉到另一個線程。

4. wait() 和 notify() 方法：兩個方法配套使用，wait() 使得線程進入阻塞狀態，它有兩種形式，一種允許 指定以毫秒為單位的一段時間作為參數，另一種沒有參數，前者當對應的 notify() 被調用或者超出指定時間時線程重新進入可執行狀態，後者則必須對應的 notify() 被調用。

初看起來它們與 suspend() 和 resume() 方法對沒有什麼分別，但是事實上它們是截然不同的。區別的核心在於，前面敘述的所有方法，阻塞時都不會釋放佔用的鎖（如果佔用了的話），而這一對方法則相反。

上述的核心區別導致了一系列的細節上的區別。

首先，前面敘述的所有方法都隸屬於 Thread 類，但是這一對卻直接隸屬於 Object 類，也就是說，所有對象都擁有這一對方法。初看起來這十分不可思議，但是實際上卻是很自然的，因為這一對方法阻塞時要釋放佔用的鎖，而鎖是任何對象都具有的，調用任意對象的 wait() 方法導致線程阻塞，並且該對象上的鎖被釋放。

而調用 任意對象的notify()方法則導致因調用該對象的 wait() 方法而阻塞的線程中隨機選擇的一個解除阻塞（但要等到獲得鎖後才真正可執行）。

其次，前面敘述的所有方法都可在任何位置調用，但是這一對方法卻必須在 synchronized 方法或塊中調用，理由也很簡單，只有在synchronized 方法或塊中當前線程才佔有鎖，才有鎖可以釋放。

同樣的道理，調用這一對方法的對象上的鎖必須為當前線程所擁有，這樣才有鎖可以釋放。因此，這一對方法調用必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖對象就是調用這一對方法的對象。若不滿足這一條件，則程序雖然仍能編譯，但在運行時會出現IllegalMonitorStateException 異常。

wait() 和 notify() 方法的上述特性決定了它們經常和synchronized 方法或塊一起使用，將它們和操作系統的進程間通信機製作一個比較就會發現它們的相似性：synchronized方法或塊提供了類似於操作系統原語的功能，它們的執行不會受到多線程機制的干擾，而這一對方法則相當於 block 和wakeup 原語（這一對方法均聲明為 synchronized）。

它們的結合使得我們可以實現操作系統上一系列精妙的進程間通信的演算法（如信號量演算法），並用於解決各種復雜的線程間通信問題。關於 wait() 和 notify() 方法最後再說明兩點：

第一：調用 notify() 方法導致解除阻塞的線程是從因調用該對象的 wait() 方法而阻塞的線程中隨機選取的，我們無法預料哪一個線程將會被選擇，所以編程時要特別小心，避免因這種不確定性而產生問題。

第二：除了 notify()，還有一個方法 notifyAll() 也可起到類似作用，唯一的區別在於，調用 notifyAll() 方法將把因調用該對象的 wait() 方法而阻塞的所有線程一次性全部解除阻塞。當然，只有獲得鎖的那一個線程才能進入可執行狀態。

談到阻塞，就不能不談一談死鎖，略一分析就能發現，suspend() 方法和不指定超時期限的 wait() 方法的調用都可能產生死鎖。遺憾的是，Java 並不在語言級別上支持死鎖的避免，我們在編程中必須小心地避免死鎖。

以上我們對 Java 中實現線程阻塞的各種方法作了一番分析，我們重點分析了 wait() 和 notify()方法，因為它們的功能最強大，使用也最靈活，但是這也導致了它們的效率較低，較容易出錯。實際使用中我們應該靈活使用各種方法，以便更好地達到我們的目的。

七、守護線程

守護線程是一類特殊的線程，它和普通線程的區別在於它並不是應用程序的核心部分，當一個應用程序的所有非守護線程終止運行時，即使仍然有守護線程在運行，應用程序也將終止，反之，只要有一個非守護線程在運行，應用程序就不會終止。守護線程一般被用於在後台為其它線程提供服務。

可以通過調用方法 isDaemon() 來判斷一個線程是否是守護線程，也可以調用方法 setDaemon() 來將一個線程設為守護線程。

八、線程組

線程組是一個 Java 特有的概念，在 Java 中，線程組是類ThreadGroup 的對象，每個線程都隸屬於唯一一個線程組，這個線程組在線程創建時指定並在線程的整個生命期內都不能更改。

你可以通過調用包含 ThreadGroup 類型參數的 Thread 類構造函數來指定線程屬的線程組，若沒有指定，則線程預設地隸屬於名為 system 的系統線程組。

在 Java 中，除了預建的系統線程組外，所有線程組都必須顯式創建。在 Java 中，除系統線程組外的每個線程組又隸屬於另一個線程組，你可以在創建線程組時指定其所隸屬的線程組，若沒有指定，則預設地隸屬於系統線程組。這樣，所有線程組組成了一棵以系統線程組為根的樹。

Java 允許我們對一個線程組中的所有線程同時進行操作，比如我們可以通過調用線程組的相應方法來設置其中所有線程的優先順序，也可以啟動或阻塞其中的所有線程。

Java 的線程組機制的另一個重要作用是線程安全。線程組機制允許我們通過分組來區分有不同安全特性的線程，對不同組的線程進行不同的處理，還可以通過線程組的分層結構來支持不對等安全措施的採用。

Java 的 ThreadGroup 類提供了大量的方法來方便我們對線程組樹中的每一個線程組以及線程組中的每一個線程進行操作。

九、總結

在本文中，我們講述了 Java 多線程編程的方方面面，包括創建線程，以及對多個線程進行調度、管理。我們深刻認識到了多線程編程的復雜性，以及線程切換開銷帶來的多線程程序的低效性，這也促使我們認真地思考一個問題：我們是否需要多線程？何時需要多線程？

多線程的核心在於多個代碼塊並發執行，本質特點在於各代碼塊之間的代碼是亂序執行的。我們的程序是否需要多線程，就是要看這是否也是它的內在特點。

假如我們的程序根本不要求多個代碼塊並發執行，那自然不需要使用多線程；假如我們的程序雖然要求多個代碼塊並發執行，但是卻不要求亂序，則我們完全可以用一個循環來簡單高效地實現，也不需要使用多線程；只有當它完全符合多線程的特點時，多線程機制對線程間通信和線程管理的強大支持才能有用武之地，這時使用多線程才是值得的。

來自：開發者在線

6. qthread如何啟動多個線程

1. 引言

多線程對於需要處理耗時任務的應用很有用，一方面響應用戶操作、更新界面顯示，另一方面在「後台」進行耗時操作，比如大量運算、復制大文件、網路傳輸等。
使用Qt框架開發應用程序時，使用QThread類可以方便快捷地創建管理多線程。而多線程之間的通信也可使用Qt特有的「信號-槽」機制實現。
下面的說明以文件復制為例。主線程負責提供交互界面，顯示復制進度等；子線程負責復制文件。最後附有可以執行的代碼。

2. QThread使用方法1——重寫run()函數

第一種使用方法是自己寫一個類繼承QThread，並重寫其run()函數。
大家知道，C/C++程序都是從main()函數開始執行的。main()函數其實就是主進程的入口，main()函數退出了，則主進程退出，整個進程也就結束了。
而對於使用Qthread創建的進程而言，run()函數則是新線程的入口，run()函數退出，意味著線程的終止。復制文件的功能，就是在run()函數中執行的。
下面舉個文件復制的例子。自定義一個類，繼承自Qthread

CopyFileThread: public QThread
{
Q_OBJECTpublic:
CopyFileThread(QObject * parent = 0);protected: void run(); // 新線程入口// 省略掉一些內容}

在對應的cpp文件中，定義run()

void CopyFileThread::run(){ // 新線程入口
// 初始化和操作放在這里}

將這個類寫好之後，在主線程的代碼中生成一個CopyFileThread的實例，例如在mainwindow.cpp中寫：

// mainwindow.h中CopyFileThread * m_cpyThread;// mainwindow.cpp中m_cpyThread = new CopyFileThread;

在要開始復制的時候，比如按下「復制」按鈕後，讓這個線程開始執行：

m_cpyThread->start();

注意，使用start()函數來啟動子線程，而不是run()。start()會自動調用run()。
線程開始執行後，就進入run()函數，執行復制文件的操作。而此時，主線程的顯示和操作都不受影響。
如果需要進行對復制過程中可能發生的事件進行處理，例如界面顯示復制進度、出錯返回等等，應該從CopyFileThread中發出信號(signal），並事先連接到mainwindow的槽，由這些槽函數來處理事件。

3. QThread使用方法2——moveToThread()

如果不想每執行一種任務就自定義一個新線程，那麼可以自定義用於完成任務的類，並讓它們繼承自QObject。例如，自定義一個FileCopier類，用於復制文件。

class FileCopier : public QObject
{
Q_OBJECTpublic: explicit FileCopier(QObject *parent = 0);public slots: void startCopying(); void cancelCopying();
}

注意這里我們定義了兩個槽函數，分別用於復制的開始和取消。
這個類本身的實例化是在主線程中進行的，例如：

// mainwindow.h中private:
FileCopier* m_copier;// mainwindow.cpp中，初始化時
m_copier = new FileCopier;

此時m_copier還是屬於主線程的。要將其移動到子線程處理，需要首先聲明並實例化一個QThread：

// mainwindow.h中signals: void startCopyRsquested();private:
QThread * m_childThread; // m_copier將被移動到此線程執行// mainwindow.cpp中，初始化時
m_childThread = new QThread; // 子線程，本身不負責復制

然後使用moveToThread()將m_copier移動到新線程。注意moveToThread()是QObject的公有函數，因此用於復制文件的類FileCopier必須繼承自QObject。移動之後啟動子線程。此時復制還沒有開始。

m_copier->moveToThread(m_childThread); // 將實例移動到新的線程，實現多線程運行
m_childThread->start(); // 啟動子線程

注意一定要記得啟動子線程，否則線程沒有運行，m_copier的功能也無法執行。
要開始復制，需要使用信號-槽機制，觸發FileCopier的槽函數實現。因此要事先定義信號並連接：

// mainwindow.h中signals: void startCopyRsquested();// mainwindow.cpp中，初始化時// 使用信號-槽機制，發出開始指令
connect(this, SIGNAL(startCopyRsquested()), m_copier, SLOT(startCopying()));

當按下「復制」按鈕後，發出信號。

emit startCopyRsquested(); // 發送信號

m_copier在另一個線程接收到信號後，觸發槽函數，開始復制文件。

4.常見問題

4.1. 子線程中能不能進行UI操作？

Qt中的UI操作，比如QMainWindow、QWidget之類的創建、操作，只能位於主線程！
這個限制意味著你不能在新的線程中使用QDialog、QMessageBox等。比如在新線程中復制文件出錯，想彈出對話框警告？可以，但是必須將錯誤信息傳到主線程，由主線程實現對話框警告。
因此一般思路是，主線程負責提供界面，子線程負責無UI的單一任務，通過「信號-槽」與主線程交互。

4.2. QThread中的哪些代碼屬於子線程？

QThread，以及繼承QThread的類（以下統稱QThread），他們的實例都屬於新線程嗎？答案是：不。
需要注意的是，QThread本身的實例是屬於創建該實例的線程的。比如在主線程中創建一個QThread，那麼這個QThread實例本身屬於主線程。當然，QThread會開辟一個新線程（入口是run()），但是QThread本身並不屬於這個新線程。也就是說，QThread本身的成員都不屬於新線程，而且在QThread構造函數里通過new得到的實例，也不屬於新線程。這一特性意味著，如果要實現多線程操作，那麼你希望屬於新線程的實例、變數等，應該在run()中進行初始化、實例化等操作。本文給出的例子就是這樣操作的。
如果你的多線程程序運行起來，會出現關於thread的報警，思考一下，各種變數、實例是不是放對了位置，是不是真的位於新的線程里。

4.3. 怎麼查看是不是真的實現了多線程？

可以列印出當前線程。對於所有繼承自QObject的類，例如QMainwindow、QThread，以及自定義的各種類，可以調用QObject::thread()查看當前線程，這個函數返回的是一個QThread的指針。例如用qDebug()列印：
在mainwindow.cpp的某個函數里、QThread的run()函數里、自定義類的某個函數里，寫上：

qDebug() << "Current thread:" << thread();

對比不同位置列印的指針，就可以知道它們是不是位於同一個線程了。

5.範例

範例實現了多線程復制文本文件。
提供的範例文件可用QtCreator編譯運行。界面如下（不同的操作系統略有不同）：

範例中實現了本文介紹的兩種方法，同時也給出了單線程復制對比。打鉤選擇不同的復制方法。可以發現，在使用多線程的時候，界面不會假死，第二根進度條的動畫是持續的；而使用單線程復制的時候，「取消」按鈕按不動，界面假死，而且第二根進度條的動畫也停止了。
由於範例處理的文件很小，為了讓復制過程持續較長時間以便使得現象明顯，復制文件的時候，每復制一行加入了等待。

範例代碼：
https://github.com/Xia-Weiwen/CopyFile

7. QT如何進行線程編譯

在Qt中使用多線程，目前就我使用過的有兩種，一是子類化QThread，重寫run函數，在run函數里實現自己的代碼，這一部分代碼通常是比較耗時，或者乾脆直接阻塞的。比如一個while循環，設置一個標志，判斷循環結束。
這樣的例子在網上有很多，就不寫了。
這樣寫的話，會有一些東西需要了解。
子類化QThread的方法，只有run函數裡面的內容是執行在子線程里的，其他的部分，比如槽函數什麼的還是在主線程里執行（假設是在主線程開啟的該子線程）。
還有一種方法，是子類化QObject，新建一個線程，然後使用MoveToThread把這個類的對象移到新建的線程中，這種做法使得它所有的槽函數都是執行在新開辟的線程裡面。
如果直接（QObject對象）.abc()的話，這個成員函數是在主進程內執行，可能會出現"QObject::killTimer: timers
cannot be stopped from another thread"的運行錯誤。
使用第二種方法的話，貌似會遇到這樣的問題：如果在一個槽函數中把子線程阻塞，其他的槽函數無法接受來自主線程

8. 如何使用java多線程處理http請求，求思路！！

雲計算也分很多種類型，也需要看哪種類型，目前我只能從你之前的介紹來猜測你的需求是計算密集型。那麼這種一般來說，前端界面提供三個功能（23也可以合並）：1、提交請求：就是把請求保存在伺服器，然後等著後台批處理系統去搞定它；2、查詢處理狀態：查詢下之前提交的某請求處理得怎麼樣了，比如總共處理多久了，處理了百分之多少；3、查詢處理結果：如果處理完畢了，顯示下處理的結果。然後後端專門有個批處理系統去負責從資料庫中把前端接受的請求拿出來，然後找工作線程去處理，並跟蹤進度，回寫結果。比如前端提交請求是計算PI到小數點後十億位，那麼這個前端應用只需要把客戶的請求直接寫入資料庫，就可以返回消息：「請求提交成功。」而批處理系統定期查詢資料庫，並從資料庫中取出請求，然後根據計算規模啟動大量線程甚至其它集群，分配任務，然後......不過，總的來說，你們老大直接把這樣的命題交給你，好像有點那啥。。。