java里 对线程的wait方法只有在synchronized下才有用吗？

不是，可以不用synchronized，但Java推荐在调用wait方法前将对象锁住
其实，从并发的角度考虑，wait是不能放在synchronized锁里的，会引起死锁。
试考虑，当wait和notify方法都在synchronized锁里的时候，调用wait方法前将对象锁住，然后调用wait方法，线程被挂起，需要其它线程调用notify将其唤醒。
由于notify方法也在synchronized里面，其它线程调用notify的时候要获得对象的锁，但此时锁已经被wait所在的线程持有，而且wait线程已经被挂起，所以notify因为无法获得锁而挂起，这样二者相互等待，导致死锁。
Java里面可以将wait和notify放在synchronized里面，是因为Java是这样处理的：
在synchronized代码被执行期间，线程调用对象的wait()方法，会释放对象锁标志，然后进入等待状态，然后由其它线程调用notify()或者notifyAll()方法通知正在等待的线程。

引言

随着双核 四核等多核处理器的推广 多核处理器或超线程单核处理器的计算机已很常见 基于多核处理的编程技术也开始受到程序员们普遍关注 这其中一个重要的方面就是构建多线程应用程序（因为不使用多线程的话 开发人员就不能充分发挥多核计算机的强大性能）

本文针对的是构建基于单核计算机的多线程应用程序 目的在于介绍多线程相关的基本概念 内涵 以及如何通过System Threading命名空间的类 委托和BackgroundWorker组件等三种手段构建多线程应用程序

本文如果能为刚接触多线程的朋友起到抛砖引玉的作用也就心满意足了 当然 本人才疏学浅 文中难免会有不足或错误的地方 恳请各位朋友多多指点

理解多线程

我们通常理解的应用程序就是一个 exe文件 当运行 exe应用程序以后 系统会在内存中为该程序分配一定的空间 同时加载一些该程序所需的资源 其实这就可以称为创建了一个进程 可以通过Windows任务管理器查看这个进程的相关信息 如映像名称 用户名 内存使用 PID（唯一的进程标示）等 如图下所示

而线程则只是进程中的一个基本执行单元 一个应用程序往往只有一个程序入口 如

[STAThread]

static void Main()   //应用程序主入口点

{

Application EnableVisualStyles();

Application SetCompatibleTextRenderingDefault(false);

Application Run(new MainForm());

}

进程会包含一个进入此入口的线程 我们称之为主线程 其中 特性 [STAThread] 指示应用程序的默认线程模型是单线程单元（相关信息可参考 us/library/system stathreadattribute(VS ) aspx） 只包含一个主线程的进程是线程安全的 相当于程序仅有一条工作线 只有完成了前面的任务才能执行排在后面的任务

然当在程序处理一个很耗时的任务 如输出一个大的文件或远程访问数据库等 此时的窗体界面程序对用户而言基本像是没反应一样 菜单 按钮等都用不了 因为窗体上控件的响应事件也是需要主线程来执行的 而主线程正忙着干其他的事 控件响应事件就只能排队等著主线程忙完了再执行

为了克服单线程的这个缺陷 Win API可以让主线程再创建其他的次线程 但不论是主线程还是次线程都是进程中独立的执行单元 可以同时访问共享的数据 这样就有了多线程这个概念

相信到这 应该对多线程有个比较感性的认识了 但笔者在这要提醒一下 基于单核计算机的多线程其实只是 *** 作系统施展的一个障眼法而已（但这不会干扰我们理解构建多线程应用程序的思路） 他并不能缩短完成所有任务的时间 有时反而还会因为使用过多的线程而降低性能 延长时间 之所以这样 是因为对于单CPU而言 在一个单位时间（也称时间片）内 只能执行一个线程 即只能干一件事 当一个线程的时间片用完时 系统会将该线程挂起 下一个时间内再执行另一个线程 如此 CPU以时间片为间隔在多个线程之间交替执行运算（其实这里还与每个线程的优先级有关 级别高的会优先处理） 由于交替时间间隔很短 所以造成了各个线程都在 同时 工作的假象 而如果线程数目过多 由于系统挂起线程时要记录线程当前的状态数据等 这样又势必会降低程序的整体性能 但对于这些 多核计算机就能从本质上（真正的同时工作）提高程序的执行效率

线程异步与线程同步

从线程执行任务的方式上可以分为线程同步和线程异步 而为了方便理解 后面描述中用 同步线程 指代与线程同步相关的线程 同样 用 异步线程 表示与线程异步相关的线程

线程异步就是解决类似前面提到的执行耗时任务时界面控件不能使用的问题 如创建一个次线程去专门执行耗时的任务 而其他如界面控件响应这样的任务交给另一个线程执行（往往由主线程执行） 这样 两个线程之间通过线程调度器短时间（时间片）内的切换 就模拟出多个任务 同时 被执行的效果

线程异步往往是通过创建多个线程执行多个任务 多个工作线同时开工 类似多辆在宽广的公路上并行的汽车同时前进 互不干扰（读者要明白 本质上并没有 同时 仅仅是 *** 作系统玩的一个障眼法 但这个障眼法却对提高我们的程序与用户之间的交互 以及提高程序的友好性很有用 不是吗）

在介绍线程同步之前 先介绍一个与此紧密相关的概念——并发问题

前面提到 线程都是独立的执行单元 可以访问共享的数据 也就是说 在一个拥有多个次线程的程序中 每个线程都可以访问同一个共享的数据 再稍加思考你会发现这样可能会出问题 由于线程调度器会随机的挂起某一个线程（前面介绍的线程间的切换） 所以当线程a对共享数据D的访问（修改 删除等 *** 作）完成之前被挂起 而此时线程b又恰好去访问数据D 那么线程b访问的则是一个不稳定的数据 这样就会产生非常难以发现bug 由于是随机发生的 产生的结果是不可预测的 这样样的bug也都很难重现和调试 这就是并发问题

为了解决多线程共同访问一个共享资源（也称互斥访问）时产生的并发问题 线程同步就应运而生了 线程同步的机理 简单的说 就是防止多个线程同时访问某个共享的资源 做法很简单 标记访问某共享资源的那部分代码 当程序运行到有标记的地方时 CLR（具体是什么可以先不管 只要知道它能控制就行）对各线程进行调整 如果已有线程在访问一资源 CLR就会将其他访问这一资源的线程挂起 直到前一线程结束对该资源的访问 这样就保证了同一时间只有一个线程访问该资源 打个比方 就如某资源放在只有一独木桥相连的孤岛上 如果要使用该资源 大家就得排队 一个一个来 前面的回来了 下一个再去 前面的没回来 后面的就原地待命

这里只是把基本的概念及原理做了一个简单的阐述 不至于看后面的程序时糊里糊涂的 具体如何编写代码 下面的段落将做详细介绍

创建多线程应用程序

这里做一个简单的说明 下面主要通过介绍通过System Threading命名空间的类 委托和BackgroundWorker组件三种不同的手段构建多线程应用程序 具体会从线程异步和线程同步两个方面来阐述

通过System Threading命名空间的类构建

在 NET平台下 System Threading命名空间提供了许多类型来构建多线程应用程序 可以说是专为多线程服务的 由于本文仅是想起到一个 抛砖引玉 的作用 所以对于这一块不会探讨过多 过深 主要使用System Threading Thread类

先从System Threading Thread类本身相关的一个小例子说起 代码如下 解释见注释

using System;

using System Threading; //引入System Threading命名空间

namespace MultiThread

{

class Class

{

static void Main(string[] args)

{

Console WriteLine( 显示当前线程的相关信息 );

//声明线程变量并赋值为当前线程

Thread primaryThread = Thread CurrentThread;

//赋值线程的名称

primaryThread Name = 主线程 ;

//显示线程的相关信息

Console WriteLine( 线程的名字 { } primaryThread Name);

Console WriteLine( 线程是否启动？ { } primaryThread IsAlive);

Console WriteLine( 线程的优先级 { } primaryThread Priority);

Console WriteLine( 线程的状态 { } primaryThread ThreadState);

Console ReadLine();

}

}

}

输出结果如下

显示当前线程的相关信息

线程的名字 主线程

线程是否启动？ True

线程的优先级 Normal

线程的状态 Running

对于上面的代码不想做过多解释 只说一下Thread CurrentThread得到的是执行当前代码的线程

异步调用线程

这里先说一下前台线程与后台线程 前台线程能阻止应用程序的终止 既直到所有前台线程终止后才会彻底关闭应用程序 而对后台线程而言 当所有前台线程终止时 后台线程会被自动终止 不论后台线程是否正在执行任务 默认情况下通过Thread Start()方法创建的线程都自动为前台线程 把线程的属性IsBackground设为true时就将线程转为后台线程

下面先看一个例子 该例子创建一个次线程执行打印数字的任务 而主线程则干其他的事 两者同时进行 互不干扰

using System;

using System Threading;

using System Windows Forms;

namespace MultiThread

{

class Class

{

static void Main(string[] args)

{

Console WriteLine( 两个线程同时工作 );

//主线程 因为获得的是当前在执行Main()的线程

Thread primaryThread = Thread CurrentThread;

primaryThread Name = 主线程 ;

Console WriteLine( > { } 在执行主函数 Main() Thread CurrentThread Name);

//次线程 该线程指向PrintNumbers()方法

Thread SecondThread = new Thread(new ThreadStart(PrintNumbers));

SecondThread Name = 次线程 ;

//次线程开始执行指向的方法

SecondThread Start();

//同时主线程在执行主函数中的其他任务

MessageBox Show( 正在执行主函数中的任务 主线程在工作 );

Console ReadLine();

}

//打印数字的方法

static void PrintNumbers()

{

Console WriteLine( > { } 在执行打印数字函数 PrintNumber() Thread CurrentThread Name);

Console WriteLine( 打印数字 );

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

{

Console Write( { } i);

//Sleep()方法使当前线程挂等待指定的时长在执行 这里主要是模仿打印任务

Thread Sleep( );

}

Console WriteLine();

}

}

}

程序运行后会看到一个窗口d出 如图所示 同时控制台窗口也在不断的显示数字

输出结果为

两个线程同时工作

> 主线程 在执行主函数 Main()

> 次线程 在执行打印数字函数 PrintNumber()

打印数字

这里稍微对 Thread SecondThread = new Thread(new ThreadStart(PrintNumbers)); 这一句做个解释 其实 ThreadStart 是 System Threading 命名空间下的一个委托 其声明是 public delegate void ThreadStart() 指向不带参数 返回值为空的方法 所以当使用 ThreadStart 时 对应的线程就只能调用不带参数 返回值为空的方法 那非要指向含参数的方法呢？在System Threading命名空间下还有一个ParameterizedThreadStart 委托 其声明是 public delegate void ParameterizedThreadStart(object obj) 可以指向含 object 类型参数的方法 这里不要忘了 object 可是所有类型的父类哦 有了它就可以通过创建各种自定义类型 如结构 类等传递很多参数了 这里就不再举例说明了

并发问题

这里再通过一个例子让大家切实体会一下前面说到的并发问题 然后再介绍线程同步

using System;

using System Threading;

namespace MultiThread

{

class Class

{

static void Main(string[] args)

{

Console WriteLine( 并发问题演示 );

//创建一个打印对象实例

Printer printer = new Printer();

//声明一含 个线程对象的数组

Thread[] threads = new Thread[ ];

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

{

//将每一个线程都指向printer的PrintNumbers()方法

threads[i] = new Thread(new ThreadStart(printer PrintNumbers));

//给每一个线程编号

threads[i] Name = i ToString() + 号线程 ;

}

//开始执行所有线程

foreach (Thread t in threads)

t Start();

Console ReadLine();

}

}

//打印类

public class Printer

{

//打印数字的方法

public void PrintNumbers()

{

Console WriteLine( > { } 正在执行打印任务 开始打印数字 Thread CurrentThread Name);

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

{

Random r = new Random();

//为了增加冲突的几率及 使各线程各自等待随机的时长

Thread Sleep( r Next( ));

//打印数字

Console Write( { } i);

}

Console WriteLine();

}

}

}

上面的例子中 主线程产生的 个线程同时访问同一个对象实例printer的方法PrintNumbers() 由于没有锁定共享资源（注意 这里是指控制台） 所以在PrintNumbers()输出到控制台之前 调用PrintNumbers()的线程很可能被挂起 但不知道什么时候（或是否有）挂起 导致得到不可预测的结果 如下是两个不同的结果（当然 读者的运行结果可能会是其他情形）

情形一

情形二

线程同步

线程同步的访问方式也称为阻塞调用 即没有执行完任务不返回 线程被挂起 可以使用C#中的lock关键字 在此关键字范围类的代码都将是线程安全的 lock关键字需定义一个标记 线程进入锁定范围是必须获得这个标记 当锁定的是一个实例级对象的私有方法时使用方法本身所在对象的引用就可以了 将上面例子中的打印类Printer稍做改动 添加lock关键字 代码如下

//打印类

public class Printer

{

public void PrintNumbers()

{

//使用lock关键字 锁定d的代码是线程安全的

lock (this)

{

Console WriteLine( > { } 正在执行打印任务 开始打印数字 Thread CurrentThread Name);

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

{

Random r = new Random();

//为了增加冲突的几率及 使各线程各自等待随机的时长

Thread Sleep( r Next( ));

//打印数字

Console Write( { } i);

}

Console WriteLine();

}

}

}

}

同步后执行结果如下

也可以使用System Threading命名空间下的Monitor类进行同步 两者内涵是一样的 但Monitor类更灵活 这里就不在做过多的探讨 代码如下

//打印类

public class Printer

{

public void PrintNumbers()

{

Monitor Enter(this);

try

{

Console WriteLine( > { } 正在执行打印任务 开始打印数字 Thread CurrentThread Name);

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

{

Random r = new Random();

//为了增加冲突的几率及 使各线程各自等待随机的时长

Thread Sleep( r Next( ));

//打印数字

Console Write( { } i);

}

Console WriteLine();

}

finally

{

Monitor Exit(this);

}

}

}

输出结果与上面的一样

通过委托构建多线程应用程序

在看下面的内容时要求对委托有一定的了解 如果不清楚的话推荐参考一下博客园张子阳的《C# 中的委托和事件》 里面对委托与事件进行由浅入深的较系统的讲解

这里先举一个关于委托的简单例子 具体解说见注释

using System;

namespace MultiThread

{

//定义一个指向包含两个int型参数 返回值为int型的函数的委托

public delegate int AddOp(int x int y);

class Program

{

static void Main(string[] args)

{

//创建一个指向Add()方法的AddOp对象p

AddOp pAddOp = new AddOp(Add);

//使用委托间接调用方法Add()

Console WriteLine( + = { } pAddOp( ));

Console ReadLine();

}

//求和的函数

static int Add(int x int y)

{

int sum = x + y;

return sum;

}

}

}

运行结果为

+ =

线程异步

先说明一下 这里不打算讲解委托线程异步或同步的参数传递 获取返回值等 只是做个一般性的开头而已 如果后面有时间了再另外写一篇关于多线程中参数传递 获取返回值的文章

注意观察上面的例子会发现 直接使用委托实例 pAddOp( ) 就调用了求和方法 Add() 很明显 这个方法是由主线程执行的 然而 委托类型中还有另外两个方法——BeginInvoke()和EndInvoke() 下面通过具体的例子来说明 将上面的例子做适当改动 如下

using System;

using System Threading;

using System Runtime Remoting Messaging;

namespace MultiThread

{

//声明指向含两个int型参数 返回值为int型的函数的委托

public delegate int AddOp(int x int y);

class Program

{

static void Main(string[] args)

{

Console WriteLine( 委托异步线程 两个线程 同时 工作 );

//显示主线程的唯一标示

Console WriteLine( 调用Main()的主线程的线程ID是 { } Thread CurrentThread ManagedThreadId);

//将委托实例指向Add()方法

AddOp pAddOp = new AddOp(Add);

//开始委托次线程调用 委托BeginInvoke()方法返回的类型是IAsyncResult

//包含这委托指向方法结束返回的值 同时也是EndInvoke()方法参数

IAsyncResult iftAR = pAddOp BeginInvoke( null null);

Console WriteLine( nMain()方法中执行其他任务 n );

int sum = pAddOp EndInvoke(iftAR);

Console WriteLine( + = { } sum);

Console ReadLine();

}

//求和方法

static int Add(int x int y)

{

//指示调用该方法的线程ID ManagedThreadId是线程的唯一标示

Console WriteLine( 调用求和方法 Add()的线程ID是 { } Thread CurrentThread ManagedThreadId);

//模拟一个过程 停留 秒

Thread Sleep( );

int sum = x + y;

return sum;

}

}

}

运行结果如下

委托异步线程 两个线程 同时 工作

调用Main()的主线程的线程ID是

Main()方法中执行其他任务

调用求和方法 Add()的线程ID是

+ =

线程同步

委托中的线程同步主要涉及到上面使用的pAddOp BeginInvoke( null null)方法中后面两个为null的参数 具体的可以参考相关资料 这里代码如下 解释见代码注释

using System;

using System Threading;

using System Runtime Remoting Messaging;

namespace MultiThread

{

//声明指向含两个int型参数 返回值为int型的函数的委托

public delegate int AddOp(int x int y);

class Program

{

static void Main(string[] args)

{

Console WriteLine( 线程同步 阻塞 调用 两个线程工作 );

Console WriteLine( Main() invokee on thread { } Thread CurrentThread ManagedThreadId);

//将委托实例指向Add()方法

AddOp pAddOp = new AddOp(Add);

IAsyncResult iftAR = pAddOp BeginInvoke( null null);

//判断委托线程是否执行完任务

//没有完成的话 主线程就做其他的事

while (!iftAR IsCompleted)

{

Console WriteLine( Main()方法工作中 );

Thread Sleep( );

}

//获得返回值

int answer = pAddOp EndInvoke(iftAR);

Console WriteLine( + = { } answer);

Console ReadLine();

}

//求和方法

static int Add(int x int y)

{

//指示调用该方法的线程ID ManagedThreadId是线程的唯一标示

Console WriteLine( 调用求和方法 Add()的线程ID是 { } Thread CurrentThread ManagedThreadId);

//模拟一个过程 停留 秒

Thread Sleep( );

int sum = x + y;

return sum;

}

}

}

运行结果如下

线程同步 阻塞 调用 两个线程工作

Main() invokee on thread

Main()方法工作中

调用求和方法 Add()的线程ID是

Main()方法工作中

Main()方法工作中

Main()方法工作中

Main()方法工作中

+ =

BackgroundWorker组件

BackgroundWorker组件位于工具箱中 用于方便的创建线程异步的程序 新建一个WindowsForms应用程序 界面如下

代码如下 解释参见注释

private void button _Click(object sender EventArgs e)

{

try

{

//获得输入的数字

int numOne = int Parse(this textBox Text);

int numTwo = int Parse(this textBox Text);

//实例化参数类

AddParams args = new AddParams(numOne numTwo);

//调用RunWorkerAsync()生成后台线程 同时传入参数

this backgroundWorker RunWorkerAsync(args);

}

catch (Exception ex)

{

MessageBox Show(ex Message);

}

}

//backgroundWorker新生成的线程开始工作

private void backgroundWorker _DoWork(object sender DoWorkEventArgs e)

{

//获取传入的AddParams对象

AddParams args = (AddParams)e Argument;

//停留 秒 模拟耗时任务

Thread Sleep( );

//返回值

e Result = args a + args b;

}

//当backgroundWorker 的DoWork中的代码执行完后会触发该事件

//同时 其执行的结果会包含在RunWorkerCompletedEventArgs参数中

private void backgroundWorker _RunWorkerCompleted(object sender RunWorkerCompletedEventArgs e)

{

//显示运算结果

MessageBox Show( 运行结果为 + e Result ToString() 结果 );

}

}

//参数类 这个类仅仅起到一个记录并传递参数的作用

class AddParams

{

public int a b;

public AddParams(int numb int numb )

{

a = numb ;

b = numb ;

}

}

注意 在计算结果的同时 窗体可以随意移动 也可以重新在文本框中输入信息 这就说明主线程与backgroundWorker组件生成的线程是异步的

总结

lishixinzhi/Article/program/net/201311/11400

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：同消息有关的长参数；
调用该函数时，如果即将接收消息的线程没有创建消息循环，则该函数执行失败。
顺便说一下WaitForSingleObject函数，其函数原型为：
DWORD WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);
hHandle为要监视的对象（一般为同步对象，也可以是线程）的句柄；
dwMilliseconds为hHandle对象所设置的超时值，单位为毫秒；
当在某一线程中调用该函数时，线程暂时挂起，系统监视hHandle所指向的对象的状态。如果在挂起的dwMilliseconds毫秒内，线程所等待的对象变为有信号状态，则该函数立即返回；如果超时时间已经到达dwMilliseconds毫秒，但hHandle所指向的对象还没有变成有信号状态，函数照样返回。参数dwMilliseconds有两个具有特殊意义的值：0和INFINITE。若为0，则该函数立即返回；若为INFINITE，则线程一直被挂起，直到hHandle所指向的对象变为有信号状态时为止

当多个线程访问一个独占性共享资源时,可以使用“临界区”对象。任一时刻只有一个线程可以拥有临界区对象，拥有临界区的线程可以访问被保护起来的资源或代码段，其他希望进入临界区的线程将被挂起等待，直到拥有临界区的线程放弃临界区时为止，这样就保证了不会在同一时刻出现多个线程访问共享资源。
CCriticalSection类的用法非常简单，步骤如下：
　
定义CCriticalSection类的一个全局对象（以使各个线程均能访问），如CCriticalSection critical_section；
在访问需要保护的资源或代码之前，调用CCriticalSection类的成员Lock（）获得临界区对象： critical_sectionLock();
在线程中调用该函数来使线程获得它所请求的临界区。如果此时没有其它线程占有临界区对象，则调用Lock()的线程获得临界区；否则，线程将被挂起，并放入到一个系统队列中等待，直到当前拥有临界区的线程释放了临界区时为止。
访问临界区完毕后，使用CCriticalSection的成员函数Unlock()来释放临界区：critical_sectionUnlock();
再通俗一点讲，就是线程A执行到critical_sectionLock();语句时，如果其它线程(B)正在执行critical_sectionLock();语句后且critical_section Unlock();语句前的语句时，线程A就会等待，直到线程B执行完critical_section Unlock();语句，线程A才会继续执行。

用time控件啊，获取threadstate后，按指定时间间隔规定向界面刷新，线程必须是全局变量
用一个有退出条件的无限循环的sub也行。
线程开始就触发该过程，用无限循环来刷新状态，线程完成即退出无限循环。局部变量的线程也可以用这种方式。
不过用法要正确，否则会出问题。

条件变量（Condition Variable）是一种同步工具，允许线程暂停执行、进入休眠，直到某些共享资源满足条件。条件变量基本 *** 作如下：

条件锁体现的是一种协作，一个线程完成后通知其他线程开始执行。Condition variable 必须和 mutex 关联，以避免竞争条件。一个线程获取锁后发现条件不满足，暂停线程执行进行等待，其他线程这时可以获取锁，条件满足后，向条件发出信号。

条件锁可用于生产者、消费者模式中状态同步：

当消费者发现没有数据时，等待 condition 变为1。生产者生产了新数据，condition 变为1，通知消费者。

这篇文章将介绍三种条件锁： pthread_cond_t 、 NSCondition 和 NSConditionLock 。

前面两篇文章已介绍过 pthread_mutex_t 和 pthread_mutexattr_t ，这里需额外使用 pthread_cond_t 。

使用 pthread_cond_init(pthread_cond_t cond, pthread_condattr_t cond_attr) 初始化条件变量 cond，cond_attr 指定的 condition attribute。如果 cond_attr 为 nil，则使用默认属性。 pthread_cond_t 也可以使用PTHREAD_COND_INITIALIZER常量静态初始化。

如下所示：

pthread_cond_signal() 和 pthread_cond_broadcast() 函数用于解除堵塞在条件变量上的线程。

如果多个线程堵塞在 cond，调度器决定唤醒哪个线程。使用 pthread_cond_signal() 、 pthread_cond_broadcast() 唤醒线程后，从 pthread_cond_wait() 和 pthread_cond_timedwait() 返回的线程会尝试持有 mutex。如果没有线程等待 cond，则什么也不发生。

pthread_cond_wait() 和 pthread_cond_timedwait() 函数用于堵塞条件变量。需先使用同一线程锁定 mutex，否则会导致无法预期结果。

解锁 mutex 与在条件变量处挂起线程是原子 *** 作。线程先获取 mutex、后 signal 条件变量，可以避免线程在加锁后、等待条件变量前被唤醒。线程被挂起后不再占用 CPU 时间，直到 signal 条件变量。成功返回后，mutex 被该线程持有。

多个 mutex 并发使用同一个 condition variable 会产生无法预期的结果。也就是当线程等待 condition variable 时， cond 就绑定到了该 mutex。等待结束时，绑定关系终止。

pthread_cond_timedwait() 与 pthread_cond_wait() 类似，只是如果指定时间后还没有 signal、broadcast，就返回错误。

pthread_cond_destroy() 销毁指定cond，销毁后对象成为未初始化状态。销毁后的对象可以使用 pthread_cond_init() 再次初始化，其他方式使用已销毁的对象会产生无法预期的结果。

NSCondition 类是对 pthread_mutex_t 和 pthread_cond_t 的封装，为面向对象的类。 NSCondition 类遵守 NSLocking 协议。

初始化方法如下：

GNUstep 中实现如下：

signal() 一次唤醒一个线程，可以多次调用唤醒多个线程。 broadcast() 一次唤醒多个线程。

如果没有线程等待cond，则不执行任何 *** 作。为避免竞争条件，应只在 condtion 锁定时调用。

GNUstep 中实现如下：

堵塞当前线程，直到 signal 或到达指定时间。必须先 lock NSCondition 再调用该方法。

GNUstep 中实现如下：

NSConditionLock 类是对 pthread_mutex_t 和 pthread_cond_t 的封装，为面向对象的类，方。 NSConditionLock 类遵守 NSLocking 协议。

NSConditionLock 有一个关联值，即condition。在初始化 NSConditionLock 或释放锁时设置。线程会等待锁，直到其为特定值，等待期间不会占用 CPU 时间。借助 NSConditionLock condition值可以实现依赖项，使其按次序执行。

初始化方法如下：

GNUstep 中实现如下：

当 NSConditionLock 的condition值与 lock(whenCondition:) 参数的值相同时，加锁成功，否则会堵塞在当前位置。

GNUstep 中实现如下：

释放锁，并设置 condition 值。

现在，上述三个方法按顺序执行。

GNUstep 中实现如下：

Demo名称：Synchronization
源码地址： >