四种进程或线程同步互斥的控制方法
四种进程或线程同步互斥的控制方法
1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。
2、互斥量:为协调共同对一个共享资源的单独访问而设计的。
3、信号量:为控制一个具有有限数量用户资源而设计。
4、事件:用来通知线程有一些事件已发生，从而启动后继任务的开始。
一临界区
临界区的使用在线程同步中应该算是比较简单，说它简单还是说它同后面讲到的其它方法相比更容易理解。举个简单的例子：比如说有一个全局变量（公共资源）两个线程都会对它进行写操作和读操作，如果我们在这里不加以控制，会产生意想不到的结果。假设线程A 正在把全局变量加1然后打印在屏幕上，但是这时切换到线程B，线程B又把全局变量加1然后又切换到线程A，这时候线程A打印的结果就不是程序想要的结果，也就产生了错误。解决的办法就是设置一个区域，让线程A在操纵全局变量的时候进行加锁，线程B如果想操纵这个全局变量就要等待线程A释放这个锁，这个也就是临界区的概念。
二互斥体
windows api中提供了一个互斥体，功能上要比临界区强大。也许你要问，这个东东和临界区有什么区别，为什么强大？它们有以下几点不一致：
1.critical section是局部对象，而mutex是核心对象。因此像waitforsingleobject是不可以等待临界区的。
2.critical section是快速高效的，而mutex同其相比要慢很多
3.critical section使用围是单一进程中的各个线程，而mutex由于可以有一个名字，因此它是可以应用于不同的进程，当然也可以应用于同一个进程中的不同线程。
4.critical section 无法检测到是否被某一个线程释放，而mutex在某一个线程结束之后会产生一个abandoned的信息。同时mutex只能被拥有它的线程释放。下面举两个应用mutex 的例子，一个是程序只能运行一个实例，也就是说同一个程序如果已经运行了，就不能再运行了；另一个是关于非常经典的哲学家吃饭问题的例子。
三事件
事件对象的特点是它可以应用在重叠I/O（overlapped I/0）上，比如说socket编程中有两种模型，一种是重叠I/0，一种是完成端口都是可以使用事件同步。它也是核心对象，因此可以被waitforsingleobje这些函数等待；事件可以有名字，因此可以被其他进程开启。
四信号量
semaphore的概念理解起来可能要比mutex还难，我先简单说一下创建信号量的函数，因为我在开始使用的时候没有很快弄清楚，可能现在还有理解不对的地方，如果有错误还是请大侠多多指教。
CreateSemaphore(
LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, // SD
LONG lInitialCount, // initial count
LONG lMaximumCount, // maximum count
LPCTSTR lpName // object name
)
第一个参数是安全性，可以使用默认的安全性选项NULL；第二个和第三个参数是两个long 型的数值，它们表示什么含义呢？lMaxinumCount表示信号量的最大值，必须要大于零。比如是5就表示可以有5个进程或者线程使用，如果第六个进程或者线程想使用的话就必须进入等待队列等待有进程或者线程释放资源。lInitalCount表示信号量的初始值，应该大于或者等于零小于等于lMaximumCount。如果lInitialCount = 0 && lMaximumCount == 5，那么就表示当前资源已经全部被使用，如果再有进程或者线程想使用的话，信号量就会变成－1，该进程或者线程进入等待队列，直到有进程或者线程执行ReleaseMutex;如果lInitialCount = 5 && lMaximumCount == 5，那么就表示现在信号量可以被进程或者线程使用5次，再之后就要进行等待；如果InitialCount = 2 && MaximumCount == 5这样的用法不太常见，表示还可以调用两次CreateSemaphore或者OpenSemaphore，再调用的话就要进入等待状态。最后一个参数表示这个信号量的名字，这样就可以跨进程的时候通过这个名字OpenSemaphore。
总结：
1．互斥量与临界区的作用非常相似，但互斥量是可以命名的，也就是说它可以跨越进程使用。所以创建互斥量需要的资源更多，所以如果只为了在进程部是用的话使用临界区会带来速度上的优势并能够减少资源占用量。因为互斥量是跨进程的互斥量一旦被创建，就可以通过名字打开它。
2．互斥量（Mutex），信号灯（Semaphore），事件（Event）都可以被跨越进程使用来进行同步数据操作，而其他的对象与数据同步操作无关，但对于进程和线程来讲，如果进程和线程在运行状态则为无信号状态，在退出后为有信号状态。所以可以使用WaitForSingleObject来等待进程和线程退出。
3．通过互斥量可以指定资源被独占的方式使用，但如果有下面一种情况通过互斥量就无法处理，比如现在一位用户购买了一份三个并发访问许可的数据库系统，可以根据用户购买的访问许可数量来决定有多少个线程/进程能同时进行数据库操作，这时候如果利用互斥量就没有办法完成这个要求，信号灯对象可以说是一种资源计数器。
六。CreateMutex()与CreateEvent() 区别
使用CreateMutex()来产生一个Mutex物件，而传入的Mutex名称字串用以区别不同的Mutex
，也就是说，不管是哪个Process/Thread，只要传入的名称叁数是相同的一个字串，那CreateMutex()传回值(hMutex, handle of Mutex)会指向相同的一个Mutex物件。这和Event物件相同。然而Mutex和Event有很大的不同，Mutex有Owner的概念，如果Mutex 为
ThreadA所拥有，那麽ThreadA执行WaitForSingleObject()时，并不会停下来，而会立即传回WAIT_OBJECT_0，而其他的Thread执行WaitForSingleObject()则会停下来，直到Mutex
的所有权被Release出来或Time Out。
如果一个Thread已取得Mutex的所有权，而它呼叫WaitForSingleObject()
n 次，则也要使用ReleaseMutex n次才能够将Mutex的拥有权放弃，这和Event也不同，而
且，非Mutex拥有者呼叫ReleaseMutex也不会有任何作用。而每次以WaitForSingleObject
呼叫一次，Mutex会有一个计数器会加一，ReleaseMutex成功会减一，直到Mutex的计数器为0之後，系统才会将之去除。
临界区（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)
不用的参数不能乱填，乱填会出现一些意想不到的运行结果。
信号量（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（）等待信号量
事件（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．通过互斥量可以指定资源被独占的方式使用，但如果有下面一种情况通过互斥量就无法处理，比如现在一位用户购买了一份三个并发访问许可的数据库系统，可以根据用户购买的访问许可数量来决定有多少个线程/进程能同时进行数
据库操作，这时候如果利用互斥量就没有办法完成这个要求，信号灯对象可以说是一种资源计数器。
首选使用临界区对象,主要原因是使用简单。
EnterCriticalSection（）函数等候指定的危险区段对象的所有权。当调用的线程被允许所有权时，函数返回。
EnterCriticalSection （），一个单独进程的线程可以使用一个危险区段对象作为相互-排除同步。进程负责分配被一个危险区段对象使用的存, 它藉由声明一个CRITICAL_SECTION类型的变量实现。在使用一个危险区段之前，进程的一些线程必须调用InitializeCriticalSection 函数设定对象的初值.
为了要使互斥的访问被共享的资源,每个线程调用EnterCriticalSection 或者TryEnterCriticalSection 功能，在执行访问被保护资源的任何代码段之前，请求危险区段的所有权。
#include
#include
using namespace std;
DWORD WINAPI Fun1Proc(LPVOID lpParameter);
DWORD WINAPI Fun2Proc(LPVOID lpParameter);
int tickets=100;
CRITICAL_SECTION g_csA;
CRITICAL_SECTION g_csB;
void main()
{
HANDLE hThread1;
HANDLE hThread2;
hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);
hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);
CloseHandle(hThread1);
CloseHandle(hThread2);
InitializeCriticalSection(&g_csA);
InitializeCriticalSection(&g_csB);
Sleep(40000);
DeleteCriticalSection(&g_csA);
DeleteCriticalSection(&g_csB);
}
DWORD WINAPI Fun1Proc(LPVOID lpParameter)
{
while (TRUE)
{
EnterCriticalSection(&g_csA);
Sleep(1);
//EnterCriticalSection(&g_csB);//临界区的同步和互锁if (tickets>0)
{
Sleep(1);
cout<<"Thread1 sell ticket :"< //LeaveCriticalSection(&g_csB); LeaveCriticalSection(&g_csA); } else { //LeaveCriticalSection(&g_csB); LeaveCriticalSection(&g_csA); break; } } return 0; } DWORD WINAPI Fun2Proc(LPVOID lpParameter) { while (TRUE) { EnterCriticalSection(&g_csB); Sleep(1); EnterCriticalSection(&g_csA); if (tickets>0) { Sleep(1); cout<<"Thread2 sell ticket :"< LeaveCriticalSection(&g_csA); LeaveCriticalSection(&g_csB); } else { LeaveCriticalSection(&g_csA); LeaveCriticalSection(&g_csB); break; } } return 0; } 二、使用互斥对象 DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds); 如果时间是有信号状态返回WAIT_OBJECT_0，如果时间超过dwMilliseconds值但时间事件还是无信号状态则返回WAIT_TIMEOUT WaitForSingleObject函数用来检测hHandle事件的信号状态，当函数的执行时间超过dwMilliseconds就返回，但如果参数dwMilliseconds为INFINITE时函数将直到相应时间事件变成有信号状态才返回，否则就一直等待下去，直到WaitForSingleObject有返回直才执行后面的代码。 #include #include using namespace std; DWORD WINAPI Fun1Proc(LPVOID lpParameter); DWORD WINAPI Fun2Proc(LPVOID lpParameter); int index =0; int tickets=100; HANDLE hMutex; void main() { HANDLE hThread1; HANDLE hThread2; hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL); //创建线程 hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL); CloseHandle(hThread1); CloseHandle(hThread2); //保证应用程序只有一个实例运行,创建一个命名的互斥对象. hMutex=CreateMutex(NULL,TRUE,LPCTSTR("tickets")); //创建时主线程拥有该互斥对象,互斥对象的线程ID为主线程的ID,同时将该互斥对象部计数器置为1 if (hMutex) { if (ERROR_ALREADY_EXISTS==GetLastError()) { cout<<"only one instance can run!"< //Sleep(40000); return; } } WaitForSingleObject(hMutex,INFINITE); //使用该函数请求互斥对象时,虽说该对象处于无信号状态,但因为请求的线程ID和该互斥 对象所有者的线程ID是相同的.所以仍然可以请求到这个互斥对象,于是该互斥对象部计数器加1,部计数器的值为2. 意思是有两个等待动作 ReleaseMutex(hMutex);//释放一次互斥对象,该互斥对象部计数器的值递减1,操作系统不会将这个互斥对象变为已通知状态. ReleaseMutex(hMutex);//释放一次互斥对象,该互斥对象部计数器的值为0,同时将该对象设置为已通知状态. //对于互斥对象来说,谁拥有谁释放 Sleep(40000); } DWORD WINAPI Fun1Proc(LPVOID lpParameter) { while (TRUE) { WaitForSingleObject(hMutex,INFINITE);//等待互斥对象有信号 if (tickets>0) { Sleep(1); cout<<"thread1 sell ticket :"< } else break; ReleaseMutex(hMutex);//设置该互斥对象的线程ID为0,并且将该对象设置为有信号状态} return 0; } DWORD WINAPI Fun2Proc(LPVOID lpParameter) { while (TRUE) { WaitForSingleObject(hMutex,INFINITE); if (tickets>0) { Sleep(1); cout<<"thread2 sell ticket :"< } else break; ReleaseMutex(hMutex); } return 0; } 三、使用事件对象 HANDLE CreateEvent( LPSECURITY_ATTRIBUTES lpEventAttributes, // SD BOOL bManualReset, // reset type BOOL bInitialState, // initial state LPCTSTR lpName // object name ); 该函数创建一个Event同步对象,并返回该对象的Handle lpEventAttributes 一般为NULL bManualReset 创建的Event是自动复位还是人工复位 ,如果true,人工复位, 一旦该Event被设置为有信号,则它一直会等到ResetEvent()API被调用时才会恢复 为无信号. 如果为false,Event被设置为有信号,则当有一个wait到它的Thread时, 该Event就会自动复位,变成无信号. bInitialState 初始状态,true,有信号,false无信号 lpName Event对象名 一个Event被创建以后,可以用OpenEvent()API来获得它的Handle,用CloseHandle() 来关闭它,用SetEvent()或PulseEvent()来设置它使其有信号,用ResetEvent() 来使其无信号,用WaitForSingleObject()或WaitForMultipleObjects()来等待 其变为有信号. PulseEvent()是一个比较有意思的使用方法,正如这个API的名字,它使一个Event 对象的状态发生一次脉冲变化,从无信号变成有信号再变成无信号,而整个操作是原子的. 对自动复位的Event对象,它仅释放第一个等到该事件的thread（如果有),而对于 人工复位的Event对象,它释放所有等待的thread. #include #include using namespace std; DWORD WINAPI Fun1Proc(LPVOID lpParameter); DWORD WINAPI Fun2Proc(LPVOID lpParameter); int tickets=100; HANDLE g_hEvent; void main() { HANDLE hThread1; HANDLE hThread2; //************************************************** //创建一个命名的自动重置事件核对象 g_hEvent=CreateEvent(NULL,FALSE,FALSE,LPCTSTR("tickets")); if (g_hEvent) { if (ERROR_ALREADY_EXISTS==GetLastError()) { cout<<"only one instance can run!"< return; } } //************************************************** SetEvent(g_hEvent); //创建线程 hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL); hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL); Sleep(40000); //关闭事件对象句柄 CloseHandle(g_hEvent); } DWORD WINAPI Fun1Proc(LPVOID lpParameter) { while (TRUE) { WaitForSingleObject(g_hEvent,INFINITE); //ResetEvent(g_hEvent); if (tickets>0) { Sleep(1); cout<<"thread1 sell ticket :"< SetEvent(g_hEvent); } else { SetEvent(g_hEvent); break; } } return 0; } DWORD WINAPI Fun2Proc(LPVOID lpParameter) { while (TRUE) { WaitForSingleObject(g_hEvent,INFINITE); //ResetEvent(g_hEvent); if (tickets>0) { cout<<"Thread2 sell ticket :"< SetEvent(g_hEvent); } else { SetEvent(g_hEvent); break; } } return 0; } 一个经典的多线程同步问题 程序描述： 主线程启动10个子线程并将表示子线程序号的变量地址作为参数传递给子线程。子线程接收参数 -> sleep(50) -> 全局变量++ -> sleep(0) -> 输出参数和全局变量。 要求： 1．子线程输出的线程序号不能重复。 2．全局变量的输出必须递增。 下面画了个简单的示意图： 分析下这个问题的考察点，主要考察点有二个： 1．主线程创建子线程并传入一个指向变量地址的指针作参数，由于线程启动须要花费一定的时间，所以在子线程根据这个指针访问并保存数据前，主线程应等待子线程保存完毕后才能改动该参数并启动下一个线程。这涉及到主线程与子线程之间的同步。 2．子线程之间会互斥的改动和输出全局变量。要求全局变量的输出必须递增。这涉及到各子线程间的互斥。 下面列出这个程序的基本框架，可以在此代码基础上进行修改和验证。 //经典线程同步互斥问题 #include HANDLE handle[THREAD_NUM]; int i = 0; while (i < THREAD_NUM) { handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL); i++;//等子线程接收到参数时主线程可能改变了这个i的值} //保证子线程已全部运行结束 WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE); return 0; } unsigned int__stdcall Fun(void *pPM) { //由于创建线程是要一定的开销的，所以新线程并不能第一时间执行到这来int nThreadNum = *(int *)pPM; //子线程获取参数 Sleep(50);//some work should to do g_nNum++; //处理全局资源 Sleep(0);//some work should to do printf("线程编号为%d 全局资源值为%d\n", nThreadNum, g_nNum); return 0; } 运行结果： 学习中心： 专业： 年级：年春/秋季 学号： 学生： 题目：进程同步与互斥生产者-消费者问题 1.谈谈你对本课程学习过程中的心得体会与建议？ 转眼间，学习了一个学期的计算机操作系统课程即将结束。在这个学期中，通过老师的悉心教导，让我深切地体会到了计算机操作系统的一些原理和具体操作过程。在学习操作系统之前，我只是很肤浅地认为操作系统只是单纯地讲一些关于计算机方面的操作应用，并不了解其中的具体操作过程 1.1设计思路 在这次设计中定义的多个缓冲区不是环形循环的，并且不需要按序访问。其中生产者可以把产品放到某一个空缓冲区中，消费者只能消费被指定生产者生产的产品。本设计在测试用例文件中指定了所有生产和消费的需求，并规定当共享缓冲区的数据满足了所有有关它的消费需求后，此共享才可以作为空闲空间允许新的生产者使用。 本设计在为生产者分配缓冲区时各生产者之间必须互斥，此后各个生产者的具体生产活动可以并发。而消费者之间只有在对同一个产品进行消费时才需要互斥，它们在消费过程结束时需要判断该消费者对象是否已经消费完毕并释放缓冲区的空间。 1.2程序流程图 1.3基本内容 在设计程序时主要有三个主体部分、三个辅助函数和一个数据结构。 其中主体部分为一个主函数main（），用于初始化缓冲区和各个同步对象，并完成线程信息的读入，最后根据该组的线程记录启动模拟线程，并等待所有线程的运 Y 行结束后退出程序； 生产者函数Produce（）和消费者函数Consume（），生产者和消费者函数运行于线程中完成对缓冲区的读、写动作，根据此处生产消费的模型的特点，生产者和消费者之间通过使用同步对象实现了生产和消费的同步与互斥，是本实验的核心所在。 另外三个辅助性函数被生产者和消费者函数调用，是上述生产和消费函数中对缓冲区进行的一系列处理。 3)在实现本程序的消费生产模型时，具体的通过如下同步对象实现互斥： ①设一个互斥量h_mutex，以实现生产者在查询和保留缓冲区内的下一个位置时进行互斥。 ②每一个生产者用一个信号量与其消费者同步，通过设置h_Semaphore[MAX_THREAD_NUM]信号量 ③数组实现，该组信号量用于相应的产品已产生。同时用一个表示空缓冲区 用信号量实现线程同步与互斥 一、相关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 是线程函数 名；函数名称没有限制，但是必须以下列形式声明：DWORD WINAPI ThreadProc (PVOID pParam) ； ?lpParameter：指定了线程执行时传送给线程的32位参数，即线程函数的参数； ?dwCreationFlags：控制线程创建的附加标志，可以取两种值。如果该参数为0，线程在被创建后就会立即开始执行；如果该参数为CREATE_SUSPENDED,则系统产 生线程后，该线程处于挂起状态，并不马上执行，直至函数ResumeThread被调用； ?lpThreadId：该参数返回所创建线程的ID。 如果创建成功则返回线程的句柄，否则返回NULL。 例如： for (int i=0;i 实验3 报告 源程序1 /** 作者：wwj 时间：2012/4/12 功能：实现吃水果问题 **题目内容：桌子有一只盘子，只允许放一个水果，父亲专向盘子放苹果，母亲专向盘子放桔子儿子专等吃盘子的桔子，女儿专等吃盘子的苹果。只要盘子为空，父亲或母亲就可以向盘子放水果，仅当盘子有自己需要的水果时，儿子和女儿可从盘子取出。请给出四个人之间的同步关系，并用pv操作实现四个人的正确活动的问题。** **题目分析：父亲和女儿是相互制约的，父亲进程执行完即往盘中放入苹果后，女儿进程才能执行即吃苹果，是同步关系； 母亲和儿子是相互制约的，母亲进程执行完即往盘中放入桔子，儿子进程才能执行即吃桔子，也是同步关系 而父亲和母亲这两个进程不能同时进行，是互斥关系；** **/ #include 实验报告 1、实验名称 进程间的互斥和同步 2、小组成员：姓名+学号 3、实验目的 Linux命名信号量实现进程间的互斥和同步 4、实验背景知识 进程同步也是进程之间直接的制约关系，是为完成某种任务而建立的两个或多个线程，这个线程需要在某些位置上协调他们的工作次序而等待、传递信息所产生的制约关系。进程间的直接制约关系来源于他们之间的合作。比如说进程A需要从缓冲区读取进程B产生的信息，当缓冲区为空时，进程B因为读取不到信息而被阻塞。而当进程A产生信息放入缓冲区时，进程B才会被唤醒。 进程互斥是进程之间的间接制约关系。当一个进程进入临界区使用临界资源时，另一个进程必须等待。只有当使用临界资源的进程退出临界区后，这个进程才会解除阻塞状态。比如进程B需要访问打印机，但此时进程A占有了打印机，进程B会被阻塞，直到进程A释放了打印机资源,进程B才可以继续执行。 5、实验步骤演示 大概步骤： 先进行单次同步，把信号量先初始化为0，创建一个命名信号量，设置信号捕捉处理代码，安装捕捉信号；其次使用信号量进行同步和互斥的操作。 详细步骤： 1.创建一个命名信号量，sem = sem_open(SEM_NAME, OPEN_FLAG, OPEN_MODE, INIT_V); 2.创建子进程，pid = fork(); 3.V操作，sem_post(sem); 4.P操作，sem_wait(sem); 5.等待子进程结束，wait(&status); 6.删掉在系统创建的信号量，sem_unlink(SEM_NAME); 7.彻底销毁打开的信号量，sem_close(sem); 8.信号捕捉处理，static void myhandler(void); 9.迭代同步,两个信号量，开始时一个为1，一个为0，一个进程执行完换另一个执行； 10.安装捕捉信号，signal(SIGINT,(void *)myhandler ); 11.创建一个命名信号量：sem1 = sem_open(SEM_NAME1, OPEN_FLAG, OPEN_MODE, 1);sem2 = sem_open(SEM_NAME2, OPEN_FLAG, OPEN_MODE, 0); 12.创建子进程，pid = fork(); 13.if(0 == pid) P操作：sem_wait(sem1); V操作：sem_post(sem2); 14.if(0 < pid) P操作：sem_wait(sem2); V操作：sem_post(sem1); 15.static void mysem(char *str) { int i = 0; //P操作 sem_wait(sem); while('\0' != str[i]) { printf("%c\n", str[i++]); sleep(1); } //V操作 sem_post(sem); } 进程排斥,在临界区设置PV操作 16.创建一个命名信号量，sem = sem_open(SEM_NAME, OPEN_FLAG, OPEN_MODE, INIT_V); 17.if(0 == pid) { mysem("abcd"); } 18.if(0 < pid) { mysem("1234"); //等待子进程结束 wait(&status); //删掉在系统创建的信号量 sem_unlink(SEM_NAME); //彻底销毁打开的信号量 sem_close(sem); } 说明： 命名信号量不带内存共享,编译时要带库文件-lpthread或-lrt 实验五线程间的互斥与同步 实验学时：2学时 实验类型：验证、设计型 一、实验目的 理解POSIX线程（Pthread）互斥锁和POSIX信号量机制，学习它们的使用方法；编写程序，实现多个POSIX线程的同步控制。 二，实验内容 创建4个POSIX线程。其中2个线程(A和B)分别从2个数据文件(data1.txt和data2.txt)读取10个整数. 线程A和B把从文件中读取的逐一整数放入一个缓冲池. 缓冲池由n个缓冲区构成（n=5，并可以方便地调整为其他值），每个缓冲区可以存放一个整数。另外2个线程，C和D，各从缓冲池读取10数据。线程C、D每读出2个数据，分别求出它们的和或乘积，并打印输出。 提示：在创建4个线程当中，A和B是生产者，负责从文件读取数据到公共的缓冲区，C和D是消费者，从缓冲区读取数据然后作不同的计算（加和乘运算）。使用互斥锁和信号量控制这些线程的同步。不限制线程C和D从缓冲区得到的数据来自哪个文件。 在开始设计和实现之前，务必认真阅读课本6.8.4节和第6章后面的编程项目——生产者-消费者问题。 三，实验要求 按照要求编写程序，放在相应的目录中，编译成功后执行，并按照要求分析执行结果，并写出实验报告。 四，实验设计 1，功能设计 根据实验要求，主程序需要创建四个线程，两个线程负责从文件读取数据到缓冲区，两个线程负责将缓冲区的数据做数学运算。由于同一个进程中的各个线程共享资源，可以用一个二维数组的全局变量作为公共缓冲区，同时还需要一个整形全局变量size用来做数组的索引。读线程的运行函数打开不同的文件并从中读取数据到二维数组中，每次写入数组后size加一。运算线程从二维数组中读数并做运算，每次读数之前size减一。本题的关键在于如何使用信号量保证进程的同步与互斥。在运算线程从缓冲区读取之前缓冲区里必须有数，即任意时刻运算操作的执行次数必须小于等于读取操作的执行次数。同时应该保证两个读线程和两个运算线程两两互斥。由于以上分析，使用了四个信号量sem1，sem2，sem3和sem4。sem1保证线程1和线程2互斥，sem2保证线程3和线程4互斥，sem3保证线程3和线程4互斥，sem4保证线程4和线程1互斥。即这四个信号量使四个线程循环进行，从而保证了运行结果的正确性。 源代码及注释： #include 实验四：进程的管道通信 实验题目 进程的管道通信 实验目的 加深对进程概念的理解，明确进程和程序的区别。学习进程创建的过程，进一步认识进程并发执行的实质。分析进程争用资源的现象，学习解决进程互斥的方法。学习解决进程同步的方法。掌握Linux系统中进程间通过管道通信的具体实现 实验内容 使用系统调用pipe()建立一条管道，系统调用fork()分别创建两个子进程，它们分别向管道写一句话，如： Child process1 is sending a message! Child process2 is sending a message! 父进程分别从管道读出来自两个子进程的信息，显示在屏幕上。 当然，仅仅通过屏幕上输出这两句话还不能说明实现了进程的管道通信，为了能够更好的证明和显示出进程的同步互斥和通信，在其中要加入必要的跟踪条件，如一定的输出语句等，来反映程序的并发执行情况 实验要求 这是一个设计型实验，要求自行、独立编制程序。两个子进程要并发执行。实现管道的互斥使用。当一个子进程正在对管道进行写操 作时，另一个欲写入管道的子进程必须等待。使用系统调用lockf(fd[1],1,0)实现对管道的加锁操作，用lockf(fd[1],0,0)解除对管道的锁定。实现父子进程的同步，当父进程试图从一空管道中读取数据时，便进入等待状态，直到子进程将数据写入管道返回后，才将其唤醒。 为了清楚的反应进程的同步，在子进程完成相应的操作后，调用sleep()函数睡眠一段时间（程序中定为3s）。父进程先执行wait()函数，当有子进程执行完毕后，会得到子进程的返回结果并清理子进程。若子进程没执行完，父进程一直执行wait()进行监听，知道有一个子进程执行完成为僵尸进程。 程序中用到的系统调用 因为程序时在linux系统上进行编写的，所以其中要利用到相关的linux提供的系统调用。 所用到的系统调用包含在如下头文件中。 #include 四种进程或线程同步互斥的控制方法 1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。 2、互斥量:为协调共同对一个共享资源的单独访问而设计的。 3、信号量:为控制一个具有有限数量用户资源而设计。 4、事件:用来通知线程有一些事件已发生，从而启动后继任务的开始。 一临界区 临界区的使用在线程同步中应该算是比较简单，说它简单还是说它同后面讲到的其它方法相比更容易理解。举个简单的例子：比如说有一个全局变量（公共资源）两个线程都会对它进行写操作和读操作，如果我们在这里不加以控制，会产生意想不到的结果。假设线程A 正在把全局变量加1然后打印在屏幕上，但是这时切换到线程B，线程B又把全局变量加1然后又切换到线程A，这时候线程A打印的结果就不是程序想要的结果，也就产生了错误。解决的办法就是设置一个区域，让线程A在操纵全局变量的时候进行加锁，线程B如果想操纵这个全局变量就要等待线程A释放这个锁，这个也就是临界区的概念。 二互斥体 windows api中提供了一个互斥体，功能上要比临界区强大。也许你要问，这个东东和临界区有什么区别，为什么强大？它们有以下几点不一致： 1.critical section是局部对象，而mutex是核心对象。因此像waitforsingleobject是不可以等待临界区的。 2.critical section是快速高效的，而mutex同其相比要慢很多 3.critical section使用围是单一进程中的各个线程，而mutex由于可以有一个名字，因此它是可以应用于不同的进程，当然也可以应用于同一个进程中的不同线程。 4.critical section 无法检测到是否被某一个线程释放，而mutex在某一个线程结束之后会产生一个abandoned的信息。同时mutex只能被拥有它的线程释放。下面举两个应用mutex 的例子，一个是程序只能运行一个实例，也就是说同一个程序如果已经运行了，就不能再运行了；另一个是关于非常经典的哲学家吃饭问题的例子。 三事件 事件对象的特点是它可以应用在重叠I/O（overlapped I/0）上，比如说socket编程中有两种模型，一种是重叠I/0，一种是完成端口都是可以使用事件同步。它也是核心对象，因此可以被waitforsingleobje这些函数等待；事件可以有名字，因此可以被其他进程开启。 四信号量 semaphore的概念理解起来可能要比mutex还难，我先简单说一下创建信号量的函数，因为我在开始使用的时候没有很快弄清楚，可能现在还有理解不对的地方，如果有错误还是请大侠多多指教。 CreateSemaphore( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, // SD LONG lInitialCount, // initial count LONG lMaximumCount, // maximum count LPCTSTR lpName // object name ) 进程同步与互斥 进程的PV操作 在操作系统中，P、V操作是进程管理中的难点。这是1968年荷兰人Dijkstra 给出的一种解决并发进程间互斥和同步关系的通用方法。 1. P、V操作的意义 定义了信号量及其上的P操作和V操作，来实现并发进程间的同步和互斥，甚至可以用来管理资源的分配。P、V操作因交换的信息量少，属于进程的低级通信。 2. 什么是信号量？ 信号量（semaphore）是由一个值和一个指针构成的数据结构。值为整型变 量，表示信息量的值；指针指向进程控制块（PCB）队列的队头，表示等待该信号量的下一个进程。如下图所示。 信号量的一般结构及PCB队列 信号量的值与相应资源的使用情况有关。当它的值大于0时，表示当前可用资源的数量；当它的值小于0时，其绝对值表示等待使用该资源的进程个数。注意，信号量的初值不能为负，且其值只能由P、V操作来改变。 3. P、V操作的含义 P、V操作由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量S进行操作，具体定义如下： P（S）： ①将信号量S的值减1，即S=S-1； ②如果S≥0，则该进程继续执行；否则该进程状态置为阻塞状态，进程PCB 排入信号量PCB队列末尾，放弃CPU，等待V操作的执行。 V（S）： ①将信号量S的值加1，即S=S+1； ②如果S≤0，释放信号量队列中第一个PCB所对应的进程，将进程状态由阻塞态改为就绪态。执行V操作的进程继续执行。 一般来说，信号量S≥0时，S表示可用资源的数量。执行一次P操作意味着请求分配一个单位资源，因此S的值减1；当S<0时，表示已经没有可用资源，请求者必须等待别的进程释放该类资源，它才能运行下去。而执行一个V操作意味着释放一个单位资源，因此S的值加1；若S≤0，表示有某些进程正在等待该资源，因此要唤醒一个阻塞状态的进程，使之成为就绪状态。 4. 利用信号量和P、V操作实现进程互斥 一般地，n个进程利用信号量和P、V操作实现进程互斥的一般模型如下： 进程P 1进程P 2 ……进程Pn …… …… …… P（S）； P（S）； P（S）； 临界区；临界区；临界区； V（S）； V（S）； V（S）； …… …… …… …… 其中S是互斥信号量，初值为1。 使用P、V操作实现进程互斥时应该注意的问题是： （1）每个程序中，用户实现互斥的P、V操作必须成对出现，先做P操作，进临界区，后做V操作，出临界区。若有多个分支，要认真检查P、V操作的成对性。 （2）P、V操作应分别紧靠临界区的头尾部，临界区的代码应尽可能短，不能有死循环。 （3）互斥信号量的初值一般为1。 由于用于互斥的信号量sem与所有的并发进程有关，所以称之为公有信号量。公有信号量的值反映了公有资源的数量。只要把临界区置于P(sem)和V(sem) 进程间互斥与同步 实验内容： 编写算法，实现进程间对临界资源的互斥访问以及进程间的同步关系。 实验要求： 1、要求进程互斥使用文本文件； 2、假定文本文件txt1最大可写入30个字符； 3、写满后复制进程将文本文件的内容复制到另一个文本文件txt2中（无长度限制）。 4、复制进程复制完毕写入进程可再重新写入，重复执行3，4，直到给出停止命令。 5、实现进程间的同步和互斥。 代码： #include sem_b.sem_num=0; sem_b.sem_op=1; sem_b.sem_flg=SEM_UNDO; if(semop(sem_id,&sem_b,1)==-1) { cout<<"error"< 操作系统实验报告 课程名称操作系统实验名称进程（线程）的同步与互斥成绩 学生姓名作业君专业软件工程班级、学号 同组者姓名无实验日期2020 一、实验题目:进程（线程）的同步与互斥 二、实验目的： 自行编制模拟程序，通过形象化的状态显示，加深理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。1．掌握基本的同步与互斥算法，理解生产者消费者模型。 2．学习使用Windows中基本的同步对象，掌握相关API的使用方法。 3．了解Windows中多线程的并发执行机制，实现进程的同步与互斥 三、实验内容与要求： 1．实验内容 以生产者/消费者模型为依据，在Windows 环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 2．实验要求 学习并理解生产者/消费者模型及其同步/互斥规则； 学习了解Windows同步对象及其特性； 熟悉实验环境，掌握相关API的使用方法； 设计程序，实现生产者/消费者进程(线程)的同步与互斥； 四、算法描述（含数据结构定义）或流程图 #include #define MAX_THREAD_NUM 64 //最大线程数 #define INTE_PER_SEC 1000 //延迟时间的毫秒值 const int SIZE_OF_BUFFER = 10; //缓冲区长度 int ProductID = 0; //产品号 int ConsumeID = 0; //将被消耗的产品号 int in = 0; //产品进缓冲区时的缓冲区下标 int out = 0; //产品出缓冲区时的缓冲区下标 bool running = true; //判断程序能否继续执行的逻辑值 int g_buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列 HANDLE g_hMutex; //公有信号量，用于线程间的互斥HANDLE g_hFullSemaphore; //生产者的私有信号量，当缓冲区满时迫使生产者等待 HANDLE g_hEmptySemaphore; //消费者的私有信号量，当缓冲区空时迫使消费者等待 //定义一个结构体用于存储线程的信息 struct ThreadInfo { int serial; //线程号 char entity; //线程类别(生产者或消费者) double delay; //等待时间 double persist; //操作时间 }; //生产者 void Producer(void* p) { //定义变量用于存储当前线程的信息 DWORD m_delay; DWORD m_persist; int m_serial; //从参数中获得信息 m_serial = ((ThreadInfo*)(p))->serial; m_delay = (DWORD)(((ThreadInfo*)(p))->delay * INTE_PER_SEC); m_persist = (DWORD)(((ThreadInfo*)(p))->persist * INTE_PER_SEC); while (running) { //P操作 cout << "生产者线程 " << m_serial << " 请求生产." << endl; WaitForSingleObject(g_hEmptySemaphore, INFINITE); 习题解答: ?何谓与时间有关的错误? 举例说明之。 答：并发进程的执行实际上是进程活动的某种交叉，某些交叉次序可能得到错误结果。由于具体交叉的形成与进程的推进速度有关，而速度是时间的函数，因而将这种错误称为与时间有关的错误。 例如，两个并发进程的程序如下： int n=0; main( ){ 创建进程A； 创建进程B； }； A( ){ while(1){ n++; } }; B( ){ while(1){ 睡眠一段时间；printf(“%d”,n); n=0; } }; 假设进程A被部署在公园入口的终端上，用来记录一段时间内进入公园的人数，进程B被部署在公园的控制中心，用来输出一段时间内进入公园的总人数。进程A和进程B共享全局变量n，n表示记录下的人数。如果在进程B执行完打印语句后被进程A打断，进程A执行了若干次变量自增语句，之后进程B接着执行清0语句，那么进程A对n的累加丢失了，相当于进程B被打断的这段时间内进入公园的人没有被记录下来。发生与时间有关的错误。 ?有人说，假设两个进程之间没有共享内存，则二者之间没有公共变量，这种说法准确吗? 说明原因。 答：如果只从用户空间考虑，这种说法是正确的。但从操作系统的角度来说并不准确。两个没有公共内存的用户进程可能同时（宏观）进入操作系统，并访问操作系统空间中的公共变 量。 ?何谓忙式等待? 是否还有其它方式的等待? 比较它们之间的联系和差别。 答：不进入等待状态的等待称为忙式等待。另一种等待方式是阻塞式等待，进程得不到共享资源时将进入阻塞状态，让出CPU给其他进程使用。忙等待和阻塞式等待的相同之处在于进程都不具备继续向前推进的条件，不同之处在于处于忙等待的进程不主动放弃CPU，尽管CPU 可能被剥夺，因而是低效的；而处于阻塞状态的进程主动放弃CPU，因而是高效的。 ?下列进程互斥方法哪些存在忙式等待问题? （1）软件: 面包店算法(2) 硬件: TS指令(3) 关中断指令 答：（1）、（2）存在忙等待问题。 ?为何开关中断进程互斥方法仅在单CPU系统中是有效的？ 答：关中断方法不适用于多CPU系统，因为关中断只能保证CPU不由一个进程切换到另外一个进程，从而防止多个进程并发地进入公共临界区域。但即使关中断后，不同进程仍可以在不同CPU上并行执行关于同一组共享变量的临界区代码. ?在多处理机系统中，软件互斥方法是否有效？为什么？ 答：依然有效。多处理机并行与单处理并发之间的差别在于程序交叉的粒度，单处理机机环境中进程交叉发生在指令之间，多处理机环境中进程交叉发生在指令周期之间。由于纯软件互斥算法并不依赖特殊的硬件指令(如test_and_set)，指令之间的交叉与指令周期之间的交叉结果相同。 ?试分析临界区域的大小与系统并发性之间的关系。 答：关于同一组变量的临界区域是不能并发执行的代码，临界区越大，并发性越差，因而编写并发程序应尽量缩小临界区域范围。 ?设CR1是关于一组共享变量SV1的临界区域，CR2是关于另外一组共享变量SV2的临 实验1编程实现进程（线程）同步和互斥 一、实验目的 ①通过编写程序实现进程同步和互斥，使学生掌握有关进程（线程）同步与 互斥的原理，以及解决进程（线程）同步和互斥的算法，从而进一步巩固进程（线程）同步和互斥 ②等有关的内容。 ③了解Windows2000/XP中多线程的并发执行机制，线程间的同步和互斥。 ④学习使用Windows2000/XP中基本的同步对象，掌握相应的 ⑤API函数。 ⑥掌握进程和线程的概念，进程（线程）的控制原语或系统调用的使用。 ⑦掌握多道程序设计的基本理论、方法和技术，培养学生多道程序设计的能 力。 二、实验内容 在Windows XP、Windows 2000等操作系统下，使用的VC、VB、java或C 等编程语言，采用进程（线程）同步和互斥的技术编写程序实现生产者消费者问题或哲学家进餐问题或读者-写者问题或自己设计一个简单进程（线程）同步和互斥的实际问题。 三、实验要求 ①经调试后程序能够正常运行。 ②采用多进程或多线程方式运行，体现了进程（线程）同步和互斥的关系。 ③程序界面美观。 四、实验步骤、过程 让写者与读者、读者与读者之间互斥的访问同一数据集，在无写者进程到来时各读者可同时的访问数据集，在读者和写者同时等待时写者优先唤醒。设置两个全局变量readcount 和writecount来记录读者与写者的数目，设置了3个信号量。h_mutex1表示互斥对象对阻塞在read这一个过程实现互斥，h_mutex2实现全局变量readcount操作上的互斥，h_mutex3实现对全局变量writecount的互斥访问。设置了两个临界区，为了实现写者优先，用了临界区read。数据结构：（1）用了两个临界区（2）自定义结构ThreadInfo记录一条线程信息，多个线程对应一个ThreadInfo数组。（3）设置了互斥量h_mutex1，实现了互斥对象对阻 同步和互斥的区别 信号量互斥量条件变量 同步和互斥 一、信号量：用于进程间通信（linux中用于线程） 独立于进程在两个进程中都要初始化，若一个已创建，则另一个获取可以执行多次v操作，然后再执行p操作 信号量的一些概念： 以下是信号灯（量)的一些概念: 信号灯与互斥锁和条件变量的主要不同在于”灯”的概念，灯亮则意味着资源可用，灯灭则意味着不可用。如果说后两中同步方式侧重于”等待”操作，即资源不可用的话，信号灯机制则侧重于点灯，即告知资源可用；没有等待线程的解锁或激发条件都是没有意义的，而没有等待灯亮的线程的点灯操作则有效，且能保持灯亮状态。当然，这样的操作原语也意味着更多的开销。 信号灯的应用除了灯亮/灯灭这种二元灯以外，也可以采用大于1的灯数，以表示资源数大于1，这时可以称之为多元灯。 二、互斥量：（用于在线程间的通信） 1、在一个进程中创建 三、信号量与互斥量的区别 1. 互斥量用于线程的互斥，信号量用于线程的同步。 这是互斥量和信号量的根本区别，也就是互斥和同步之间的区别。 互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源 以上区别是主要想记住的。 note:信号量可以用来实现互斥量的功能 2. 互斥量值只能为0/1，信号量值可以为非负整数。 也就是说，一个互斥量只能用于一个资源的互斥访问，它不能实现多个资源的多线程互斥问题。信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量是，也可以完成一个资源的互斥访问。3、互斥量的加锁和解锁必须由同一线程分别对应使用，信号量可以由一个线程释放，另一个线程得到。 4、作用域 信号量: 进程间或线程间(linux仅线程间) 互斥锁: 线程间 5、上锁时 信号量: 只要信号量的value大于0，其他线程就可以sem_wait(p操作-1)成功，成功后信号量的value减一。若value值不大于0，则 多线程同步方法及比较 多线程同步方法： 1.临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数 据访问。. 2.互斥量:为协调一起对一个共享资源的单独访问而设计的。. 3.信号量:为控制一个具备有限数量用户资源而设计。. 4.事件:用来通知线程有一些事件已发生，从而启动后继任务的开始。 临界区（Critical Section）.. 确保在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。假如有多个线程试图同时访问临界区，那么在有一个线程进入后其他任何试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程能够继续抢占，并以此达到用原子方式操作共享资源的目的。 临界区包含两个操作原语： EnterCriticalSection（）进入临界区 LeaveCriticalSection（）离开临界区。 EnterCriticalSection（）语句执行后代码将进入临界区以后无论发生什么，必须确保和之匹配的LeaveCriticalSection（）都能够被执行到。否则临界区保护的共享资源将永远不会被释放。虽然临界区同步速度很快，但却只能用来同步本进程内的线程，而不可用来同步多个进程中的线程。 MFC为临界区提供有一个CCriticalSection类，使用该类进行线程同步处理是很简单的。只需在线程函数中用CCriticalSection类成员函数Lock（）和UnLock（）标定出被保护代码片段即可。Lock（）后代码用到的资源自动被视为临界区内的资源被保护。UnLock后别的线程才能访问这些资源。. ------------------------------------------------ 介绍：什么是线程，线程的优点是什么 线程在Unix系统下，通常被称为轻量级的进程，线程虽然不是进程，但却可以看作是Unix进程的表亲，同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈(call stack)，自己的寄存器环境（register context)，自己的线程本地存储(thread-local storage)。 一个进程可以有很多线程，每条线程并行执行不同的任务。 线程可以提高应用程序在多核环境下处理诸如文件I/O或者socket I/O等会产生堵塞的情况的表现性能。在Unix系统中，一个进程包含很多东西，包括可执行程序以及一大堆的诸如文件描述符地址空间等资源。在很多情况下，完成相关任务的不同代码间需要交换数据。如果采用多进程的方式，那么通信就需要在用户空间和内核空间进行频繁的切换，开销很大。但是如果使用多线程的方式，因为可以使用共享的全局变量，所以线程间的通信（数据交换）变得非常高效。 Hello World(线程创建、结束、等待） 创建线程 pthread_create 线程创建函数包含四个变量，分别为： 1. 一个线程变量名，被创建线程的标识 2. 线程的属性指针，缺省为NULL即可 3. 被创建线程的程序代码 4. 程序代码的参数 For example： - pthread_t thrd1? - pthread_attr_t attr? - void thread_function(void argument)? - char *some_argument? pthread_create(&thrd1, NULL, (void *)&thread_function, (void *) &some_argument); 结束线程 pthread_exit 线程结束调用实例：pthread_exit(void *retval); //retval用于存放线程结束的退出状态 线程等待 pthread_join pthread_create调用成功以后，新线程和老线程谁先执行，谁后执行用户是不知道的，这一块取决与操作系统对线程的调度，如果我们需要等待指定线程结束，需要使用pthread_join函数，这个函数实际上类似与多进程编程中的waitpid。 举个例子，以下假设 A 线程调用 pthread_join 试图去操作B线程，该函数将A线程阻塞，直到B线程退出，当B线程退出以后，A线程会收集B线程的返回码。 该函数包含两个参数：pthread_t th //th是要等待结束的线程的标识 void **thread_return //指针thread_return指向的位置存放的是终止线程的返回状态。 调用实例：pthread_join(thrd1, NULL); example1： 1 /************************************************************************* 2 > F i l e N a m e: t h r e a d_h e l l o_w o r l d.c 3 > A u t h o r: c o u l d t t(f y b y) 4 > M a i l: f u y u n b i y i@g m a i l.c o m 5 > C r e a t e d T i m e: 2013年12月14日 星期六 11时48分50秒 6 ************************************************************************/ 7 8 #i n c l u d e 11 12 v o i d p r i n t_m e s s a g e_f u n c t i o n (v o i d *p t r)? 13 14 i n t m a i n() 15 { 16 i n t t m p1, t m p2?4：一个经典的多线程同步问题汇总
进程同步机制与互斥-生产者消费者问题
用信号量实现线程同步与互斥
同步和互斥实验-吃水果问题、消费者问题
进程间的同步和互斥-
操作系统 实验 五 线程间的互斥与同步
操作系统实验-进程同步与互斥
四种进程或线程同步互斥的控制方法
进程同步与互斥汇总
计算机操作系统_进程间互斥与同步
进程(线程)的同步与互斥实验报告
同步与互斥
实验1编程实现进程(线程)同步和互斥
同步和互斥的区别_
多线程同步方法及比较
Step by Step：Linux C多线程编程入门(基本API及多线程的同步与互斥)
9 #i n c l u d e 10 #i n c l u d e