JAVA 中的线程不可以共享代码 1. Applet 可以做下列那些操作 A. 读取客户端...线程是进程的中的一个实体,通常一个进程有若干个线程,但同一进程中的多个线程...
并发 D. 共享 9. D 不是一个操作系统环境.(...A. 系统进程和用户进程是进程的两种不同状态 B. ...对于进程和线程,以下说法中正确的是 C A. 线程是...
是被系统独立调度和分派的基本单位,线 程自己不拥有系统资源, 只拥有一点儿在运行中必不可少的资源,但它可与同属 一个进程的其它线程共享进程所拥有的全部资源...
在一个进程中的多个线程之间,可以并发执行,甚至允许在一个进程 中所有线程都能并发执行;同样,不同进程中的线程也能并发执行。 4)共享进程资源。 在同一进程中...
A. 并行 B.真实 C.虚拟 D.共享 6、设计实时...时间片用完 17、 下列的进程状态变化中, ( )变化...27. 进程 同一进程中的线程 28.封闭和可再现性 ...
下列哪个算法是对一个list排序的最快方法() A B C D 快速排序 冒泡排序 二...同一进程下的多个线程可以共享哪一种资源() A B C D stack data section ...
一:选择题(本题共 4 小题,每题 3 分共 12 分) 1)下列不是 Linux 系统...只拥有一点在运行中必不可少的资源但是它可与同属一个进程的其他的线程共享进...
信号量 Semaphore 与互斥量 Mutex 的用法不同,互斥量 Mutex 保证任意时刻只能有一 个进程或线程获得互斥体,信号量允许多个线程同时使用共享资源,这与操作系统中的...
具有线程控制块,共享所属进程资源,处理机的独立调度...下列答案中不属于此分类 的是: A.批处理系统 C....多个进程的实体能存在于同一内存中,在一段时间内...
是被系统独立调度和分派的基本单位, 线程自己不拥有系统资源, 只拥有一点儿在运行中必不可少的资源,但它可与同 属一个进程的其它线程共享进程所拥有的全部资源...24332人阅读
多线程（7）
转载---其它（8）
&&& 进程拥有这许多共性的同时，还拥有自己的个性。有了这些个性，线程才能实现并发性。这些个性包括：
&&& 1.线程ID
&&&&& 每个线程都有自己的线程ID，这个ID在本进程中是唯一的。进程用此来标
&& 识线程。
&&& 2.寄存器组的值
&&&&&& 由于线程间是并发运行的，每个线程有自己不同的运行线索，当从一个线
&& 程切换到另一个线程上时，必须将原有的线程的寄存器集合的状态保存，以便
&& 将来该线程在被重新切换到时能得以恢复。
&&& 3.线程的堆栈
&&&&&& 堆栈是保证线程独立运行所必须的。
&&&&&& 线程函数可以调用函数，而被调用函数中又是可以层层嵌套的，所以线程
&& 必须拥有自己的函数堆栈，使得函数调用可以正常执行，不受其他线程的影
&&& 4.错误返回码
&&&&&& 由于同一个进程中有很多个线程在同时运行，可能某个线程进行系统调用
&& 后设置了errno值，而在该线程还没有处理这个错误，另外一个线程就在此时
&& 被调度器投入运行，这样错误值就有可能被修改。
&&&&&& 所以，不同的线程应该拥有自己的错误返回码变量。
&&& 5.线程的信号屏蔽码
&&&&&& 由于每个线程所感兴趣的信号不同，所以线程的信号屏蔽码应该由线程自
&& 己管理。但所有的线程都共享同样的信号处理器。
&&& 6.线程的优先级
&&&&&& 由于线程需要像进程那样能够被调度，那么就必须要有可供调度使用的参
&& 数，这个参数就是线程的优先级。
涉及多线程程序涉及的时候经常会出现一些令人难以思议的事情，用堆和栈分配一个变量可能在以后的执行中产生意想不到的结果，而这个结果的表现就是内存的非法被访问，导致内存的内容被更改。&
　　理解这个现象的两个基本概念是：在一个进程的线程共享堆区，而进程中的线程各自维持自己堆栈。&
　　另一运行机制就是如果声明一个成员变量如 char Name[200]，随着这段代码调用的结束，Name在栈区的地址被释放，而如果是 char * Name = new char[200]; 情况则完全不同，除非显示调用delete否则 Name指向的地址不会被释放。&
　　在B中如果用栈区 即采用临时变量的机制分配声明V和堆区，而者的结果是不同的。如果用栈区，如果变量地址为Am1-Am2这么大，退出B调用时候这段地址被释放，C函数可能将这段内存改写；这样当D执行的时候，从内存Am1-Am2中读取的内容就是被改过的了。&
　　而如果用New（堆）分配，则不会出现那样的情况，因为没有显示对用delete并且堆对于线程共享，即2线程可以看到1线程在堆里分配的东西，所以不会发生误写。&
　　这个问题是笔者在公司实习的时候发现的，因为当时刚刚涉及多线程程序设计，操作系统中如此简单的话题困扰笔者很久，希望可以对初涉C++多线程的读者有所帮助！ 2）如果两个线程共享堆，而且都有可能执行内存分配和释放操作，就必须进行同步保护，这个和C类，R类，T类没有关系。你看到的例子两个线程应该是使用各自的堆。&
　　在 windows 等平台上，不同线程缺省使用同一个堆，所以用 C 的 malloc （或者 windows 的 GlobalAlloc）分配内存的时候是使用了同步保护的。如果没有同步保护，在两个线程同时执行内存操作的时候会产生竞争条件，可能导致堆内内存管理混乱。比如两个线程分配了统一块内存地址，空闲链表指针错误等。&
　　Symbian 的线程一般使用独立的堆空间。这样每个线程可以直接在自己的堆里分配和释放，可以减少同步所引入的开销。当线程退出的时候，系统直接回收线程的堆空间，线程内没有释放的内存空间也不会造成进程内的内存泄漏。&
　　但是两个线程使用共用堆的时候，就必须用 critical section 或者 mutex 进行同步保护。否则程序崩溃时早晚的事。如果你的线程需要在共用堆上无规则的分配和释放任何数量和类型的对象，可以定制一个自己的 allcator，在 allocator 内部使用同步保护。线程直接使用这个 allocator 分配内存就可以了。这相当于实现自己的 malloc，free。但是更建议你重新审查一下自己的系统，因为这种情况大多数是不必要的。经过良好的设计，线程的本地堆应该能够满足大多数对象的需求。如果有某一类对象需要在共享堆上创建和共享，这种需求是比较合理的，可以在这个类的
new 和 delete 上实现共享保护。&
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2132436次
积分：24186
积分：24186
排名：第273名
原创：422篇
转载：245篇
译文：39篇
评论：262条
(11)(7)(9)(3)(2)(2)(4)(7)(1)(3)(5)(2)(5)(11)(2)(1)(3)(3)(9)(5)(23)(5)(2)(1)(4)(2)(10)(21)(1)(19)(1)(6)(2)(2)(3)(6)(4)(5)(14)(14)(7)(11)(13)(16)(11)(25)(13)(12)(12)(2)(13)(9)(15)(25)(16)(24)(1)(3)(4)(7)(1)(8)(44)(18)(25)(21)(9)(2)(4)(6)(3)(35)(24)(3)(2)(1)(2)(5)(11)(3)
(window.slotbydup = window.slotbydup || []).push({
id: '4740881',
container: s,
size: '200,200',
display: 'inlay-fix'多个线程之间共享数据的方式 - where - ITeye博客
博客分类：
ps:由于最近的面试很多问题都涉及多线程，自己感觉以前学的还是太浅，再展开学学吧。
今天先从考的比较频繁的“多线程共享数据”开始。
谈到多线程共享数据，理想情况下我们希望做到“同步”和“互斥”。这是目标我们暂且把它先放到这。
多线程共享数据通常的场景有一下两种：
卖票，我们都买过火车票。要买火车票我们可以去车站，也可以通过代售点（或网购），但不管有多少种方式火车票的总数是一定的。
场景抽象：
对于卖票系统每个线程的核心执行的代码都相同（就是票数--）。
解决方法：
只需创建一个Runnable,这个Runnable里有那个共享数据。
代码模拟：
package 多线程共享数据;
public class Ticket implements Runnable{
private int ticket = 10;
public void run() {
while(ticket&0){
System.out.println("当前票数为："+ticket);
package 多线程共享数据;
public class SellTicket {
* @param args
public static void main(String[] args) {
Ticket t = new Ticket();
new Thread(t).start();
new Thread(t).start();
场景二：比较常见的例子，银行问题，我们对账户可以存钱也可以取钱，怎么保证这样的数据共享呢？
场景抽象：
每个线程执行的代码不同（比如上面的问题，对每个账户可以执行++操作和--操作），这时候需要用不同的Runnable对象，有如下两种方式来实现这些Runnable之间的数据共享
解决方案：
有两种方法来解决此类问题：
将共享数据封装成另外一个对象中封装成另外一个对象中，然后将这个对象逐一传递给各个Runnable对象，每个线程对共享数据的操作方法也分配到那个对象身上完成，这样容易实现针对数据进行各个操作的互斥和通信
将Runnable对象作为偶一个类的内部类，共享数据作为这个类的成员变量，每个线程对共享数据的操作方法也封装在外部类，以便实现对数据的各个操作的同步和互斥，作为内部类的各个Runnable对象调用外部类的这些方法。
代码模拟：
以一道面试题为例：
“设计4个线程。，其中两个线程每次对j增加1，另外两个线程对j每次减1”
（第一种解法）
public class MyData {
private int j=0;
synchronized void add(){
System.out.println("线程"+Thread.currentThread().getName()+"j为："+j);
synchronized void dec(){
System.out.println("线程"+Thread.currentThread().getName()+"j为："+j);
public int getData(){
public class AddRunnable implements Runnable{
public AddRunnable(MyData data){
this.data=
public void run() {
data.add();
public class DecRunnable implements Runnable {
public DecRunnable(MyData data){
this.data =
public void run() {
data.dec();
测试代码：
public class TestOne {
* @param args
public static void main(String[] args) {
MyData data = new MyData();
Runnable add = new AddRunnable(data);
Runnable dec = new DecRunnable(data);
for(int i=0;i&2;i++){
new Thread(add).start();
new Thread(dec).start();
解法分析：
1.这种解法代码写的有条理，简单易读，从main中很容易整理出思路
2.将数据抽象成一个类，并将对这个数据的操作作为这个类的方法，这么设计可以和容易做到同步，只要在方法上加”synchronized“
代码写的比较繁琐，需要有多个类，不是那么简洁
个人观点：为了有条理个人比较喜欢这种写法。
（第二种解法）
public class MyData {
private int j=0;
synchronized void add(){
System.out.println("线程"+Thread.currentThread().getName()+"j为："+j);
synchronized void dec(){
System.out.println("线程"+Thread.currentThread().getName()+"j为："+j);
public int getData(){
public class TestThread {
* @param args
public static void main(String[] args) {
final MyData data = new MyData();
for(int i=0;i&2;i++){
new Thread(new Runnable(){
public void run() {
data.add();
}).start();
new Thread(new Runnable(){
public void run() {
data.dec();
}).start();
解法分析：
与第一种方法的区别在于第二种方法巧妙的用了内部类共享外部类数据的思想，即把要共享的数据变得全局变量，这样就保证了操作的是同一份数据。同时内部类的方式使代码更加简洁。但是不如第一种解法条理那么清楚。
结束语：感谢网上各种资料，只要想学网上的各种资料是这么丰富。学无止境，少年加油！！！
下载次数: 17
浏览 18595
第一个卖票系统那个场景的实现方式不行的，ticket--不是原子操作，这个程序跑起来会有问题，会出现一张票被多个网点卖出去的情况，需要做同步。用AtomicInteger。
浏览: 51786 次
来自: 长沙
superhotdong 写道第一个卖票系统那个场景的实现方式 ...
2楼说的是正确的
第一个卖票系统那个场景的实现方式不行的，ticket--不是原 ...
where 写道我是从学习的角度看画图板，而不站在应用的角度， ...
写的很不错。进程线程同步的四种方法
我的图书馆
进程线程同步的四种方法
　　很想整理一下自己对进程线程同步互斥的理解。正巧周六一个刚刚回到学校的同学请客吃饭。在吃饭的过程中，有两个同学，为了一个问题争论的面红耳赤。一个认为.Net下的进程线程控制模型更加合理。一个认为Java下的线程池策略比.Net的好。大家的话题一下转到了进程线程同步互斥的控制问题上。回到家，想了想就写了这个东东。　　现在流行的进程线程同步互斥的控制机制，其实是由最原始最基本的4种方法实现的。由这4种方法组合优化就有了.Net和Java下灵活多变的，编程简便的线程进程控制手段。　　这4种方法具体定义如下 在《操作系统教程》ISBN 7- 一书中可以找到更加详细的解释　　　　1临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。　　2互斥量:为协调共同对一个共享资源的单独访问而设计的。　　3信号量:为控制一个具有有限数量用户资源而设计。　　　　4事 件:用来通知线程有一些事件已发生，从而启动后继任务的开始。　　　　临界区（Critical Section）　　保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。　　临界区包含两个操作原语：EnterCriticalSection（） 进入临界区LeaveCriticalSection（） 离开临界区　　EnterCriticalSection（）语句执行后代码将进入临界区以后无论发生什么，必须确保与之匹配的LeaveCriticalSection（）都能够被执行到。否则临界区保护的共享资源将永远不会被释放。虽然临界区同步速度很快，但却只能用来同步本进程内的线程，而不可用来同步多个进程中的线程。　　MFC提供了很多功能完备的类，我用MFC实现了临界区。MFC为临界区提供有一个CCriticalSection类，使用该类进行线程同步处理是非常简单的。只需在线程函数中用CCriticalSection类成员函数Lock（）和UnLock（）标定出被保护代码片段即可。Lock（）后代码用到的资源自动被视为临界区内的资源被保护。UnLock后别的线程才能访问这些资源。　　//CriticalSection　　CCriticalSection global_CriticalS　　// 共享资源　　char global_Array[256];　　//初始化共享资源　　void InitializeArray()　　{　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=I;　　 }　　}　　//写线程　　UINT Global_ThreadWrite(LPVOID pParam)　　{　　 CEdit *ptr=(CEdit *)pP　　 ptr-&SetWindowText("");　　 //进入临界区　　global_CriticalSection.Lock();　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=W;　　 ptr-&SetWindowText(global_Array);　　 Sleep(10);　　 }　　//离开临界区　　 global_CriticalSection.Unlock();　　 return 0;　　}　　//删除线程　　UINT Global_ThreadDelete(LPVOID pParam)　　{　　 CEdit *ptr=(CEdit *)pP　　 ptr-&SetWindowText("");　　 //进入临界区　　 global_CriticalSection.Lock();　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=D;　　 ptr-&SetWindowText(global_Array);　　 Sleep(10);　　 }　　//离开临界区　　 global_CriticalSection.Unlock();　　 return 0;　　}　　//创建线程并启动线程　　void CCriticalSectionsDlg::OnBnClickedButtonLock()　　{　　 //Start the first Thread　　 CWinThread *ptrWrite = AfxBeginThread(Global_ThreadWrite,　　 &m_Write,　　 THREAD_PRIORITY_NORMAL,　　 0,　　 CREATE_SUSPENDED);　　 ptrWrite-&ResumeThread();　　 //Start the second Thread　　 CWinThread *ptrDelete = AfxBeginThread(Global_ThreadDelete,　　 &m_Delete,　　 THREAD_PRIORITY_NORMAL,　　 0,　　 CREATE_SUSPENDED);　　 ptrDelete-&ResumeThread();　　}　　在测试程序中，Lock UnLock两个按钮分别实现，在有临界区保护共享资源的执行状态，和没有临界区保护共享资源的执行状态。　　　　程序运行结果　　　　互斥量（Mutex）　　　　互斥量跟临界区很相似，只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程所访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。互斥量比临界区复杂。因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享，而且可以在不同应用程序的线程之间实现对资源的安全共享。　　互斥量包含的几个操作原语：　　CreateMutex（） 创建一个互斥量　　OpenMutex（） 打开一个互斥量　　ReleaseMutex（） 释放互斥量　　WaitForMultipleObjects（） 等待互斥量对象　　同样MFC为互斥量提供有一个CMutex类。使用CMutex类实现互斥量操作非常简单，但是要特别注意对CMutex的构造函数的调用　　CMutex( BOOL bInitiallyOwn = FALSE, LPCTSTR lpszName = NULL, LPSECURITY_ATTRIBUTES lpsaAttribute = NULL)　　不用的参数不能乱填，乱填会出现一些意想不到的运行结果。　　//创建互斥量　　CMutex global_Mutex(0,0,0);　　// 共享资源　　char global_Array[256];　　void InitializeArray()　　{　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=I;　　 }　　}　　UINT Global_ThreadWrite(LPVOID pParam)　　{　　 CEdit *ptr=(CEdit *)pP　　 ptr-&SetWindowText("");　　 global_Mutex.Lock();　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=W;　　 ptr-&SetWindowText(global_Array);　　 Sleep(10);　　 }　　 global_Mutex.Unlock();　　 return 0;　　}　　UINT Global_ThreadDelete(LPVOID pParam)　　{　　 CEdit *ptr=(CEdit *)pP　　 ptr-&SetWindowText("");　　 global_Mutex.Lock();　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=D;　　 ptr-&SetWindowText(global_Array);　　 Sleep(10);　　 }　　 global_Mutex.Unlock();　　 return 0;　　}　　同样在测试程序中，Lock UnLock两个按钮分别实现，在有互斥量保护共享资源的执行状态，和没有互斥量保护共享资源的执行状态。　　　　程序运行结果　　　　　　信号量（Semaphores）　　信号量对象对线程的同步方式与前面几种方法不同，信号允许多个线程同时使用共享资源，这与操作系统中的PV操作相同。它指出了同时访问共享资源的线程最大数目。它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。在用CreateSemaphore（）创建信号量时即要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目，不能在允许其他线程的进入，此时的信号量信号将无法发出。线程在处理完共享资源后，应在离开的同时通过ReleaseSemaphore（）函数将当前可用资源计数加1。在任何时候当前可用资源计数决不可能大于最大资源计数。　　PV操作及信号量的概念都是由荷兰科学家E.W.Dijkstra提出的。信号量S是一个整数，S大于等于零时代表可供并发进程使用的资源实体数，但S小于零时则表示正在等待使用共享资源的进程数。　　P操作申请资源：　　　　（1）S减1；　　（2）若S减1后仍大于等于零，则进程继续执行；　　（3）若S减1后小于零，则该进程被阻塞后进入与该信号相对应的队列中，然后转入进程调度。　　V操作 释放资源：　　（1）S加1；　　（2）若相加结果大于零，则进程继续执行；　　（3）若相加结果小于等于零，则从该信号的等待队列中唤醒一个等待进程，然后再返回原进程继续执行或转入进程调度。　　信号量包含的几个操作原语：　　CreateSemaphore（） 创建一个信号量　　OpenSemaphore（） 打开一个信号量　　ReleaseSemaphore（） 释放信号量　　WaitForSingleObject（） 等待信号量　　//信号量句柄　　HANDLE global_S　　// 共享资源　　char global_Array[256];　　void InitializeArray()　　{　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=I;　　 }　　}　　//线程1　　UINT Global_ThreadOne(LPVOID pParam)　　{　　 CEdit *ptr=(CEdit *)pP　　 ptr-&SetWindowText("");　　 //等待对共享资源请求被通过 等于 P操作　　WaitForSingleObject(global_Semephore, INFINITE);　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=O;　　 ptr-&SetWindowText(global_Array);　　 Sleep(10);　　 }　　//释放共享资源 等于 V操作　　 ReleaseSemaphore(global_Semephore, 1, NULL);　　 return 0;　　}　　UINT Global_ThreadTwo(LPVOID pParam)　　{　　 CEdit *ptr=(CEdit *)pP　　 ptr-&SetWindowText("");　　 WaitForSingleObject(global_Semephore, INFINITE);　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=T;　　 ptr-&SetWindowText(global_Array);　　 Sleep(10);　　 }　　 ReleaseSemaphore(global_Semephore, 1, NULL);　　 return 0;　　}　　UINT Global_ThreadThree(LPVOID pParam)　　{　　 CEdit *ptr=(CEdit *)pP　　 ptr-&SetWindowText("");　　 WaitForSingleObject(global_Semephore, INFINITE);　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=H;　　 ptr-&SetWindowText(global_Array);　　 Sleep(10);　　 }　　 ReleaseSemaphore(global_Semephore, 1, NULL);　　 return 0;　　}　　void CSemaphoreDlg::OnBnClickedButtonOne()　　{　　//设置信号量 1 个资源 1同时只可以有一个线程访问　　 global_Semephore= CreateSemaphore(NULL, 1, 1, NULL);　　 this-&StartThread();　　// TODO: Add your control notification handler code here　　}　　void CSemaphoreDlg::OnBnClickedButtonTwo()　　{　　//设置信号量 2 个资源 2 同时只可以有两个线程访问　　 global_Semephore= CreateSemaphore(NULL, 2, 2, NULL);　　 this-&StartThread();　　// TODO: Add your control notification handler code here　　}　　void CSemaphoreDlg::OnBnClickedButtonThree()　　{　　//设置信号量 3 个资源 3 同时只可以有三个线程访问　　 global_Semephore= CreateSemaphore(NULL, 3, 3, NULL);　　 this-&StartThread();　　// TODO: Add your control notification handler code here　　}　　信号量的使用特点使其更适用于对Socket（套接字）程序中线程的同步。例如，网络上的HTTP服务器要对同一时间内访问同一页面的用户数加以限制，这时可以为每一个用户对服务器的页面请求设置一个线程，而页面则是待保护的共享资源，通过使用信号量对线程的同步作用可以确保在任一时刻无论有多少用户对某一页面进行访问，只有不大于设定的最大用户数目的线程能够进行访问，而其他的访问企图则被挂起，只有在有用户退出对此页面的访问后才有可能进入。　　　　程序运行结果　　　　事件（Event）　　　　事件对象也可以通过通知操作的方式来保持线程的同步。并且可以实现不同进程中的线程同步操作。　　信号量包含的几个操作原语：　　CreateEvent（） 创建一个信号量　　OpenEvent（） 打开一个事件　　SetEvent（） 回置事件　　WaitForSingleObject（） 等待一个事件　　WaitForMultipleObjects（）　　等待多个事件　　WaitForMultipleObjects 函数原型：　　WaitForMultipleObjects（　　IN DWORD nCount, // 等待句柄数　　IN CONST HANDLE *lpHandles, //指向句柄数组　　IN BOOL bWaitAll, //是否完全等待标志　　IN DWORD dwMilliseconds //等待时间　　）　　参数nCount指定了要等待的内核对象的数目，存放这些内核对象的数组由lpHandles来指向。fWaitAll对指定的这nCount个内核对象的两种等待方式进行了指定，为TRUE时当所有对象都被通知时函数才会返回，为FALSE则只要其中任何一个得到通知就可以返回。dwMilliseconds在这里的作用与在WaitForSingleObject（）中的作用是完全一致的。如果等待超时，函数将返回WAIT_TIMEOUT。　　//事件数组　　HANDLE global_Events[2];　　// 共享资源　　char global_Array[256];　　void InitializeArray()　　{　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=I;　　 }　　}　　UINT Global_ThreadOne(LPVOID pParam)　　{　　 CEdit *ptr=(CEdit *)pP　　 ptr-&SetWindowText("");　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=O;　　 ptr-&SetWindowText(global_Array);　　 Sleep(10);　　 }　　//回置事件　　 SetEvent(global_Events[0]);　　 return 0;　　}　　UINT Global_ThreadTwo(LPVOID pParam)　　{　　 CEdit *ptr=(CEdit *)pP　　 ptr-&SetWindowText("");　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=T;　　 ptr-&SetWindowText(global_Array);　　 Sleep(10);　　 }　　//回置事件　　 SetEvent(global_Events[1]);　　 return 0;　　}　　UINT Global_ThreadThree(LPVOID pParam)　　{　　 CEdit *ptr=(CEdit *)pP　　 ptr-&SetWindowText("");　　//等待两个事件都被回置　　 WaitForMultipleObjects(2, global_Events, true, INFINITE);　　 for(int i = 0;i&256;i++)　　 {　　 global_Array[i]=H;　　 ptr-&SetWindowText(global_Array);　　 Sleep(10);　　 }　　 return 0;　　}　　void CEventDlg::OnBnClickedButtonStart()　　{　　 for (int i = 0; i & 2; i++)　　 {　　//实例化事件　　 global_Events[i]=CreateEvent(NULL,false,false,NULL);　　 }　　 CWinThread *ptrOne = AfxBeginThread(Global_ThreadOne,　　 &m_One,　　 THREAD_PRIORITY_NORMAL,　　 0,　　 CREATE_SUSPENDED);　　 ptrOne-&ResumeThread();　　//Start the second Thread　　 CWinThread *ptrTwo = AfxBeginThread(Global_ThreadTwo,　　 &m_Two,　　 THREAD_PRIORITY_NORMAL,　　 0,　　 CREATE_SUSPENDED);　　 ptrTwo-&ResumeThread();　　//Start the Third Thread　　 CWinThread *ptrThree = AfxBeginThread(Global_ThreadThree,　　 &m_Three,　　 THREAD_PRIORITY_NORMAL,　　 0,　　 CREATE_SUSPENDED);　　 ptrThree-&ResumeThread();　　// TODO: Add your control notification handler code here　　}　　事件可以实现不同进程中的线程同步操作，并且可以方便的实现多个线程的优先比较等待操作，例如写多个WaitForSingleObject来代替WaitForMultipleObjects从而使编程更加灵活。　　程序运行结果　　　　总结：　　　　1． 互斥量与临界区的作用非常相似，但互斥量是可以命名的，也就是说它可以跨越进程使用。所以创建互斥量需要的资源更多，所以如果只为了在进程内部是用的话使用临界区会带来速度上的优势并能够减少资源占用量。因为互斥量是跨进程的互斥量一旦被创建，就可以通过名字打开它。　　　　2． 互斥量（Mutex），信号灯（Semaphore），事件（Event）都可以被跨越进程使用来进行同步数据操作，而其他的对象与数据同步操作无关，但对于进程和线程来讲，如果进程和线程在运行状态则为无信号状态，在退出后为有信号状态。所以可以使用WaitForSingleObject来等待进程和线程退出。　　3． 通过互斥量可以指定资源被独占的方式使用，但如果有下面一种情况通过互斥量就无法处理，比如现在一位用户购买了一份三个并发访问许可的数据库系统，可以根据用户购买的访问许可数量来决定有多少个线程/进程能同时进行数据库操作，这时候如果利用互斥量就没有办法完成这个要求，信号灯对象可以说是一种资源计数器。
TA的最新馆藏[转]&
喜欢该文的人也喜欢}