第一篇：多核多線程題目總結

2.并行和并發的概念與區別：

-如果某個系統支持兩個或多個動作（Action）同時存在，那么這個系統就是一個并發系統-如果某個系統支持兩個或多個動作同時執行，那么這個系統就是一個并行系統

-并發程序可同時擁有兩個或多個線程。如果程序能夠并行執行，則一定是運行在多核處理器上，每個線程都將分配到一個獨立的處理器核上。

-“并行”概念是“并發”概念的一個子集 3.并行計算技術的主要目的：

加速求解問題的速度

例如，給定某應用，在單處理器上，串行執行需要2 周，這個速度對一般的應用而言，是無法忍受的。于是，可以借助并行計算，使用100 臺處理器，加速50 倍，將執行時間縮短為6.72 個小時。

提高求解問題的規模

例如，在單處理器上，受內存資源2GB的限制，只能計算10 萬個網格，但是，當前數值模擬要求計算千萬個網格。于是，也可以借助并行計算，使用100 個處理器，將問題求解規模線性地擴大100 倍。并行計算的主要目標：

在并行機上，解決具有重大挑戰性計算任務的科學、工程及商業計算問題，滿足不斷增長的應用問題對速度和內存資源的需求。

4.并行計算的主要研究內容大致可分為四個方面：

并行機的高性能特征抽取

充分理解和抽取當前并行機體系結構的高性能特征，提出實用的并行計算模型和并行性能評價方法，指導并行算法的設計和并行程序的實現。

并行算法設計與分析

設計高效率的并行算法，將應用問題分解為可并行計算的多個子任務，并具體分析這些算法的可行性和效果。

并行實現技術

主要包含并行程序設計和并行性能優化。

并行應用

這是并行計算研究的最終目的。通過驗證和確認并行程序的正確性和效率，進一步將程序發展為并行應用軟件，應用于求解實際問題。同時，結合實際應用出現的各種問題，不斷地改進并行算法和并行程序。5.并行程序執行時間

對各個進程，墻上時間可進一步分解為計算CPU時間、通信CPU時間、同步開銷時間、同步導致的進程空閑時間

計算CPU時間：進程指令執行所花費的CPU時間，包括程序本身的指令執行占用的時間（用戶時間）和系統指令花費的時間；

通信CPU時間：進程通信花費的CPU時間； 同步開銷時間：進程同步花費的時間；

進程空閑時間：進程空閑時間是指并行程序執行過程中，進程所有空閑時間總和（如進程阻塞式等待其他進程的消息時。此時CPU通常是空閑的，或者處于等待狀態）6.并行程序性能優化

最主要的是選擇好的并行算法和通信模式

減少通信量、提高通信粒度

提高通信粒度的有效方法就是減少通信次數，盡可能將可以一次傳遞的數據合并起來一起傳遞

全局通信盡量利用高效集合通信算法

對于標準的集合通信，如廣播、規約、數據散發與收集等，盡量調用MPI標準庫函數 挖掘算法的并行度，減少CPU空閑等待

具有數據相關性的計算過程會導致并行運行的部分進程空閑等待.在這種情況下，可以考慮改變算法來消除數據相關性

7.順序程序的特性

順序性：處理機嚴格按照指令次序依次執行，即僅當一條指令執行完后才開始執行下一條指令；

封閉性：程序在執行過程中獨占系統中的全部資源，該程序的運行環境只與其自身動作有關，不受其它程序及外界因素影響；

可再現性：程序的執行結果與執行速度無關，而只與初始條件有關，給定相同的初始條件，程序的任意多次執行一定得到相同的執行結果.8.并發程序特性

交叉性：程序并發執行對應某一種交叉，不同的交叉可能導致不同的計算結果，操作系統應當保證只產生導致正確結果的交叉，去除那些可能導致不正確結果的交叉；

非封閉性：一個進程的運行環境可能被其它進程所改變，從而相互影響；

不可再現性：由于交叉的隨機性，并發程序的多次執行可能對應不同的交叉，因而不能期望重新運行的程序能夠再現上次運行的結果。

10.Win32線程同步的實現

11.數據作用域對數據值的影響

12.分析程序的結果

13.并行區域編程與parallel for語句的區別

-并行區域采用了復制執行方式，將代碼在所有的線程內各執行一次；

-循環并行化則是采用工作分配執行方式，將循環需做的所有工作量，按一定的方式分配給各個執行線程，全部線程執行工作的總合等于原先串行執行所完成的工作量。14.OpenMP提供三種不同的互斥鎖機制： 臨界區（critical）原子操作（atomic）由庫函數來提供同步操作 int counter=0;#pragma omp parallel {

for(int i=0;i<10000;i++)

#pragma omp atomic //atomic operation

}

printf(“counter = %dn”,counter);

counter=20000 25.影響性能的主要因素

并行化代碼在應用程序中的比率-OpenMP 本身的開銷

-OpenMP 獲得應用程序多線程并行化的能力，需要一定的程序庫支持。在這些庫程序對程序并行加速的同時也需要運行庫本身-負載均衡

-局部性

在程序運行過程中，高速緩存將緩存最近剛剛訪問過的數據及其相鄰的數據。因此，在編寫程序的時候，需要考慮到高速緩存的作用，有意地運用這種局部性帶來的高速緩存的效率提高。-線程同步帶來的開銷

多個線程在進行同步的時候必然帶來一定的同步開銷，在使用多線程進行開發時需要考慮同步的必要性，消除不必要的同步，或者調整同步的順序，就有可能帶來性能上的提升。26.什么是MPI 消息傳遞接口（Message Passing Interface，簡稱MPI）是一種編程接口標準，而不是一種具體的編程語言。基本含義：MPI標準定義了一組具有可移植性的編程接口。

特征：

1、典型的實現包括開源的MPICH、LAM MPI以及不開源的INTEL MPI。

2、程序員設計好應用程序并行算法，調用這些接口，鏈接相應平臺上的MPI庫，即可實現基于消息傳遞的并行計算

27.MPICH的安裝和配置 counter++;

28.MPI程序的四個基本函數-MPI_Init和MPI_Finalize MPI_Init初始化MPI執行環境，建立多個MPI進程之間的聯系，為后續通信做準備。而MPI_Finalize則是結束MPI執行環境。這兩個函數用來定義MPI程序的并行區-MPI_Comm_rank

用來標識各個MPI進程，兩個函數參數：

MPI_Comm類型的通信域，表示參與計算的MPI進程組 &rank，返回調用進程在comm中的標識號-MPI_Comm_size 用來標識相應進程組中有多少個進程，有兩個參數： MPI_Comm類型的通信域，標尺參與計算的MPI進程組 整型指針，返回相應進程組中的進程數

29.MPI的點對點通信

兩個最重要的MPI函數MPI_Send和MPI_Recv。

-int MPI_SEND(buf, count, datatype, dest, tag, comm)這個函數的含義是向通信域comm中的dest進程發送數據。消息數據存放在buf中，類型是datatype，個數是count個。這個消息的標志是tag，用以和本進程向同一目的進程發送的其他消息區別開來。

-int MPI_RECV(buf,count,datatype,source,tag,comm,status)MPI_Recv絕大多數的參數和MPI_Send相對應，有相同的意義。唯一的區別就是MPI_Recv里面多了一個參數status。status主要顯示接收函數的各種錯誤狀態。30.消息管理7要素 發送或者接收緩沖區buf； 數據數量count； 數據類型datatype；

目標進程或者源進程destination/source； 消息標簽tag； 通信域comm；.消息狀態status，只在接收的函數中出現。31.MPI群集通信

群集通信是包含了一對多、多對一和多對多的進程通信模式。其最大特點是多個進程參與通信。常用的MPI群集通信函數： 同步

廣播 聚集 播撒

第二篇：Java多線程編程總結

Java多線程編程總結

2007-05-17 11:21:59 標簽：java 多線程

原創作品，允許轉載，轉載時請務必以超鏈接形式標明文章 原始出處、作者信息和本聲明。否則將追究法律責任。http://lavasoft.blog.51cto.com/62575/27069

Java多線程編程總結

下面是Java線程系列博文的一個編目：

Java線程：概念與原理 Java線程：創建與啟動

Java線程：線程棧模型與線程的變量 Java線程：線程狀態的轉換 Java線程：線程的同步與鎖 Java線程：線程的交互 Java線程：線程的調度-休眠 Java線程：線程的調度-優先級 Java線程：線程的調度-讓步 Java線程：線程的調度-合并 Java線程：線程的調度-守護線程 Java線程：線程的同步-同步方法 Java線程：線程的同步-同步塊

Java線程：并發協作-生產者消費者模型 Java線程：并發協作-死鎖 Java線程：volatile關鍵字 Java線程：新特征-線程池

Java線程：新特征-有返回值的線程 Java線程：新特征-鎖（上）Java線程：新特征-鎖（下）Java線程：新特征-信號量 Java線程：新特征-阻塞隊列 Java線程：新特征-阻塞棧 Java線程：新特征-條件變量 Java線程：新特征-原子量 Java線程：新特征-障礙器 Java線程：大總結

----

下面的內容是很早之前寫的，內容不夠充實，而且是基于Java1.4的內容，Java5之后，線程并發部分擴展了相當多的內容，因此建議大家看上面的系列文章的內容，與時俱進，跟上Java發展的步伐。----

一、認識多任務、多進程、單線程、多線程 要認識多線程就要從操作系統的原理說起。

以前古老的DOS操作系統（V 6.22）是單任務的，還沒有線程的概念，系統在每次只能做一件事情。比如你在copy東西的時候不能rename文件名。為了提高系統的利用效率，采用批處理來批量執行任務。

現在的操作系統都是多任務操作系統，每個運行的任務就是操作系統所做的一件事情，比如你在聽歌的同時還在用MSN和好友聊天。聽歌和聊天就是兩個任務，這個兩個任務是“同時”進行的。一個任務一般對應一個進程，也可能包含好幾個進程。比如運行的MSN就對應一個MSN的進程，如果你用的是windows系統，你就可以在任務管理器中看到操作系統正在運行的進程信息。

一般來說，當運行一個應用程序的時候，就啟動了一個進程，當然有些會啟動多個進程。啟動進程的時候，操作系統會為進程分配資源，其中最主要的資源是內存空間，因為程序是在內存中運行的。在進程中，有些程序流程塊是可以亂序執行的，并且這個代碼塊可以同時被多次執行。實際上，這樣的代碼塊就是線程體。線程是進程中亂序執行的代碼流程。當多個線程同時運行的時候，這樣的執行模式成為并發執行。

多線程的目的是為了最大限度的利用CPU資源。

Java編寫程序都運行在在Java虛擬機（JVM）中，在JVM的內部，程序的多任務是通過線程來實現的。每用java命令啟動一個java應用程序，就會啟動一個JVM進程。在同一個JVM進程中，有且只有一個進程，就是它自己。在這個JVM環境中，所有程序代碼的運行都是以線程來運行。

一般常見的Java應用程序都是單線程的。比如，用java命令運行一個最簡單的HelloWorld的Java應用程序時，就啟動了一個JVM進程，JVM找到程序程序的入口點main()，然后運行main()方法，這樣就產生了一個線程，這個線程稱之為主線程。當main方法結束后，主線程運行完成。JVM進程也隨即退出。

對于一個進程中的多個線程來說，多個線程共享進程的內存塊，當有新的線程產生的時候，操作系統不分配新的內存，而是讓新線程共享原有的進程塊的內存。因此，線程間的通信很容易，速度也很快。不同的進程因為處于不同的內存塊，因此進程之間的通信相對困難。

實際上，操作的系統的多進程實現了多任務并發執行，程序的多線程實現了進程的并發執行。多任務、多進程、多線程的前提都是要求操作系統提供多任務、多進程、多線程的支持。

在Java程序中，JVM負責線程的調度。線程調度是值按照特定的機制為多個線程分配CPU的使用權。調度的模式有兩種：分時調度和搶占式調度。分時調度是所有線程輪流獲得CPU使用權，并平均分配每個線程占用CPU的時間；搶占式調度是根據線程的優先級別來獲取CPU的使用權。JVM的線程調度模式采用了搶占式模式。

所謂的“并發執行”、“同時”其實都不是真正意義上的“同時”。眾所周知，CPU都有個時鐘頻率，表示每秒中能執行cpu指令的次數。在每個時鐘周期內，CPU實際上只能去執行一條（也有可能多條）指令。操作系統將進程線程進行管理，輪流（沒有固定的順序）分配每個進程很短的一段是時間（不一定是均分），然后在每個線程內部，程序代碼自己處理該進程內部線程的時間分配，多個線程之間相互的切換去執行，這個切換時間也是非常短的。因此多任務、多進程、多線程都是操作系統給人的一種宏觀感受，從微觀角度看，程序的運行是異步執行的。

用一句話做總結：雖然操作系統是多線程的，但CPU每一時刻只能做一件事，和人的大腦是一樣的，呵呵。

二、Java與多線程

Java語言的多線程需要操作系統的支持。

Java 虛擬機允許應用程序并發地運行多個執行線程。Java語言提供了多線程編程的擴展點，并給出了功能強大的線程控制API。

在Java中，多線程的實現有兩種方式： 擴展java.lang.Thread類 實現java.lang.Runnable接口

每個線程都有一個優先級，高優先級線程的執行優先于低優先級線程。每個線程都可以或不可以標記為一個守護程序。當某個線程中運行的代碼創建一個新 Thread 對象時，該新線程的初始優先級被設定為創建線程的優先級，并且當且僅當創建線程是守護線程時，新線程才是守護程序。

當 Java 虛擬機啟動時，通常都會有單個非守護線程（它通常會調用某個指定類的 main 方法）。Java 虛擬機會繼續執行線程，直到下列任一情況出現時為止：

調用了 Runtime 類的 exit 方法，并且安全管理器允許退出操作發生。

非守護線程的所有線程都已停止運行，無論是通過從對 run 方法的調用中返回，還是通過拋出一個傳播到 run 方法之外的異常。

三、擴展java.lang.Thread類

/** * File Name: TestMitiThread.java * Created by: IntelliJ IDEA.* Copyright: Copyright(c)2003-2006 * Company: Lavasoft([url]http://lavasoft.blog.51cto.com/[/url])* Author: leizhimin * Modifier: leizhimin * Date Time: 2007-5-17 10:03:12 * Readme: 通過擴展Thread類實現多線程 */ public class TestMitiThread { public static void main(String[] rags){ System.out.println(Thread.currentThread().getName()+ “ 線程運行開始!”);new MitiSay(“A”).start();new MitiSay(“B”).start();System.out.println(Thread.currentThread().getName()+ “ 線程運行結束!”);} }

class MitiSay extends Thread { public MitiSay(String threadName){ super(threadName);}

public void run(){ System.out.println(getName()+ “ 線程運行開始!”);for(int i = 0;i < 10;i++){ System.out.println(i + “ ” + getName());try { sleep((int)Math.random()* 10);} catch(InterruptedException e){ e.printStackTrace();} } System.out.println(getName()+ “ 線程運行結束!”);} }

運行結果：

main 線程運行開始!main 線程運行結束!A 線程運行開始!0 A 1 A B 線程運行開始!2 A 0 B 3 A 4 A 1 B 5 A 6 A 7 A 8 A 9 A A 線程運行結束!2 B 3 B 4 B 5 B 6 B 7 B 8 B 9 B B 線程運行結束!說明：

程序啟動運行main時候，java虛擬機啟動一個進程，主線程main在main()調用時候被創建。隨著調用MitiSay的兩個對象的start方法，另外兩個線程也啟動了，這樣，整個應用就在多線程下運行。

在一個方法中調用Thread.currentThread().getName()方法，可以獲取當前線程的名字。在mian方法中調用該方法，獲取的是主線程的名字。

注意：start()方法的調用后并不是立即執行多線程代碼，而是使得該線程變為可運行態（Runnable），什么時候運行是由操作系統決定的。

從程序運行的結果可以發現，多線程程序是亂序執行。因此，只有亂序執行的代碼才有必要設計為多線程。

Thread.sleep()方法調用目的是不讓當前線程獨自霸占該進程所獲取的CPU資源，以留出一定時間給其他線程執行的機會。

實際上所有的多線程代碼執行順序都是不確定的，每次執行的結果都是隨機的。

四、實現java.lang.Runnable接口

/** * 通過實現 Runnable 接口實現多線程 */ public class TestMitiThread1 implements Runnable {

public static void main(String[] args){ System.out.println(Thread.currentThread().getName()+ “ 線程運行開始!”);TestMitiThread1 test = new TestMitiThread1();Thread thread1 = new Thread(test);Thread thread2 = new Thread(test);thread1.start();thread2.start();System.out.println(Thread.currentThread().getName()+ “ 線程運行結束!”);}

public void run(){ System.out.println(Thread.currentThread().getName()+ “ 線程運行開始!”);for(int i = 0;i < 10;i++){ System.out.println(i + “ ” + Thread.currentThread().getName());try { Thread.sleep((int)Math.random()* 10);} catch(InterruptedException e){ e.printStackTrace();} } System.out.println(Thread.currentThread().getName()+ “ 線程運行結束!”);} }

運行結果：

main 線程運行開始!Thread-0 線程運行開始!main 線程運行結束!0 Thread-0 Thread-1 線程運行開始!0 Thread-1 1 Thread-1 1 Thread-0 2 Thread-0 2 Thread-1 3 Thread-0 3 Thread-1 4 Thread-0 4 Thread-1 5 Thread-0 6 Thread-0 5 Thread-1 7 Thread-0 8 Thread-0 6 Thread-1 9 Thread-0 7 Thread-1 Thread-0 線程運行結束!8 Thread-1 9 Thread-1 Thread-1 線程運行結束!說明：

TestMitiThread1類通過實現Runnable接口，使得該類有了多線程類的特征。run（）方法是多線程程序的一個約定。所有的多線程代碼都在run方法里面。Thread類實際上也是實現了Runnable接口的類。

在啟動的多線程的時候，需要先通過Thread類的構造方法Thread(Runnable target)構造出對象，然后調用Thread對象的start()方法來運行多線程代碼。

實際上所有的多線程代碼都是通過運行Thread的start()方法來運行的。因此，不管是擴展Thread類還是實現Runnable接口來實現多線程，最終還是通過Thread的對象的API來控制線程的，熟悉Thread類的API是進行多線程編程的基礎。

五、讀解Thread類API

static int MAX_PRIORITY 線程可以具有的最高優先級。static int MIN_PRIORITY 線程可以具有的最低優先級。static int NORM_PRIORITY 分配給線程的默認優先級。

構造方法摘要

Thread(Runnable target)分配新的 Thread 對象。Thread(String name)分配新的 Thread 對象。

方法摘要

static Thread currentThread()返回對當前正在執行的線程對象的引用。ClassLoader getContextClassLoader()返回該線程的上下文 ClassLoader。long getId()返回該線程的標識符。String getName()返回該線程的名稱。int getPriority()返回線程的優先級。Thread.State getState()返回該線程的狀態。ThreadGroup getThreadGroup()返回該線程所屬的線程組。static boolean holdsLock(Object obj)當且僅當當前線程在指定的對象上保持監視器鎖時，才返回 true。void interrupt()中斷線程。

static boolean interrupted()測試當前線程是否已經中斷。boolean isAlive()測試線程是否處于活動狀態。boolean isDaemon()測試該線程是否為守護線程。boolean isInterrupted()測試線程是否已經中斷。void join()等待該線程終止。void join(long millis)等待該線程終止的時間最長為 millis 毫秒。void join(long millis, int nanos)等待該線程終止的時間最長為 millis 毫秒 + nanos 納秒。void resume()已過時。該方法只與 suspend()一起使用，但 suspend()已經遭到反對，因為它具有死鎖傾向。有關更多信息，請參閱為何 Thread.stop、Thread.suspend 和 Thread.resume 遭到反對？。void run()如果該線程是使用獨立的 Runnable 運行對象構造的，則調用該 Runnable 對象的 run 方法；否則，該方法不執行任何操作并返回。void setContextClassLoader(ClassLoader cl)設置該線程的上下文 ClassLoader。void setDaemon(boolean on)將該線程標記為守護線程或用戶線程。

static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)設置當線程由于未捕獲到異常而突然終止，并且沒有為該線程定義其他處理程序時所調用的默認處理程序。void setName(String name)改變線程名稱，使之與參數 name 相同。void setPriority(int newPriority)更改線程的優先級。

void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)設置該線程由于未捕獲到異常而突然終止時調用的處理程序。static void sleep(long millis)在指定的毫秒數內讓當前正在執行的線程休眠（暫停執行）。static void sleep(long millis, int nanos)在指定的毫秒數加指定的納秒數內讓當前正在執行的線程休眠（暫停執行）。void start()使該線程開始執行；Java 虛擬機調用該線程的 run 方法。void stop()已過時。該方法具有固有的不安全性。用 Thread.stop 來終止線程將釋放它已經鎖定的所有監視器（作為沿堆棧向上傳播的未檢查 ThreadDeath 異常的一個自然后果）。如果以前受這些監視器保護的任何對象都處于一種不一致的狀態，則損壞的對象將對其他線程可見，這有可能導致任意的行為。stop 的許多使用都應由只修改某些變量以指示目標線程應該停止運行的代碼來取代。目標線程應定期檢查該變量，并且如果該變量指示它要停止運行，則從其運行方法依次返回。如果目標線程等待很長時間（例如基于一個條件變量），則應使用 interrupt 方法來中斷該等待。有關更多信息，請參閱《為何不贊成使用 Thread.stop、Thread.suspend 和 Thread.resume？》。void stop(Throwable obj)已過時。該方法具有固有的不安全性。請參閱 stop()以獲得詳細信息。該方法的附加危險是它可用于生成目標線程未準備處理的異常（包括若沒有該方法該線程不太可能拋出的已檢查的異常）。有關更多信息，請參閱為何 Thread.stop、Thread.suspend 和 Thread.resume 遭到反對？。void suspend()已過時。該方法已經遭到反對，因為它具有固有的死鎖傾向。如果目標線程掛起時在保護關鍵系統資源的監視器上保持有鎖，則在目標線程重新開始以前任何線程都不能訪問該資源。如果重新開始目標線程的線程想在調用 resume 之前鎖定該監視器，則會發生死鎖。這類死鎖通常會證明自己是“凍結”的進程。有關更多信息，請參閱為何 Thread.stop、Thread.suspend 和 Thread.resume 遭到反對？。String toString()返回該線程的字符串表示形式，包括線程名稱、優先級和線程組。static void yield()暫停當前正在執行的線程對象，并執行其他線程。

六、線程的狀態轉換圖

線程在一定條件下，狀態會發生變化。線程變化的狀態轉換圖如下：

1、新建狀態（New）：新創建了一個線程對象。

2、就緒狀態（Runnable）：線程對象創建后，其他線程調用了該對象的start()方法。該狀態的線程位于可運行線程池中，變得可運行，等待獲取CPU的使用權。

3、運行狀態（Running）：就緒狀態的線程獲取了CPU，執行程序代碼。

4、阻塞狀態（Blocked）：阻塞狀態是線程因為某種原因放棄CPU使用權，暫時停止運行。直到線程進入就緒狀態，才有機會轉到運行狀態。阻塞的情況分三種：

（一）、等待阻塞：運行的線程執行wait()方法，JVM會把該線程放入等待池中。

（二）、同步阻塞：運行的線程在獲取對象的同步鎖時，若該同步鎖被別的線程占用，則JVM會把該線程放入鎖池中。

（三）、其他阻塞：運行的線程執行sleep()或join()方法，或者發出了I/O請求時，JVM會把該線程置為阻塞狀態。當sleep()狀態超時、join()等待線程終止或者超時、或者I/O處理完畢時，線程重新轉入就緒狀態。

5、死亡狀態（Dead）：線程執行完了或者因異常退出了run()方法，該線程結束生命周期。

七、線程的調度

1、調整線程優先級：Java線程有優先級，優先級高的線程會獲得較多的運行機會。

Java線程的優先級用整數表示，取值范圍是1~10，Thread類有以下三個靜態常量： static int MAX_PRIORITY 線程可以具有的最高優先級，取值為10。static int MIN_PRIORITY 線程可以具有的最低優先級，取值為1。static int NORM_PRIORITY 分配給線程的默認優先級，取值為5。

Thread類的setPriority()和getPriority()方法分別用來設置和獲取線程的優先級。

每個線程都有默認的優先級。主線程的默認優先級為Thread.NORM_PRIORITY。

線程的優先級有繼承關系，比如A線程中創建了B線程，那么B將和A具有相同的優先級。JVM提供了10個線程優先級，但與常見的操作系統都不能很好的映射。如果希望程序能移植到各個操作系統中，應該僅僅使用Thread類有以下三個靜態常量作為優先級，這樣能保證同樣的優先級采用了同樣的調度方式。

2、線程睡眠：Thread.sleep(long millis)方法，使線程轉到阻塞狀態。millis參數設定睡眠的時間，以毫秒為單位。當睡眠結束后，就轉為就緒（Runnable）狀態。sleep()平臺移植性好。

3、線程等待：Object類中的wait()方法，導致當前的線程等待，直到其他線程調用此對象的 notify()方法或 notifyAll()喚醒方法。這個兩個喚醒方法也是Object類中的方法，行為等價于調用 wait(0)一樣。

4、線程讓步：Thread.yield()方法，暫停當前正在執行的線程對象，把執行機會讓給相同或者更高優先級的線程。

5、線程加入：join()方法，等待其他線程終止。在當前線程中調用另一個線程的join()方法，則當前線程轉入阻塞狀態，直到另一個進程運行結束，當前線程再由阻塞轉為就緒狀態。

6、線程喚醒：Object類中的notify()方法，喚醒在此對象監視器上等待的單個線程。如果所有線程都在此對象上等待，則會選擇喚醒其中一個線程。選擇是任意性的，并在對實現做出決定時發生。線程通過調用其中一個 wait 方法，在對象的監視器上等待。直到當前的線程放棄此對象上的鎖定，才能繼續執行被喚醒的線程。被喚醒的線程將以常規方式與在該對象上主動同步的其他所有線程進行競爭；例如，喚醒的線程在作為鎖定此對象的下一個線程方面沒有可靠的特權或劣勢。類似的方法還有一個notifyAll()，喚醒在此對象監視器上等待的所有線程。注意：Thread中suspend()和resume()兩個方法在JDK1.5中已經廢除，不再介紹。因為有死鎖傾向。

7、常見線程名詞解釋

主線程：JVM調用程序mian()所產生的線程。

當前線程：這個是容易混淆的概念。一般指通過Thread.currentThread()來獲取的進程。后臺線程：指為其他線程提供服務的線程，也稱為守護線程。JVM的垃圾回收線程就是一個后臺線程。

前臺線程：是指接受后臺線程服務的線程，其實前臺后臺線程是聯系在一起，就像傀儡和幕后操縱者一樣的關系。傀儡是前臺線程、幕后操縱者是后臺線程。由前臺線程創建的線程默認也是前臺線程。可以通過isDaemon()和setDaemon()方法來判斷和設置一個線程是否為后臺線程。

本文出自 “熔 巖” 博客，請務必保留此出處http://lavasoft.blog.51cto.com/62575/27069

第三篇：多線程編程知識總結

多線程編程

一、問題的提出

1.1問題的引出

編寫一個耗時的單線程程序：

新建一個基于對話框的應用程序SingleThread，在主對話框IDD_SINGLETHREAD_DIALOG添加一個按鈕，ID為IDC_SLEEP_SIX_SECOND，標題為“延時6秒”，添加按鈕的響應函數，代碼如下：

void CSingleThreadDlg::OnSleepSixSecond(){ Sleep(6000);//延時6秒 } 編譯并運行應用程序，單擊“延時6秒”按鈕，你就會發現在這6秒期間程序就象“死機”一樣，不在響應其它消息。為了更好地處理這種耗時的操作，我們有必要學習——多線程編程。

1.2多線程概述

進程和線程都是操作系統的概念。進程是應用程序的執行實例，每個進程是由私有的虛擬地址空間、代碼、數據和其它各種系統資源組成，進程在運行過程中創建的資源隨著進程的終止而被銷毀，所使用的系統資源在進程終止時被釋放或關閉。

線程是進程內部的一個執行單元。系統創建好進程后，實際上就啟動執行了該進程的主執行線程，主執行線程以函數地址形式，比如說main或WinMain函數，將程序的啟動點提供給Windows系統。主執行線程終止了，進程也就隨之終止。

每一個進程至少有一個主執行線程，它無需由用戶去主動創建，是由系統自動創建的。用戶根據需要在應用程序中創建其它線程，多個線程并發地運行于同一個進程中。一個進程中的所有線程都在該進程的虛擬地址空間中，共同使用這些虛擬地址空間、全局變量和系統資源，所以線程間的通訊非常方便，多線程技術的應用也較為廣泛。

多線程可以實現并行處理，避免了某項任務長時間占用CPU時間。要說明的一點是，對于單處理器（CPU）的，為了運行所有這些線程，操作系統為每個獨立線程安排一些CPU時間，操作系統以輪換方式向線程提供時間片，這就給人一種假象，好象這些線程都在同時運行。由此可見，如果兩個非常活躍的線程為了搶奪對CPU的控制權，在線程切換時會消耗很多的CPU資源，反而會降低系統的性能。這一點在多線程編程時應該注意。

Win32 SDK函數支持進行多線程的程序設計，并提供了操作系統原理中的各種同步、互斥和臨界區等操作。Visual C++中，使用MFC類庫也實現了多線程的程序設計，使得多線程編程更加方便。1.3 Win32 API對多線程編程的支持

Win32 提供了一系列的API函數來完成線程的創建、掛起、恢復、終結以及通信等工作。下面將選取其中的一些重要函數進行說明。

1、HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes，DWORD dwStackSize，LPTHREAD_START_ROUTINE lpStartAddress，LPVOID lpParameter，DWORD dwCreationFlags，LPDWORD lpThreadId);該函數在其調用進程的進程空間里創建一個新的線程，并返回已建線程的句柄，其中各參數說明如下：

lpThreadAttributes：指向一個 SECURITY_ATTRIBUTES 結構的指針，該結構決定了線程的安全屬性，一般置為 NULL；

dwStackSize：指定了線程的堆棧深度，一般都設置為0；

lpStartAddress：表示新線程開始執行時代碼所在函數的地址，即線程的起始地址。一般情況為(LPTHREAD_START_ROUTINE)ThreadFunc，ThreadFunc 是線程函數名；

lpParameter：指定了線程執行時傳送給線程的32位參數，即線程函數的參數；

dwCreationFlags：控制線程創建的附加標志，可以取兩種值。如果該參數為0，線程在被創建后就會立即開始執行；如果該參數為CREATE_SUSPENDED,則系統產生線程后，該線程處于掛起狀態，并不馬上執行，直至函數ResumeThread被調用；

lpThreadId：該參數返回所創建線程的ID；

如果創建成功則返回線程的句柄，否則返回NULL。

2、DWORD SuspendThread(HANDLE hThread);該函數用于掛起指定的線程，如果函數執行成功，則線程的執行被終止。

3、DWORD ResumeThread(HANDLE hThread);該函數用于結束線程的掛起狀態，執行線程。

4、VOID ExitThread(DWORD dwExitCode);該函數用于線程終結自身的執行，主要在線程的執行函數中被調用。其中參數dwExitCode用來設置線程的退出碼。

5、BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode);

一般情況下，線程運行結束之后，線程函數正常返回，但是應用程序可以調用TerminateThread強行終止某一線程的執行。各參數含義如下： hThread：將被終結的線程的句柄；

dwExitCode：用于指定線程的退出碼。

使用TerminateThread()終止某個線程的執行是不安全的，可能會引起系統不穩定；雖然該函數立即終止線程的執行，但并不釋放線程所占用的資源。因此，一般不建議使用該函數。

6、BOOL PostThreadMessage(DWORD idThread，UINT Msg，WPARAM wParam，LPARAM lParam);該函數將一條消息放入到指定線程的消息隊列中，并且不等到消息被該線程處理時便返回。idThread：將接收消息的線程的ID；

Msg：指定用來發送的消息；

wParam：同消息有關的字參數；

lParam：同消息有關的長參數；

調用該函數時，如果即將接收消息的線程沒有創建消息循環，則該函數執行失敗。

1.4.Win32 API多線程編程例程

例程1 [MultiThread1] 一個簡單的線程。注意事項：

? Volatile:關鍵字：

volatile是要求C++編譯器不要自作聰明的把變量緩沖在寄存器里.因為該變量可能會被意外的修改。(多個線程或其他原因)

如從串口讀數據的場合,把變量緩沖在寄存器里,下次去讀寄存器就沒有意義了.因為串口的數據可能隨時會改變的.加鎖訪問用于多個線程的場合.在進入臨界區時是肯定要加鎖的.volatile也加上，以保證從內存中讀取變量的值.? 終止線程：

Windows終止線程運行的四種方法 終止線程運行

若要終止線程的運行，可以使用下面的方法：

? 線程函數返回（最好使用這種方法）。

? 通過調用 ExitThread 函數，線程將自行撤消（最好不要使用這種方法）。

? 同一個進程或另一個進程中的線程調用 TerminateThread 函數（應該避免使用這種方法）。

? 包含線程的進程終止運行（應該避免使用這種方法）。

下面將介紹終止線程運行的方法，并且說明線程終止運行時會出現什么情況。

? 線程函數返回

始終都應該將線程設計成這樣的形式，即當想要線程終止運行時，它們就能夠返回。這是確保所有線程資源被正確地清除的唯一辦法。

如果線程能夠返回，就可以確保下列事項的實現：

? 在線程函數中創建的所有 C++ 對象均將通過它們的撤消函數正確地撤消。

? 操作系統將正確地釋放線程堆棧使用的內存。

? 系統將線程的退出代碼（在線程的內核對象中維護）設置為線程函數的返回值。

? 系統將遞減線程內核對象的使用計數。? 使用 ExitThread 函數

可以讓線程調用 ExitThread 函數，以便強制線程終止運行：

VOID ExitThread(DWORD dwExitCode);

該函數將終止線程的運行，并導致操作系統清除該線程使用的所有操作系統資源。但是，C++ 資源（如 C++ 類對象）將不被撤消。由于這個原因，最好從線程函數返回，而不是通過調用 ExitThread 來返回。

當然，可以使用 ExitThread 的 dwExitThread 參數告訴系統將線程的退出代碼設置為什么。ExitThread 函數并不返回任何值，因為線程已經終止運行，不能執行更多的代碼。? 使用 TerminateThread 函數

調用 TerminateThread 函數也能夠終止線程的運行：

BOOL TerminateThread(HANDLE hThread, DWORD dwExitCode);

與 ExitThread 不同，ExitThread 總是撤消調用的線程，而 TerminateThread 能夠撤消任何線程。hThread 參數用于標識被終止運行的線程的句柄。當線程終止運行時，它的退出代碼成為你作為 dwExitCode 參數傳遞的值。同時，線程的內核對象的使用計數也被遞減。

注意 TerminateThread 函數是異步運行的函數，也就是說，它告訴系統你想要線程終止運行，但是，當函數返回時，不能保證線程被撤消。如果需要確切地知道該線程已經終止運行，必須調用 WaitForSingleObject 或者類似的函數，傳遞線程的句柄。

設計良好的應用程序從來不使用這個函數，因為被終止運行的線程收不到它被撤消的通知。線程不能正確地清除，并且不能防止自己被撤消。

注意 當使用返回或調用 ExitThread 的方法撤消線程時，該線程的內存堆棧也被撤消。但是，如果使用 TerminateThread，那么在擁有線程的進程終止運行之前，系統不撤消該線程的堆棧。Microsoft故意用這種方法來實現 TerminateThread。如果其他仍然正在執行的線程要引用強制撤消的線程堆棧上的值，那么其他的線程就會出現訪問違規的問題。如果將已經撤消的線程的堆棧留在內存中，那么其他線程就可以繼續很好地運行。

此外，當線程終止運行時，DLL 通常接收通知。如果使用 TerminateThread 強迫線程終止，DLL 就不接收通知，這能阻止適當的清除，在進程終止運行時撤消線程。當線程終止運行時，會發生下列操作：

? 線程擁有的所有用戶對象均被釋放。在 Windows 中，大多數對象是由包含創建這些對象的線程的進程擁有的。但是一個線程擁有兩個用戶對象，即窗口和掛鉤。當線程終止運行時，系統會自動撤消任何窗口，并且卸載線程創建的或安裝的任何掛鉤。其他對象只有在擁有線程的進程終止運行時才被撤消。

? 線程的退出代碼從 STILL_ACTIVE 改為傳遞給 ExitThread 或 TerminateThread 的代碼。

? 線程內核對象的狀態變為已通知。

? 如果線程是進程中最后一個活動線程，系統也將進程視為已經終止運行。

? 線程內核對象的使用計數遞減 1。

當一個線程終止運行時，在與它相關聯的線程內核對象的所有未結束的引用關閉之前，該內核對象不會自動被釋放。

一旦線程不再運行，系統中就沒有別的線程能夠處理該線程的句柄。然而別的線程可以調用 GetExitcodeThread 來檢查由 hThread 標識的線程是否已經終止運行。如果它已經終止運行，則確定它的退出代碼：

BOOL GetExitCodeThread(HANDLE hThread, PDOWRD pdwExitCode);退出代碼的值在 pdwExitCode 指向的 DWORD 中返回。如果調用 GetExitCodeThread 時線程尚未終止運行，該函數就用 STILL_ACTIVE 標識符（定義為 0x103）填入 DWORD。如果該函數運行成功，便返回 TRUE。

? 線程的定義：

例程2[MultiThread2] 傳送一個一個整型的參數到一個線程中，以及如何等待一個線程完成處理。

DWORD WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);

hHandle：為要監視的對象（一般為同步對象，也可以是線程）的句柄；

dwMilliseconds：為hHandle對象所設置的超時值，單位為毫秒；

當在某一線程中調用該函數時，線程暫時掛起，系統監視hHandle所指向的對象的狀態。如果在掛起的dwMilliseconds毫秒內，線程所等待的對象變為有信號狀態，則該函數立即返回；如果超時時間已經到達dwMilliseconds毫秒，但hHandle所指向的對象還沒有變成有信號狀態，函數照樣返回。參數dwMilliseconds有兩個具有特殊意義的值：0和INFINITE。若為0，則該函數立即返回；若為INFINITE，則線程一直被掛起，直到hHandle所指向的對象變為有信號狀態時為止。

例程3[MultiThread3] 傳送一個結構體給一個線程函數，可以通過傳送一個指向結構體的指針參數來完成。補充一點：如果你在void CMultiThread3Dlg::OnStart()函數中添加/* */語句，編譯運行你就會發現進度條不進行刷新，主線程也停止了反應。什么原因呢？這是因為WaitForSingleObject函數等待子線程（ThreadFunc）結束時，導致了線程死鎖。因為WaitForSingleObject函數會將主線程掛起（任何消息都得不到處理），而子線程ThreadFunc正在設置進度條，一直在等待主線程將刷新消息處理完畢返回才會檢測通知事件。這樣兩個線程都在互相等待，死鎖發生了，編程時應注意避免。

例程4[MultiThread4] 測試在Windows下最多可創建線程的數目。

二、MFC中的多線程開發

2.1 MFC對多線程編程的支持

MFC中有兩類線程，分別稱之為工作者線程和用戶界面線程。二者的主要區別在于工作者線程沒有消息循環，而用戶界面線程有自己的消息隊列和消息循環。

工作者線程沒有消息機制，通常用來執行后臺計算和維護任務，如冗長的計算過程，打印機的后臺打印等。用戶界面線程一般用于處理獨立于其他線程執行之外的用戶輸入，響應用戶及系統所產生的事件和消息等。但對于Win32的API編程而言，這兩種線程是沒有區別的，它們都只需線程的啟動地址即可啟動線程來執行任務。

在MFC中，一般用全局函數AfxBeginThread()來創建并初始化一個線程的運行，該函數有兩種重載形式，分別用于創建工作者線程和用戶界面線程。兩種重載函數原型和參數分別說明如下：

(1)CWinThread* AfxBeginThread(AFX_THREADPROC pfnThreadProc，LPVOID pParam，nPriority=THREAD_PRIORITY_NORMAL，UINT nStackSize=0，DWORD dwCreateFlags=0，LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);

PfnThreadProc：指向工作者線程的執行函數的指針，線程函數原型必須聲明如下： UINT ExecutingFunction(LPVOID pParam);請注意，ExecutingFunction()應返回一個UINT類型的值，用以指明該函數結束的原因。一般情況下，返回0表明執行成功。

pParam：傳遞給線程函數的一個32位參數，執行函數將用某種方式解釋該值。它可以是數值，或是指向一個結構的指針，甚至可以被忽略；

nPriority：線程的優先級。如果為0，則線程與其父線程具有相同的優先級；

nStackSize：線程為自己分配堆棧的大小，其單位為字節。如果nStackSize被設為0，則線程的堆棧被設置成與父線程堆棧相同大小； dwCreateFlags：如果為0，則線程在創建后立刻開始執行。如果為CREATE_SUSPEND，則線程在創建后立刻被掛起；

lpSecurityAttrs：線程的安全屬性指針，一般為NULL；

(2)CWinThread* AfxBeginThread(CRuntimeClass* pThreadClass，int nPriority=THREAD_PRIORITY_NORMAL，UINT nStackSize=0，DWORD dwCreateFlags=0，LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);

pThreadClass 是指向 CWinThread 的一個導出類的運行時類對象的指針，該導出類定義了被創建的用戶界面線程的啟動、退出等；其它參數的意義同形式1。使用函數的這個原型生成的線程也有消息機制，在以后的例子中我們將發現同主線程的機制幾乎一樣。下面對CWinThread類的數據成員及常用函數進行簡要說明。

? ? ? m_hThread：當前線程的句柄；

m_nThreadID:當前線程的ID；

m_pMainWnd：指向應用程序主窗口的指針

virtual BOOL CWinThread::InitInstance();重載該函數以控制用戶界面線程實例的初始化。初始化成功則返回非0值，否則返回0。用戶界面線程經常重載該函數，工作者線程一般不使用InitInstance()。

virtual int CWinThread::ExitInstance();在線程終結前重載該函數進行一些必要的清理工作。該函數返回線程的退出碼，0表示執行成功，非0值用來標識各種錯誤。同InitInstance()成員函數一樣，該函數也只適用于用戶界面線程。

2.2 MFC多線程編程實例

例程5 MultiThread5 為了與Win32 API對照，使用MFC 類庫編程實現例程3 MultiThread3。

例程6 MultiThread6[用戶界面線程] ? 創建用戶界面線程的步驟：

1.使用ClassWizard創建類CWinThread的派生類（以CUIThread類為例）class CUIThread : public CWinThread { DECLARE_DYNCREATE(CUIThread)protected: CUIThread();// protected constructor used by dynamic creation

// Attributes public: // Operations public:

// Overrides // ClassWizard generated virtual function overrides //{{AFX_VIRTUAL(CUIThread)public: virtual BOOL InitInstance();virtual int ExitInstance();//}}AFX_VIRTUAL // Implementation protected: virtual ~CUIThread();// Generated message map functions //{{AFX_MSG(CUIThread)

// NOTE-the ClassWizard will add and remove member functions here.//}}AFX_MSG

DECLARE_MESSAGE_MAP()};

2.重載函數InitInstance()和ExitInstance()。BOOL CUIThread::InitInstance(){ CFrameWnd* wnd=new CFrameWnd;wnd->Create(NULL,“UI Thread Window”);wnd->ShowWindow(SW_SHOW);wnd->UpdateWindow();m_pMainWnd=wnd;return TRUE;}

3.創建新的用戶界面線程 void CUIThreadDlg::OnButton1(){

}

請注意以下兩點：

A、在UIThreadDlg.cpp的開頭加入語句： #include “UIThread.h” B、把UIThread.h中類CUIThread()的構造函數的特性由 protected 改為 public。CUIThread* pThread=new CUIThread();pThread->CreateThread();

用戶界面線程的執行次序與應用程序主線程相同，首先調用用戶界面線程類的InitInstance()函數，如果返回TRUE，繼續調用線程的Run()函數，該函數的作用是運行一個標準的消息循環，并且當收到WM_QUIT消息后中斷，在消息循環過程中，Run()函數檢測到線程空閑時（沒有消息），也將調用OnIdle()函數，最后Run()函數返回，MFC調用ExitInstance()函數清理資源。

你可以創建一個沒有界面而有消息循環的線程，例如：你可以從CWinThread派生一個新類，在InitInstance函數中完成某項任務并返回FALSE，這表示僅執行InitInstance函數中的任務而不執行消息循環，你可以通過這種方法，完成一個工作者線程的功能。

三、線程間通訊

3.1通訊方式

一般而言,應用程序中的一個次要線程總是為主線程執行特定的任務,這樣,主線程和次要線程間必定有一個信息傳遞的渠道,也就是主線程和次要線程間要進行通信。這種線程間的通信不但是難以避免的，而且在多線程編程中也是復雜和頻繁的，下面將進行說明。

3.1.1使用全局變量進行通信

由于屬于同一個進程的各個線程共享操作系統分配該進程的資源，故解決線程間通信最簡單的一種方法是使用全局變量。對于標準類型的全局變量，建議使用volatile 修飾符，它告訴編譯器無需對該變量作任何的優化，即無需將它放到一個寄存器中，并且該值可被外部改變。如果線程間所需傳遞的信息較復雜，可以定義一個結構，通過傳遞指向該結構的指針進行傳遞信息。

3.1.2使用自定義消息

可以在一個線程的執行函數中向另一個線程發送自定義的消息來達到通信的目的。一個線程向另外一個線程發送消息是通過操作系統實現的。利用Windows操作系統的消息驅動機制，當一個線程發出一條消息時，操作系統首先接收到該消息，然后把該消息轉發給目標線程，接收消息的線程必須已經建立了消息循環。

3.2例程

例程GlobalObjectTest 該例程演示了如何利用全局變量進行通信

例程7[MultiThread7] 該例程演示了如何使用自定義消息進行線程間通信。首先，主線程向CCalculateThread線程發送消息WM_CALCULATE，CCalculateThread線程收到消息后進行計算，再向主線程發送WM_DISPLAY消息，主線程收到該消息后顯示計算結果。步驟：

四、線程的同步

4.1基本概念

雖然多線程能給我們帶來好處，但是也有不少問題需要解決。例如，對于像磁盤驅動器這樣獨占性系統資源，由于線程可以執行進程的任何代碼段，且線程的運行是由系統調度自動完成的，具有一定的不確定性，因此就有可能出現兩個線程同時對磁盤驅動器進行操作，從而出現操作錯誤；又例如，對于銀行系統的計算機來說，可能使用一個線程來更新其用戶數據庫，而用另外一個線程來讀取數據庫以響應儲戶的需要，極有可能讀數據庫的線程讀取的是未完全更新的數據庫，因為可能在讀的時候只有一部分數據被更新過。

使隸屬于同一進程的各線程協調一致地工作稱為線程的同步。MFC提供了多種同步對象，下面只介紹最常用的四種：

臨界區（CCriticalSection）

事件（CEvent）

互斥量（CMutex）

信號量（CSemaphore）

通過這些類，可以比較容易地做到線程同步。

4.2使用 CCriticalSection 類

當多個線程訪問一個獨占性共享資源時,可以使用“臨界區”對象。任一時刻只有一個線程可以擁有臨界區對象，擁有臨界區的線程可以訪問被保護起來的資源或代碼段，其他希望進入臨界區的線程將被掛起等待，直到擁有臨界區的線程放棄臨界區時為止，這樣就保證了不會在同一時刻出現多個線程訪問共享資源。

CCriticalSection類的用法非常簡單，步驟如下：

1.定義CCriticalSection類的一個全局對象（以使各個線程均能訪問），如CCriticalSection critical_section；

2.在訪問需要保護的資源或代碼之前，調用CCriticalSection類的成員Lock（）獲得臨界區對象： critical_section.Lock();3.在線程中調用該函數來使線程獲得它所請求的臨界區。如果此時沒有其它線程占有臨界區對象，則調用Lock()的線程獲得臨界區；否則，線程將被掛起，并放入到一個系統隊列中等待，直到當前擁有臨界區的線程釋放了臨界區時為止。

4.訪問臨界區完畢后，使用CCriticalSection的成員函數Unlock()來釋放臨界區：critical_section.Unlock();通俗講，就是線程A執行到critical_section.Lock();語句時，如果其它線程(B)正在執行critical_section.Lock();語句后且critical_section.Unlock();語句前的語句時，線程A就會等待，直到線程B執行完critical_section.Unlock();語句，線程A才會繼續執行。

例程8 MultiThread8 4.3使用 CEvent 類

CEvent 類提供了對事件的支持。事件是一個允許一個線程在某種情況發生時，喚醒另外一個線程的同步對象。例如在某些網絡應用程序中，一個線程（記為A）負責監聽通訊端口，另外一個線程（記為B）負責更新用戶數據。通過使用CEvent 類，線程A可以通知線程B何時更新用戶數據。每一個CEvent 對象可以有兩種狀態：有信號狀態和無信號狀態。線程監視位于其中的CEvent 類對象的狀態，并在相應的時候采取相應的操作。

在MFC中，CEvent 類對象有兩種類型：人工事件和自動事件。一個自動CEvent 對象在被至少一個線程釋放后會自動返回到無信號狀態；而人工事件對象獲得信號后，釋放可利用線程，但直到調用成員函數ReSetEvent()才將其設置為無信號狀態。在創建CEvent 類的對象時，默認創建的是自動事件。CEvent 類的各成員函數的原型和參數說明如下：

1、CEvent(BOOL bInitiallyOwn=FALSE，BOOL bManualReset=FALSE，LPCTSTR lpszName=NULL，LPSECURITY_ATTRIBUTES lpsaAttribute=NULL);bInitiallyOwn：指定事件對象初始化狀態，TRUE為有信號，FALSE為無信號；

bManualReset：指定要創建的事件是屬于人工事件還是自動事件。TRUE為人工事件，FALSE為自動事件；

后兩個參數一般設為NULL，在此不作過多說明。

2、BOOL CEvent：：SetEvent();

將 CEvent 類對象的狀態設置為有信號狀態。如果事件是人工事件，則 CEvent 類對象保持為有信號狀態，直到調用成員函數ResetEvent()將 其重新設為無信號狀態時為止。如果CEvent 類對象為自動事件，則在SetEvent()將事件設置為有信號狀態后，CEvent 類對象由系統自動重置為無信號狀態。

如果該函數執行成功，則返回非零值，否則返回零。

3、BOOL CEvent：：ResetEvent();

該函數將事件的狀態設置為無信號狀態，并保持該狀態直至SetEvent()被調用時為止。由于自動事件是由系統自動重置，故自動事件不需要調用該函數。如果該函數執行成功，返回非零值，否則返回零。一般通過調用WaitForSingleObject函數來監視事件狀態。前面已經介紹了該函數。由于語言描述的原因，CEvent 類的理解確實有些難度，只要通過下面例程，多看幾遍就可理解。例程9 MultiThread9 仔細分析這兩個線程函數, 就會正確理解CEvent 類。線程WriteD執行到 WaitForSingleObject(eventWriteD.m_hObject,INFINITE);處等待，直到事件eventWriteD為有信號該線程才往下執行，因為eventWriteD對象是自動事件，則當WaitForSingleObject()返回時，系統自動把eventWriteD對象重置為無信號狀態。

4.4使用CMutex 類

互斥對象與臨界區對象很像.互斥對象與臨界區對象的不同在于:互斥對象可以在進程間使用,而臨界區對象只能在同一進程的各線程間使用。當然，互斥對象也可以用于同一進程的各個線程間，但是在這種情況下，使用臨界區會更節省系統資源，更有效率。

4.5使用CSemaphore 類

當需要一個計數器來限制可以使用某個線程的數目時，可以使用“信號量”對象。CSemaphore 類的對象保存了對當前訪問某一指定資源的線程的計數值，該計數值是當前還可以使用該資源的線程的數目。如果這個計數達到了零，則所有對這個CSemaphore 類對象所控制的資源的訪問嘗試都被放入到一個隊列中等待，直到超時或計數值不為零時為止。一個線程被釋放已訪問了被保護的資源時，計數值減1；一個線程完成了對被控共享資源的訪問時，計數值增1。這個被CSemaphore 類對象所控制的資源可以同時接受訪問的最大線程數在該對象的構建函數中指定。

CSemaphore 類的構造函數原型及參數說明如下：

CSemaphore(LONG lInitialCount=1，LONG lMaxCount=1，LPCTSTR pstrName=NULL，LPSECURITY_ATTRIBUTES lpsaAttributes=NULL);lInitialCount：信號量對象的初始計數值，即可訪問線程數目的初始值；

lMaxCount：信號量對象計數值的最大值，該參數決定了同一時刻可訪問由信號量保護的資源的線程最大數目；

后兩個參數在同一進程中使用一般為NULL，不作過多討論；

在用CSemaphore 類的構造函數創建信號量對象時要同時指出允許的最大資源計數和當前可用資源計數。一般是將當前可用資源計數設置為最大資源計數，每增加一個線程對共享資源的訪問，當前可用資源計數就會減1，只要當前可用資源計數是大于0的，就可以發出信號量信號。但是當前可用計數減小到0時，則說明當前占用資源的線程數已經達到了所允許的最大數目，不能再允許其它線程的進入，此時的信號量信號將無法發出。線程在處理完共享資源后，應在離開的同時通過ReleaseSemaphore()函數將當前可用資源數加1。例程10 MultiThread10 為了文件中能夠正確使用同步類，在文件開頭添加： #include “afxmt.h” 定義信號量對象和一個字符數組，為了能夠在不同線程間使用，定義為全局變量：CSemaphore semaphoreWrite(2,2);//資源最多訪問線程2個，當前可訪問線程數2個

在信號量對象有信號的狀態下，線程執行到WaitForSingleObject語句處繼續執行，同時可用線程數減1；若線程執行到WaitForSingleObject語句時信號量對象無信號，線程就在這里等待，直到信號量對象有信號線程才往下執行。

第四篇：多線程實驗報告

寧波工程學院電信學院計算機教研室

實驗報告

課程名稱： Java 2 姓 名： *** 實驗項目： 多線程實驗 學 號： **** 指導教師： **** 班 級： **** 實驗位置： 電信樓機房 日 期：

一、實驗目的

1、掌握多線程編程的特點和工作原理；

2、掌握編寫線程程序的方法

3、了解線程的調度和執行過程

4、掌握線程同步機理

二、實驗環境

windows記事本，java jdk 1.60版本，cmd命令運行窗口

三、實驗內容 實驗一：

應用Java中線程的概念寫一個Java程序（包括一個測試線程程序類TestThread，一個Thread類的子類PrintThread）。在測試程序中用子類PrintThread創建2個線程，使得其中一個線程運行時打印10次“線程1正在運行”，另一個線程運行時打印5次“線程2正在運行

源程序：

public class A { public static void main(String args[]){

Test1 A1;

Test2 A2;

A1=new Test1();

A2=new Test2();

A1.start();

A2.start();} } class PrintThread extends Thread { } class Test1 extends PrintThread { public void run(){

for(int i=1;i<=10;i++)

{

System.out.println(“線程1正在運行！”);

} } } class Test2 extends PrintThread { public void run(){

for(int i=1;i<=5;i++)

{

System.out.println(“線程2正在運行！”);

} } } 運行結果：

實驗二：

將上述程序用Runnable接口改寫，并上機驗證源程序 public class D { public static void main(String args[]){

Move move=new Move();

move.test1.start();

move.test2.start();} } class Move implements Runnable { Thread test1,test2;Move(){

test1=new Thread(this);

test1.setName(“線程1正在運行！”);

test2=new Thread(this);

test2.setName(“線程2正在運行！”);} public void run(){

if(Thread.currentThread()==test1)

{

for(int i=1;i<=10;i++)

{

System.out.println(test1.getName());

} } } else { for(int i=1;i<=5;i++){

System.out.println(test2.getName());} } 運行結果：

實驗三：

import java.awt.*;import java.awt.event.*;public class E

{ public static void main(String args[])

{ new FrameMoney();

} } class FrameMoney extends Frame implements Runnable,ActionListener { int money=100;

TextArea text1,text2;

Thread 會計,出納;

int weekDay;

Button start=new Button(“開始演示”);

FrameMoney()

{ 會計=new Thread(this);

出納=new Thread(this);

text1=new TextArea(12,15);

text2=new TextArea(12,15);

setLayout(new FlowLayout());

add(start);

add(text1);

add(text2);

setVisible(true);

setSize(360,300);

validate();

addWindowListener(new WindowAdapter()

{ public void windowClosing(WindowEvent e)

{System.exit(0);

}

});

start.addActionListener(this);

}

public void actionPerformed(ActionEvent e)

{ if(!(出納.isAlive()))

{ 會計=new Thread(this);

出納=new Thread(this);

}

try

{ 會計.start();

出納.start();

}

catch(Exception exp){}

}

public synchronized void 存取(int number)//存取方法

{ if(Thread.currentThread()==會計)

{ text1.append(“今天是星期”+weekDay+“n”);

for(int i=1;i<=3;i++)//會計使用存取方法存入90元，存入30元，稍歇一下

{ money=money+number;

//這時出納仍不能使用存取方法

try { Thread.sleep(1000);//因為會計還沒使用完存取方法

}

catch(InterruptedException e){}

text1.append(“帳上有”+money+“萬n”);

}

}

else if(Thread.currentThread()==出納)

{ text2.append(“今天是星期 ”+weekDay+“n”);

for(int i=1;i<=2;i++)//出納使用存取方法取出30元，取出15元，稍歇一下

{ money=money-number/2;

//這時會計仍不能使用存取方法

try { Thread.sleep(1000);//因為出納還沒使用完存取方法

}

catch(InterruptedException e){}

text2.append(“帳上有”+money+“萬n”);

}

}

}

public void run()

{ if(Thread.currentThread()==會計||Thread.currentThread()==出納)

{ for(int i=1;i<=3;i++)//從周一到周三會計和出納都要使用帳本

{ weekDay=i;

存取(30);

}

}

} }

運行結果：

}

四、實驗心得與小結

通過本次實驗，基本了解了線程的概念，作用，方法以及使用規則。1.首先：java 程序是建立在線程之上的。.2.創建線程必須繼承 Thread class 它已經為線程的創建和運行做了必要的配置。run是線程就重要的方法。你必須覆寫這個方法達到你想要的目的。3.run方法所包含的代碼就是和其他線程同時運行的代碼以達到同一時刻運行多段代碼的目的。當終止了 run以后。這個線程也就結束了。調用線程的 start方法才會執行 run方法。

4.線程的生命周期：新建——Thread.State.NEW：當一個 Thread 類或者其子類的對象被聲明并創建時，新的線程對象處于新建狀態，此時它已經有了相應的內存空間和其他資源start方法尚未被調整用就緒可執行狀態——Thread.State.RUNNABLE：處于新建狀態的線程被啟動后，將進入線程隊列排隊，這個時候具備了運行的條件，一旦輪到 CPU 的時候，就可以脫離創建它的主線程獨立開始自己的生命周期運行：就緒的線程被調度進入運行狀態，每一個 Thread 類及其子類的對象都有一個重要的run方法，當線程對象被調度執行的時候，它將自動調用本對象的 run方法，從第一句代碼開始執行。

第五篇：嵌入式多線程 實習總結(有感想)

解壓應用程序以及多線程應用程序設計

實習過程

首先完成上次實習沒有完成的解壓應用程序的部分。設置好宿主機和目標機的IP地址后，運行FTP軟件。將壓縮包從右側的宿主機本地目錄“拖到”左側的目標機目錄中。最后在超級終端上完成解壓。

其次完成多線程的部分，運行虛擬機后，步驟如下：

1、掛載NFS服務。

系統設置部分需要完成關閉防火墻，設置宿主機和目標機IP（需在一個網段

內），配置NFS服務器。之后：service nfs start。啟動。

掛載NFS時候出現了問題。當設置宿主機IP為192.168.1.155之后，在虛擬機的LINUX終端里mount了192.168.1.155（也就是自己掛載自己），然后總感覺不對，鼓搗了半天，又在超級終端里ifconfig之后出現了三個IP地址，第一個是inet addr，第二個是broadcast，第三個是子網掩碼，但是我當時沒看懂第二個地址，于是又把宿主機的IP設置為了192.168.1.255。老師一說才想起來計算機網絡課上講的，C類的網絡地址，后8位若為全1，應該是廣播地址才對。反正這塊亂了。

分析后，覺得主要原因還是因為對掛載的深層含義不懂，沒明白其實是目標機

想要宿主機里的東西，所以要從超級終端里掛載host下的目錄。

最終完成掛載。

Mount –t nfs 192.168.0.2:/arm2410cl/ /mnt/nfs（老師說這里直接寫/mnt不好，會覆蓋掉mnt目錄，如果以后要掛載其他的應用，就不好弄了。）

2、第一步成功后，在超級終端上cd arm2410cl/exp/basic/02_pthread。成功進入，make

語句后，用命令：./pthread成功運行。

3、在虛擬機的LINUX終端上，也進入了arm2410cl/exp/basic/01_hello，但是不能運行

hello，用gcc hello.c –o hello之后，./hello就能運行了。用這個方法，完成02_pthread，發現gcc提示幾個相似錯誤，都跟main函數里的一個函數有關。這塊還沒弄懂為什么。準備周四過去再研究研究。這塊是重點。

實習總結

總體我覺得我們班同學實習的氛圍非常好，沒有人開小差，每個人都很認真的在弄自己的東西，不會的就趕緊問旁邊的人，這次實習的內容并不多，但是確實很難理解。多線程的部分主要就是體會什么是交叉編譯，實習指導書里關于多線程的相關介紹好多，需要下來仔細研究跟體會，basic里面還有好多代碼，也可以都試試和看看。