当前位置:&&
对多线程的输出有重定向的方法吗？
&&&&来源:&互联网& 发布时间：
最近开发了多线程的程序，由于想观察一下多线程各线程的工作情况。所以想把各个线程里的输出打印到各自的文件，以便观察各线程当时在处理什么．但是由于原来低层的函数是把各个线程的输出都打印到一个日志的文件里的。所以现在想把日志都分开，不晓得如何能分开．．不知道有什么重定向的函数不？再有一个疑问，由于日志打印出来会很大，所以再想搞一个控制台的程序．．当运行这个控制台的时候，可以选择观察哪个线程的运行情况，并把信息打印到控制台上面，而不用生成日志文件．．这是我的想法，大家有什么意见和好的想法尽管可以提出来。．
几个疑问。
1、你在考虑重定向函数？当然可以重定向，那要看你的log文件的处理方式是什么了。从你介绍的情况来看，你使用了底层的lib来实现。那么，这个底层的lib有多复杂呢？它提供了多少接口？你打算简单修改底层lib的文件出力处理么？如果只是打算这样，应该不算困难。
你可以先设定一个文件名的多线程对应的命名规则，然后考虑下述方法：A、每次输出一条记录到文件都打开指定文件，这样不同线程的出力文件都肯定不同了；B、建立文件索引表，每次输出一条记录到文件之前，都到索引表中查询，看是否存在本进程/本线程的输出文件，如果已存在，那么直接使用已打开的该文件描述符，如果未找到匹配文件描述符，那就打开新文件，并更新到索引表中。注意在线程结束的时候需要清除索引表中的对应信息。另外，需要注意索引表的查询/存储方式，这直接影响到你的响应速度。
2、关于控制台程序，也是可行的。这取决于你采用何种方法来写一个巨大的或者多个文件。如果是一个巨大的文件，简单的监视文件状态就行了。如果是多个文件，那就监视按规则命名的指定文件是否存在。
总结：事情就那么多，看你每天几十/几百兆的log文件数量，总归是花时间的。问题就是你是把时间花在输出端呢（采用多文件的处理方式，可以简化显示端的处理）？还是把时间花在显示端（采用解析现有的巨大文件的方法）？另外，管道操作(grep)应该是比较花时间的一种处理方式。可能会有更好的方法？这方面我没有研究过。再另外，如果你是想在执行进程的时候做到动态重定向，个人认为很困难，貌似shell的计算单位是进程而不是线程，你可以在shell里面得到指定线程的id号么？貌似不行的罢。
就那么多，供参考。
日志量大的情况可以修改打印函数，会很麻烦么？
比如你原来用event_log(...)
我现在#define event_log event_log_2 ,然后重写个event_log_2，想怎么写就怎么写，想写到哪就写到哪。
另外，我不觉得打印到一个文件里就难以整理，比如你叫full，你有test1,test2,test3等几个文件
cat full | grep test1 就可以得到你test1中输出的文件，如果你的log中有__FILE__的话。
如果所有的线程输出都是通过一个函数写入log文件中的，那么你直接改写这个函数让它直接输出到屏幕上不就可以了吗
用信号试试,本人菜鸟,仅供参考.
你可以这么写log
线程id,时间,"log内容"
这样任何可以读csv的程序都可以读你的log
该回复于 14:04:12被版主删除
我觉得这说明你们的底层lib设计时没有考虑到这种问题，应该没有解决办法
本页相关标签:
相关技术文章: &&&&
文件名:cdma.sh
while [ 2 & 1 ]
if /sbin/ifconfig | /bin/grep ppp0
/bin/sleep 1
echo cdma on line
if /bin/ps -e | /bin/grep move_ftp
/bin/sleep 1
/usr/local/sbin/move_ftp &
/bin/killall move_ftp
/bin/killall pppd
/bin/sle...... &&&&
现在用到的是一个libsoup开源库,其功能是实现linux下与服务器进行连网.
现在的问题是,要把这个库移植到一个手机平台上,但这个库里涉及到
#include &netinet/in.h&
#include &netinet/tcp.h&
#include &arpa/inet.h&
#include &sys/socket.h&
#include &netdb.h&
这么几个系统头文件,如果只是简单的把这些文件移植到平台上不可行,因为这些是系统的头文件,里面还涉及到系统的其他内容,
问:这个库可不可以移植到手机平台里,该怎么移?
说明:手机平台是一个应用服用平台,具体的不太清楚了,好像是不与OS直接联系的.
这个就...... &&&&
就是说我想在执行 "svcadm enable xxx" or "svcadm disable xxx"的时候加一些判断条件，比如某个驱动aaa存在的话我就正常执行， 不然我就先加载驱动。
就是SMF 里面哪里可以自己定义或者修改 svcadm命令的执行方式麽？
你的SMF的启动脚本应该在/lib/svc/method/***下。
......&nbsp最新技术文章: &&&&
本人 菜鸟，，准备学《 UNIX环境高级编程》这本书，，但是不知道 需要什么 编译环境！！！大家都用什么 编译环境，，
ubuntu下可以吗？？ 有什么可以推荐的视频？ 这个 和c 语言 联系大吗？
问题比较多 ，，
谢谢！！！！
这本书需要有选择性的看，也就是我说的跳看，看楼主好像是新手，说实话，新手我个人不推荐先看这本书，新手先买本通俗易懂的薄书看，看完了有了大致的了解后在看这本书，本人的亲身体会，
视频本人认为还是不要的好，
看书，敲代码，死的定律！
ubuntu没问...... &&&&
会员ID：mymtom
申请版面：Linux/Unix社区 程序开发区
申请版主理由：督促自己，服务网友
平均上网时间(小时/天)：2小时/天
是否担任过本社区或者其他社区相关职务：否
对申请版面现状及您的管理改进意见: Unix文化的帖子是否可以有专家分
对论坛的建议：程序开发区帖子多，其他区帖子少，看的人也少，所以大家发帖都直接发程序开发区，可否改进。
技术兴趣以及专长：FreeBSD, C
附上12个月内答题链接：
http://topic.csdn.net/u//364fad64-9cdf-4364-96aa-a0.html
...... &&&&
如题，我在VMware5.0下安装了RedHat9.0，现在想换一个高级点的VMware版本，安装了6.0跟7.0都打不开那个linux了，好恼火啊，之前的linux里面有很多东西，不好移，而VMware5.0又好像安装不了FC12了，怎么办才好呢？
VM6.0或者VM7.0可以选择和较低的版本兼容的硬件配置。建立新的虚拟机的时候选择制定（Custom），可以看到下面的选择硬件兼容配置：
选择对应的就可以了。这样子可以打开你原来安装的虚拟机。
VM5......&nbsp
特别声明:169IT网站部分信息来自互联网,如果侵犯您的权利,请及时告知,本站将立即删除！
(C)2012-,站长邮箱:www_169it_(请将#改为@)java多线程控制台运行问题_百度知道C# 多线程问题 多线程控制台 从1到100输出_百度知道扫描二维码，关注牛客网
下载牛客APP，随时随地刷题
浙ICP备号-2
扫一扫，把题目装进口袋多线程笔试面试总结(一) - cnbyl123 - 博客园
主要题目类型：1.概念性题目 2，选择性题目，3.简答或综合性题目
一．概念性问答题
1. 线程的基本概念、线程的基本状态及状态之间的关系？
线程是一个进程内部的一个控制序列。进程至少有一个执行线程。线程是独立调度和分派的基本单位。
注意fork（）系统调用和创建新线程的区别。执行fork（）系统调用时，复制父进程的一个副本，子进程是独立的一个进程，它的执行几乎完全独立于父进程。而执行pthread_create（）系统调用时，在进程中创建一个新线程，但这个线程不是完全独立于父进程的，共享全局变量，但新线程可以有自己的局部变量，即可以拥有自己的
栈。同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，和等等。但同一进程中的多个线程有各自的(call stack)，自己的（register context)，自己的线程本地存储(thread-local storage)。
在solaris中，分成：
用户线程（user-level threads）:在用户空间运行。
轻量化进程（lightweight processes）:主要工作是将用户线程映射到核心线程
核心线程（kernel threads）：在中运行。
线程有四种基本状态，分别为：
产生（spawn）
中断（block）
非中断（unblock）
退出（finish）
又作：新生new， 阻塞block， 非阻塞unblock（可运行runable，正在运行running），死亡dead
第一题：线程的基本概念、线程的基本状态及状态之间的关系？
线程，有时称为轻量级进程，是CPU使用的基本单元；它由线程ID、程序计数器、寄存器集合和堆栈组成。它与属于同一进程的其他线程共享其代码段、数据段和其他操作系统资源（如打开文件和信号）。
线程有四种状态：新生状态、可运行状态、被阻塞状态、死亡状态。状态之间的转换如下图所示：
（process）和（thread）是操作系统的基本概念，但是它们比较抽象，不容易掌握。
最近，我读到一篇，发现有一个很好的类比，可以把它们解释地清晰易懂。
计算机的核心是CPU，它承担了所有的计算任务。它就像一座工厂，时刻在运行。
假定工厂的电力有限，一次只能供给一个车间使用。也就是说，一个车间开工的时候，其他车间都必须停工。背后的含义就是，单个CPU一次只能运行一个任务。
进程就好比工厂的车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其他进程处于非运行状态。
一个车间里，可以有很多工人。他们协同完成一个任务。
线程就好比车间里的工人。一个进程可以包括多个线程。
车间的空间是工人们共享的，比如许多房间是每个工人都可以进出的。这象征一个进程的内存空间是共享的，每个线程都可以使用这些共享内存。
可是，每间房间的大小不同，有些房间最多只能容纳一个人，比如厕所。里面有人的时候，其他人就不能进去了。这代表一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。
一个防止他人进入的简单方法，就是门口加一把锁。先到的人锁上门，后到的人看到上锁，就在门口排队，等锁打开再进去。这就叫（Mutual exclusion，缩写 Mutex），防止多个线程同时读写某一块内存区域。
还有些房间，可以同时容纳n个人，比如厨房。也就是说，如果人数大于n，多出来的人只能在外面等着。这好比某些内存区域，只能供给固定数目的线程使用。
这时的解决方法，就是在门口挂n把钥匙。进去的人就取一把钥匙，出来时再把钥匙挂回原处。后到的人发现钥匙架空了，就知道必须在门口排队等着了。这种做法叫做（Semaphore），用来保证多个线程不会互相冲突。
不难看出，mutex是semaphore的一种特殊情况（n=1时）。也就是说，完全可以用后者替代前者。但是，因为mutex较为简单，且效率高，所以在必须保证资源独占的情况下，还是采用这种设计。
操作系统的设计，因此可以归结为三点：
（1）以多进程形式，允许多个任务同时运行；
（2）以多线程形式，允许单个任务分成不同的部分运行；
（3）提供协调机制，一方面防止进程之间和线程之间产生冲突，另一方面允许进程之间和线程之间共享资源。
2.&线程与进程的区别？
程序： 完成某种功能的一段代码。静态概念。
任务： 程序完成的一个活动。既可以是一个进程，也可以是一个线程。
进程： 程序的一次执行过程。一个独立的进程在内存中有自己的数据空间和代码空间。它所拥有的数据变量属于它自己。
线程： 线程是进程的一个执行序列。同一个进程创建的多个线程可以共享进程的一些资源，如全局变量，同时，多个线程可以有自己的栈空间，线程的局部变量只属于这个线程。
　　　 线程可以有自己的堆栈和局部变量，但线程没有单独的地址空间，因此一个线程死掉就等于整个进程死掉，所以线程的健壮性不如进程。但进程切换时，系统开销大，因此
　　 & &资源利用率低。
对于一些要求同时运行且要共享资源的并发操作，只能用线程，而不能用进程。
总结：1. 一个线程只能同时属于一个进程，一个进程可以有多个线程，且至少有一个线程。
　　　2. 同一进程的所有线程共享进程的所有资源。有些资源的访问需要线程之间互斥访问。
　　　3. 真正在处理机上运行的是线程，而不是进程。
　　　4. 同步问题： 不同进程的线程之间利用消息通信的方式实现同步。
第二题：线程与进程的区别？
1、 线程是进程的一部分，所以线程有的时候被称为是轻权进程或者轻量级进程。2、 一个没有线程的进程是可以被看作单线程的，如果一个进程内拥有多个进程，进程的执行过程不是一条线（线程）的，而是多条线（线程）共同完成的。3、 系统在运行的时候会为每个进程分配不同的内存区域，但是不会为线程分配内存（线程所使用的资源是它所属的进程的资源），线程组只能共享资源。那就是说，出了CPU之外（线程在运行的时候要占用CPU资源），计算机内部的软硬件资源的分配与线程无关，线程只能共享它所属进程的资源。4、 与进程的控制表PCB相似，线程也有自己的控制表TCB，但是TCB中所保存的线程状态比PCB表中少多了。5、 进程是系统所有资源分配时候的一个基本单位，拥有一个完整的虚拟空间地址，并不依赖线程而独立存在。
3.&多线程有几种实现方法，都是什么？
第三题：多线程有几种实现方法，都是什么？
&1. 继承 Thread 类& 2. 实现 Runnable 接口再 new Thread(YourRunnableOjbect)&
4. 多线程同步和互斥有几种实现方法，都是什么？
&&&&&&&我在参加2011年迅雷校园招聘时的一面和二面都被问到这个题目，回答的好将会给面试成绩加不少分。
线程间的同步方法大体可分为两类：用户模式和内核模式。顾名思义，内核模式就是指利用系统内核对象的单一性来进行同步，使用时需要切换内核态与用户态，而用户模式就是不需要切换到内核态，只在用户态完成操作。用户模式下的方法有：原子操作（例如一个单一的全局变量），临界区。内核模式下的方法有：事件，信号量，互斥量。
5.&多线程同步和互斥有何异同，在什么情况下分别使用他们？举例说明。
线程同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。
线程互斥是指对于共享的进程系统资源，在各单个线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。线程互斥可以看成是一种特殊的线程同步（下文统称为同步）。
二、选择性题目
(Baidu)以下多线程对int型变量x的操作，哪几个不需要进行同步：&（D），哪几个需要进行同步（ABC）A. x=y; &&&&&B. x++; &&&C. ++x; &&&D. x=1;
将代码汇编，得到：
x =00411A25 mov eax,dword ptr [y]&00411A28 mov dword ptr [x],eax&x++;00411A2B mov eax,dword ptr [x]&00411A2E add eax,1&00411A31 mov dword ptr [x],eax&++x;00411A34 mov eax,dword ptr [x]&00411A37 add eax,1&00411A3A mov dword ptr [x],eax&x = 1;00411A3D mov dword ptr [x],1
我们看到ABC都对2个寄存器进行操作。&&&下表是一个多线程加锁的规律表&
&操作的结果与初值无关
&操作的结果与初值相关
&&写简单数据类型
&不需要加锁①
需要加锁②
&写复杂数据类型
需要加锁③
需要加锁④
&读简单数据类型
不需要加锁⑤
不需要加锁⑥
&读复杂数据类型
需要加锁⑦
需要加锁⑧
ABC都是写简单数据类型 并且操作的结果与初值相关。所以需要加锁。即要求同步
典型代表是&i++;&，需要对它加锁是因为它表面上虽然只有一条语句，却要执行至少两个操作，一是读出i的初始, 二是把加一后的结果写回去，两个操作就没有&原子性&了，所以需要加锁.
（1）很显然，x=1是原子操作。
因为x是int类型，32位CPU上int占32位，在X86上由硬件直接提供了原子性支持。实际上不管有多少个线程同时执行类似x=1这样的赋值语句，x的值最终还是被赋的值（而不会出现例如某个线程只更新了x的低16位然后被阻塞，另一个线程紧接着又更新了x的低24位然后又被阻塞，从而出现x的值被损坏了的情况）。
（2）再来看x++和++x。其实类似x++,&x+=2,&++x这样的操作在多线程环境下是需要同步的。因为X86会按三条指令的形式来处理这种语句：从内存中读x的值到寄存器中，对寄存器加1，再把新值写回x&所处的内存地址（见上面的反汇编代码）。
例如有两个线程，它们按照如下顺序执行（注意读x和写回x是原子操作，两个线程不能同时执行）：
time&&&&Thread&1&&&&&&&&&Thread&20&&&&&&load&eax,&x1&&&&&&&&&&&&&&&&&&&&&&&&&&&&load&eax&x2&&&&&&add&eax,&1&&&&&&&&add&eax,&13&&&&&&store&x,&eax4&&&&&&&&&&&&&&&&&&&&&&&&&&&&store&x,&eax
我们会发现最终x的值会是1而不是2，因为Thread&1的结果被覆盖掉了。这样情况下我们就需要对x++这样的操作加锁（例如Pthread中的mutex）来保证同步，或者使用一些提供了atomic&operations的库（例如Windows&API中的&，Linux内核中的&，Java&concurrent库中的Atomic&Integer，C++0x中即将支持的atomic_int等等，这些库会利用CPU提供的硬件机制做一层封装，提供一些保证了原子性的API）。
（3）最后来看看x=y。在X86上它包含两个操作：读取y至寄存器，再把该值写入x。读y的值这个操作本身是原子的，把值写入x也是原子的，但是两者合起来是不是原子操作呢？我个人认为x=y不是原子操作，因为它不是不可再分的操作。但是它需要不需要同步呢？其实问题的关键在于程序的上下文。
例如有两个线程，线程1要执行{y&=&1;&x&=&y;}，线程2要执行{y&=&2;&y&=&3;}，假设它们按如下时间顺序执行：
time&&&&Thread&1&&&&&&&&Thread&20&&&&&&&&store&y,&11&&&&&&&&&&&&&&&&&&&&&&&&&&&&store&y,&22&&&&&&&&load&eax,&y3&&&&&&&&&&&&&&&&&&&&&&&&&&&&store&y,&34&&&&&&&&store&x,&eax
那么最终线程1中x的值为2，而不是它原本想要的1。我们需要加上相应的同步语句确保y&=&2不会在线程1的两条语句之间发生。y&=&3那条语句尽管在load&y和store&x之间执行，但是却不影响x=y这条语句本身的语义。所以你可以说x=y需要同步，也可以说x=y不需要同步，看你怎么理解题意了。x=1是否需要同步也是一样的道理，虽然它本身是原子操作，但是如果有另一个线程要读x=1之后的值，那肯定也需要同步，否则另一个线程读到的就是x的旧值而不是1了。
(alibaba)多线程中栈与堆是公有的还是私有的()
A：栈公有, 堆私有
B：栈公有，堆公有
C：栈私有, 堆公有
D：栈私有，堆私有
分析： 同一进程中每个线程可以有自己的栈空间，因此栈是私有的。堆由进程分配的，对进程内的线程来讲是公有的。
三、综合题目
1.&在Windows编程中互斥量与临界区比较类似，请分析一下二者的主要区别。
两者都可以用于同一进程中不同子线程对资源的互斥访问。
临界区是用户模式下的互斥访问手段，互斥量是内核模式下的互斥访问手段。
critical section:&保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线 程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操 作共享资源的目的。&临界区包含两个操作原语：&EnterCriticalSection（） 进入临界区&LeaveCriticalSection（） 离开临界区&EnterCriticalSection（）语句执行后代码将进入临界区以后无论发生什么，必须确保与之匹配的 LeaveCriticalSection（）都能够被执行到。否则临界区保护的共享资源将永远不会被释放。虽然临界区同步速度很快，但却只能用来同步本 进程内的线程，而不可用来同步多个进程中的线程。&
mutex:&互斥量是内核对象，因此还可以用于不同进程中子线程对资源的互斥访问。互斥量可以很好的解决由于线程意外终止资源无法释放的问题。
2. 临界区、互斥量、信号、时间的比较分析。
四种进程或线程同步互斥的控制方法1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。&2、互斥量:为协调共同对一个共享资源的单独访问而设计的。&3、信号量:为控制一个具有有限数量用户资源而设计。&4、事 件:用来通知线程有一些事件已发生，从而启动后继任务的开始。&
critical section:&保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线 程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操 作共享资源的目的。&临界区包含两个操作原语：&EnterCriticalSection（） 进入临界区&LeaveCriticalSection（） 离开临界区&EnterCriticalSection（）语句执行后代码将进入临界区以后无论发生什么，必须确保与之匹配的 LeaveCriticalSection（）都能够被执行到。否则临界区保护的共享资源将永远不会被释放。虽然临界区同步速度很快，但却只能用来同步本 进程内的线程，而不可用来同步多个进程中的线程。&MFC提供了很多功能完备的类，我用MFC实现了临界区。MFC为临界区提供有一个CCriticalSection类，使用该类进行线程同步处理是 非常简单的。只需在线程函数中用CCriticalSection类成员函数Lock（）和UnLock（）标定出被保护代码片段即可。Lock（）后代 码用到的资源自动被视为临界区内的资源被保护。UnLock后别的线程才能访问这些资源。
mutex：互斥量跟临界区很相似，只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程 所访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。互斥量比临界区复杂。因为使用互斥不仅仅能够在同 一应用程序不同线程中实现资源的安全共享，而且可以在不同应用程序的线程之间实现对资源的安全共享。&
互斥量包含的几个操作原语：&CreateMutex（） 创建一个互斥量&OpenMutex（） 打开一个互斥量&ReleaseMutex（） 释放互斥量&WaitForMultipleObjects（） 等待互斥量对象&
同样MFC为互斥量提供有一个CMutex类。使用CMutex类实现互斥量操作非常简单，但是要特别注意对CMutex的构造函数的调用&CMutex( BOOL bInitiallyOwn = FALSE, LPCTSTR lpszName = NULL, LPSECURITY_ATTRIBUTES lpsaAttribute = NULL)&不用的参数不能乱填，乱填会出现一些意想不到的运行结果。
semaphore: 信号量对象对线程的同步方式与前面几种方法不同，信号允许多个线程同时使用共享资源，这与操作系统中的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（） 等待信号量&
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。
总结：&1． 互斥量与临界区的作用非常相似，但互斥量是可以命名的，也就是说它可以跨越进程使用。所以创建互斥量需要的资源更多，所以如果只为了在进程内部是用的话使 用临界区会带来速度上的优势并能够减少资源占用量。因为互斥量是跨进程的互斥量一旦被创建，就可以通过名字打开它。&2． 互斥量（Mutex），信号灯（Semaphore），事件（Event）都可以被跨越进程使用来进行同步数据操作，而其他的对象与数据同步操作无关，但 对于进程和线程来讲，如果进程和线程在运行状态则为无信号状态，在退出后为有信号状态。所以可以使用WaitForSingleObject来等待进程和 线程退出。&3． 通过互斥量可以指定资源被独占的方式使用，但如果有下面一种情况通过互斥量就无法处理，比如现在一位用户购买了一份三个并发访问许可的数据库系统，可以根 据用户购买的访问许可数量来决定有多少个线程/进程能同时进行数据库操作，这时候如果利用互斥量就没有办法完成这个要求，信号灯对象可以说是一种资源计数 器。
3.&一个全局变量tally，两个线程并发执行（代码段都是ThreadProc)，问两个线程都结束后，tally取值范围。
int&tally&= 0;&//glable
void&ThreadProc(void)
&&&&&&&for(inti&= 1;&i&&= 50;&i++)
&&&&&&&&&&&&&&tally&+= 1;
答：[50,100]
4.&子线程循环&10&次，接着主线程循环&100&次，接着又回到子线程循环&10&次，接着再回到主线程又循环&100&次，如此循环50次，试写出代码。
5. （thunder）编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC&.依次递推。
思路：用信号量进行各个子线程之间的互斥，创建3个信号量A、B、C。初始时A的资源数为1，B、C的资源数为0，访问A之后，将B的资源数加1，访问B之后将C的资源数加1，访问C之后将A的资源数加1。创建3个子线程顺序访问资源A、B、C。
1 #include "stdafx.h"
2 #include "stdio.h"
3 #include "stdlib.h"
4 #include &iostream&
5 #include &string&
6 #include &stack&
7 #include &windows.h&
8 #include &process.h&
9 using namespace
11 const int THREAD_NUM = 10;
14 unsigned int __stdcall FunA(void *pPM)
Sleep(50);//some work should to do
printf("A\n");
ReleaseSemaphore(gb, 1, NULL);//递增信号量B的资源数
23 unsigned int __stdcall FunB(void *pPM)
Sleep(50);//some work should to do
printf("B\n");
ReleaseSemaphore(gc, 1, NULL);//递增信号量C的资源数
32 unsigned int __stdcall FunC(void *pPM)
Sleep(50);//some work should to do
printf("C\n");
ReleaseSemaphore(ga, 1, NULL);//递增信号量A的资源数
41 int main()
//初始化信号量
ga = CreateSemaphore(NULL, 1, 1, NULL);//当前1个资源，最大允许1个同时访问
gb = CreateSemaphore(NULL, 0, 1, NULL);//当前0个资源，最大允许1个同时访问
gc = CreateSemaphore(NULL, 0, 1, NULL);//当前0个资源，最大允许1个同时访问
handle[THREAD_NUM];
int i = 0;
while (i & THREAD_NUM)
WaitForSingleObject(ga, INFINITE);
//等待信号量A&0
handle[i] = (HANDLE)_beginthreadex(NULL, 0, FunA, &i, 0, NULL);
WaitForSingleObject(gb, INFINITE);
//等待信号量B&0
handle[i] = (HANDLE)_beginthreadex(NULL, 0, FunB, &i, 0, NULL);
WaitForSingleObject(gc, INFINITE);
//等待信号量C&0
handle[i] = (HANDLE)_beginthreadex(NULL, 0, FunC, &i, 0, NULL);
WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);
//销毁信号量
CloseHandle(ga);
CloseHandle(gb);
CloseHandle(gc);
for (i = 0; i & THREAD_NUM; i++)
CloseHandle(handle[i]);
6. &（google）有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，以此类推.........现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式：
A：1 2 3 4 1 2....
B：2 3 4 1 2 3....
C：3 4 1 2 3 4....
D：4 1 2 3 4 1....
请设计程序。
7.&生产者消费者问题：有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，所有生产者和消费者都是异步方式运行的，但它们必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经装满产品且尚未被取走的缓冲区中投放产品。
分析：假设1个生产者，2个消费者，缓冲区大小为4。
第一．从缓冲区取出产品和向缓冲区投放产品必须是互斥进行的。可以用关键段和互斥量来完成。
第二．生产者要等待缓冲区为空，这样才可以投放产品，消费者要等待缓冲区不为空，这样才可以取出产品进行消费。并且由于有二个等待过程，所以要用二个事件或信号量来控制。
1 //1生产者 2消费者 4缓冲区
2 #include "stdafx.h"
3 #include "stdio.h"
4 #include "stdlib.h"
5 #include &iostream&
6 #include &string&
7 #include &stack&
8 #include &windows.h&
9 #include &process.h&
10 using namespace
12 //设置控制台输出颜色
13 BOOL SetConsoleColor(WORD wAttributes)
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
if (hConsole == INVALID_HANDLE_VALUE)
return FALSE;
return SetConsoleTextAttribute(hConsole, wAttributes);
22 const int END_PRODUCE_NUMBER = 8;
//生产产品个数
23 const int BUFFER_SIZE = 4;
//缓冲区个数
24 int g_Buffer[BUFFER_SIZE];
25 int g_i, g_j;
26 CRITICAL_SECTION g_
//信号量与关键段
27 HANDLE g_hSemaphoreBufferEmpty, g_hSemaphoreBufferF
29 //生产者线程函数
30 unsigned int __stdcall ProducerThreadFun(PVOID pM)
for (int i = 1; i &= END_PRODUCE_NUMBER; i++)
//等待有空的缓冲区出现
WaitForSingleObject(g_hSemaphoreBufferEmpty, INFINITE);
//互斥的访问缓冲区
EnterCriticalSection(&g_cs);
g_Buffer[g_i] =
printf("生产者在缓冲池第%d个缓冲区中投放数据%d\n", g_i, g_Buffer[g_i]);
g_i = (g_i + 1) % BUFFER_SIZE;
LeaveCriticalSection(&g_cs);
//通知消费者有新数据了
ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);
printf("生产者完成任务，线程结束运行\n");
51 //消费者线程函数
52 unsigned int __stdcall ConsumerThreadFun(PVOID pM)
while (true)
//等待非空的缓冲区出现
WaitForSingleObject(g_hSemaphoreBufferFull, INFINITE);
//互斥的访问缓冲区
EnterCriticalSection(&g_cs);
SetConsoleColor(FOREGROUND_GREEN);
编号为%d的消费者从缓冲池中第%d个缓冲区取出数据%d\n", GetCurrentThreadId(), g_j, g_Buffer[g_j]);
SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
if (g_Buffer[g_j] == END_PRODUCE_NUMBER)//结束标志
LeaveCriticalSection(&g_cs);
//通知其它消费者有新数据了(结束标志)
ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);
g_j = (g_j + 1) % BUFFER_SIZE;
LeaveCriticalSection(&g_cs);
Sleep(50); //some other work to do
ReleaseSemaphore(g_hSemaphoreBufferEmpty, 1, NULL);
SetConsoleColor(FOREGROUND_GREEN);
编号为%d的消费者收到通知，线程结束运行\n", GetCurrentThreadId());
SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
84 int main()
InitializeCriticalSection(&g_cs);
//初始化信号量,一个记录有产品的缓冲区个数,另一个记录空缓冲区个数.
g_hSemaphoreBufferEmpty = CreateSemaphore(NULL, 4, 4, NULL);
g_hSemaphoreBufferFull
= CreateSemaphore(NULL, 0, 4, NULL);
memset(g_Buffer, 0, sizeof(g_Buffer));
const int THREADNUM = 3;
HANDLE hThread[THREADNUM];
//生产者线程
hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);
//消费者线程
hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
hThread[2] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);
for (int i = 0; i & THREADNUM; i++)
CloseHandle(hThread[i]);
//销毁信号量和关键段
CloseHandle(g_hSemaphoreBufferEmpty);
CloseHandle(g_hSemaphoreBufferFull);
DeleteCriticalSection(&g_cs);
8.&读者写者问题：这也是一个非常经典的多线程题目，题目大意如下：有一个写者很多读者，多个读者可以同时读文件，但写者在写文件时不允许有读者在读文件，同样有读者读时写者也不能写。
分析：首先来找找哪些是属于&等待&情况。
第一、写者要等到没有读者时才能去写文件。
第二、所有读者要等待写者完成写文件后才能去读文件。
找完&等待&情况后，再看看有没有要互斥访问的资源。由于只有一个写者而读者们是可以共享的读文件，所以按题目要求并没有需要互斥访问的资源。
1 #include "stdafx.h"
2 #include "stdio.h"
3 #include "stdlib.h"
4 #include &iostream&
5 #include &string&
6 #include &stack&
7 #include &windows.h&
8 #include &process.h&
9 using namespace
11 //读者与写者问题
12 #include &stdio.h&
13 #include &process.h&
14 #include &windows.h&
15 //设置控制台输出颜色
16 BOOL SetConsoleColor(WORD wAttributes)
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
if (hConsole == INVALID_HANDLE_VALUE)
return FALSE;
return SetConsoleTextAttribute(hConsole, wAttributes);
24 const int READER_NUM = 5;
//读者个数
25 //关键段和事件
26 CRITICAL_SECTION g_cs, g_cs_writer_
27 HANDLE g_hEventWriter, g_hEventNoR
28 int g_nReaderC
29 //读者线程输出函数(变参函数的实现)
30 void ReaderPrintf(char *pszFormat, ...)
va_start(pArgList, pszFormat);
EnterCriticalSection(&g_cs);
vfprintf(stdout, pszFormat, pArgList);
LeaveCriticalSection(&g_cs);
va_end(pArgList);
40 //读者线程函数
41 unsigned int __stdcall ReaderThreadFun(PVOID pM)
ReaderPrintf("
编号为%d的读者进入等待中...\n", GetCurrentThreadId());
//等待写者完成
WaitForSingleObject(g_hEventWriter, INFINITE);
//读者个数增加
EnterCriticalSection(&g_cs_writer_count);
g_nReaderCount++;
if (g_nReaderCount == 1)
ResetEvent(g_hEventNoReader);
LeaveCriticalSection(&g_cs_writer_count);
//读取文件
ReaderPrintf("编号为%d的读者开始读取文件...\n", GetCurrentThreadId());
Sleep(rand() % 100);
//结束阅读,读者个数减小,空位增加
ReaderPrintf(" 编号为%d的读者结束读取文件\n", GetCurrentThreadId());
//读者个数减少
EnterCriticalSection(&g_cs_writer_count);
g_nReaderCount--;
if (g_nReaderCount == 0)
SetEvent(g_hEventNoReader);
LeaveCriticalSection(&g_cs_writer_count);
71 //写者线程输出函数
72 void WriterPrintf(char *pszStr)
EnterCriticalSection(&g_cs);
SetConsoleColor(FOREGROUND_GREEN);
%s\n", pszStr);
SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
LeaveCriticalSection(&g_cs);
80 //写者线程函数
81 unsigned int __stdcall WriterThreadFun(PVOID pM)
WriterPrintf("写者线程进入等待中...");
//等待读文件的读者为零
WaitForSingleObject(g_hEventNoReader, INFINITE);
//标记写者正在写文件
ResetEvent(g_hEventWriter);
WriterPrintf("
写者开始写文件.....");
Sleep(rand() % 100);
WriterPrintf("
写者结束写文件");
//标记写者结束写文件
SetEvent(g_hEventWriter);
99 int main()
读者写者问题\n");
printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");
//初始化事件和信号量
InitializeCriticalSection(&g_cs);
InitializeCriticalSection(&g_cs_writer_count);
//手动置位,初始已触发
g_hEventWriter = CreateEvent(NULL, TRUE, TRUE, NULL);
g_hEventNoReader
= CreateEvent(NULL, FALSE, TRUE, NULL);
g_nReaderCount = 0;
HANDLE hThread[READER_NUM + 1];
//先启动二个读者线程
for (i = 1; i &= 2; i++)
hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ReaderThreadFun, NULL, 0, NULL);
//启动写者线程
hThread[0] = (HANDLE)_beginthreadex(NULL, 0, WriterThreadFun, NULL, 0, NULL);
Sleep(50);
//最后启动其它读者结程
for ( ; i &= READER_NUM; i++)
hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ReaderThreadFun, NULL, 0, NULL);
WaitForMultipleObjects(READER_NUM + 1, hThread, TRUE, INFINITE);
for (i = 0; i & READER_NUM + 1; i++)
CloseHandle(hThread[i]);
//销毁事件和信号量
CloseHandle(g_hEventWriter);
CloseHandle(g_hEventNoReader);
DeleteCriticalSection(&g_cs);
DeleteCriticalSection(&g_cs_writer_count);