mutex

try_lock 函数如果被调用时没有获得锁则直接返回 false。try_lock_for 函数接受一个时间范围，表示在这一段时间范围之内线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。try_lock_until 函数则接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间其他线程释放了锁，则该线程可以获得对互斥量的锁，如果超时（即在指定时间内还是没有获得锁），则返回 false。 请采纳，谢谢。

当然不可以，目前没有问题不表示那就是对的，你查看他们的反汇编代码就知道他们的内容差别还是蛮大的

1.msdn search Mutex2.inno setup scripts[Setup]...AppMutex=......

从Backtrace来看，应该是i2c_transfer中调用mutex_lock导致schedule调用而产生进程调度，导致死机．而在中断上下文，这种情况是绝对不允许发生的．换句话说是不允许 睡眠的，不允许进程调度． 你可以把mutex_lock注释掉再试试．

pthread_mutex_t需要放在共享内存中, 并设置PTHREAD_PROCESS_SHARE。还不如用信号灯。

使用pthread_mutexattr_init(3C)可以将与互斥锁对象相关联的属性初始化为其缺省值。在执行过程中，线程系统会为每个属性对象分配存储空间。 int pthread_mutexattr_init(pthread_mutexattr_t *mattr);#include <pthread.h>pthread_mutexattr_t mattr;int ret;/* initialize an attribute to default value */ret = pthread_mutexattr_init(&mattr);调用此函数时，pshared 属性的缺省值为 PTHREAD_PROCESS_PRIVATE。 该值表示可以在进程内使用经过初始化的互斥锁。mattr 的类型为 opaque，其中包含一个由系统分配的属性对象。mattr 范围可能的值为 PTHREAD_PROCESS_PRIVATE 和 PTHREAD_PROCESS_SHARED。PTHREAD_PROCESS_PRIVATE 是缺省值。对于互斥锁属性对象，必须首先通过调用 pthread_mutexattr_destroy(3C) 将其销毁，才能重新初始化该对象。pthread_mutexattr_init() 调用会导致分配类型为 opaque 的对象。如果未销毁该对象，则会导致内存泄漏。pthread_mutexattr_init 返回值pthread_mutexattr_init() 成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下情况，该函数将失败并返回对应的值。ENOMEM 描述:内存不足，无法初始化互斥锁属性对象。

1、最近用到pthread_mutex_timedlock（）这个函数，给它设置了延时时间，但是经常返回22或者110。而且并没有真正的延时我所给的时间，而是直接返回，所以记录一下原因。查阅errno.h头文件可知，22错误码是代表无效参数（Invalid argument ），110错误码是代表超时（Connection timed out ）。2、先来看下pthread_mutex_timedlock（）函数的参数在系统头文件<pthread.h>里能看到定义：在<time.h>头文件里能看到struct timespec结构体的定义：这个结构体只有两个成员，秒和纳秒，也就是说pthread_mutex_timedlock函数可以做到纳秒级的延时等待。

一个线程可以重复占有mutex, 占有几次资源, 就要释放几次资源, 不然别的线程没法获得mutex main()线程在CreateMutex(TRUE)的时候已经占用资源, 在WaitForSingleObject( hMutex )再次占用, 他需要释放两次

此方法是保证读者优先的方法，如果不设信号量，那么在V之后无法保证先行读者阻塞队列。也可能直接唤醒写者阻塞队列。设互斥信号量的目的是保证读者有序先行。

在成功完成之后会返回零。其他任何返回值都表示出现了错误。如果出现以下任一情况，该函数将失败并返回对应的值。返回值种类，引用自说明文档：EINVAL　　The value specified by mutex does not refer to an initialized mutex object.　　EAGAIN　　The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded. 　　The pthread_mutex_lock() function may fail if: 　　EDEADLK　　The current thread already owns the mutex.

当另一个线程一直占着mutex的时候才会等待 #include <windows.h>#include <process.h>HANDLE mutex = NULL;unsigned int _stdcall threadfun( void* o ){ while( true ) { WaitForSingleObject(mutex,INFINITE); printf( "press key " ); getchar(); //当这里一直占着的时候，主线程就一直等，直到这里releasemutex ReleaseMutex( mutex ); } return 0;}int main( int argc, char** argv ){ mutex = CreateMutex(NULL,false,NULL); _beginthreadex( NULL, 0, threadfun, 0, 0, 0 ); while(true) { WaitForSingleObject(mutex, INFINITE); printf( "me " ); ReleaseMutex(mutex); } return 0;}

一个线程可以重复占有mutex, 占有几次资源, 就要释放几次资源, 不然别的线程没法获得mutexmain()线程在CreateMutex(TRUE)的时候已经占用资源, 在WaitForSingleObject( hMutex )再次占用, 他需要释放两次

好像是你的QQ飞车程序卖到的问题。那个VC++的提示是指你的C++运行库不存在了，导致Winlogo无法加载。可能是瑞星误杀导致的问题，最简单的方法：重装系统吧。

如果互斥锁类型为 PTHREAD_MUTEX_NORMAL，则不提供死锁检测。尝试重新锁定互斥锁会导致死锁。如果某个线程尝试解除锁定的互斥锁不是由该线程锁定或未锁定，则将产生不确定的行为。如果互斥锁类型为 PTHREAD_MUTEX_ERRORCHECK，则会提供错误检查。如果某个线程尝试重新锁定的互斥锁已经由该线程锁定，则将返回错误。如果某个线程尝试解除锁定的互斥锁不是由该线程锁定或者未锁定，则将返回错误。如果互斥锁类型为 PTHREAD_MUTEX_RECURSIVE，则该互斥锁会保留锁定计数这一概念。线程首次成功获取互斥锁时，锁定计数会设置为 1。线程每重新锁定该互斥锁一次，锁定计数就增加 1。线程每解除锁定该互斥锁一次，锁定计数就减小 1。 锁定计数达到 0 时，该互斥锁即可供其他线程获取。如果某个线程尝试解除锁定的互斥锁不是由该线程锁定或者未锁定，则将返回错误。如果互斥锁类型是 PTHREAD_MUTEX_DEFAULT，则尝试以递归方式锁定该互斥锁将产生不确定的行为。对于不是由调用线程锁定的互斥锁，如果尝试解除对它的锁定，则会产生不确定的行为。如果尝试解除锁定尚未锁定的互斥锁，则会产生不确定的行为。

循环等待其实是这样的：检查条件满不满足，不满足就解锁，然后等，等到了要检测的时候，又上锁，然后检查，不满足就解锁。也就是说，进了pthread_cond_wait函数以后，它就释放了lock，然后在has_product上等待，等到has_product被触发了，就再上锁，然后出函数。你的消费者线程调用了pthread_cond_wait以后，就释放了锁，然后这个函数不返回（这个函数不返回你的代码就不会运行下去），等到has_product触发了，这个函数就获取锁，然后返回。再解释一下，就是调用这个函数之前，你这个线程是拿到锁的；出了这个函数，你的线程也还是拿到锁的；但是进了这个函数还没出来的过程中，你的线程会释放锁。

mutex locked互斥锁拼音双语对照双语例句1No two threads can have the same mutex locked at the same time.两个线程不能同时对同一个互斥对象加锁。

mutex lock是建立在操作系统给的特殊指令上的一种软件解决方法。 实际上就是test_and_set 以及 compare_and_swap 等指令的高级调用。当然，这里的test and set 和 compare and swap不是具体实现在某个平台的指令，只是抽象的定义了两类的指令。 如果不熟悉test and set的话，那么test and set指令的定义是这样的 当然，这只是定义，整个命令是作为一个atomic的指令的。 利用test and set命令来实现互斥是这个样子的: lock 一开始被初始化为false，然后执行第一句while(tas(&lock)) 的时候 会发生两件事情，第一个就是这句话本身结果是false，这样就允许该线程接着往下执行进入临界区，第二个是这句话将lock赋值成true。 而当lock 取true值的时候，第二个线程如果执行第一句while(tas(&lock))的话，会无限循环busy waiting。就进不了临界区，直到第一个线程将lock 设置为false。 那个时候第一个线程也就已经离开临界区了，就达到了互斥的效果。 compare_and_swap的指令定义如下: 使用cas命令的互斥: cas命令的分析也不难。 以上两个是操作系统提供的硬件的解决方法。但很可惜的是，用户程序一般不用汇编开发。所以类似于pthread ，windows都会提供软件上的解决方法。 最直接的思路就是mutex lock：在进入临界区之前应当获得一个lock，其他没有lock的线程就进入不了临界区，离开临界区应该释放掉这个lock，以便其他线程获得lock。 lock 的两个动作 ---获得，释放的定义如下: 要注意的是，acquire和release都是atomic的。 看到acquire的定义的时候是不是感觉到了一股既视感？回想一下tas里，第一句while执行的时候的两个动作，我们将lock 从 false变成 true，我们 tas指令返回false，从而使得while空循环不执行。 在这里，available默认为true，从而使得while空循环不执行，然后我们将available从true变成了false。 把lock 看成 (!available)，我们知道tas固定设置lock = true ，也就是available = false; 这里用tas实现一下acquire : tas(&lock)返回false，进入临界区，同时lock = true 阻碍了其他进程进入临界区。 但是因为tas命令只能实现lock = true 也就是available = false，所以我们无法用它来实现release，这个时候就可以用cas命令 而release实现如下: 当lock = false 的时候，我们将他改变成true。 于是我们现在有了TSL和mutex lock了。

从　Backtrace　来看，应该是　i2c_transfer　中调用　mutex_lock　导致　schedule　调用而产生　进程调度，导致死机．　而在中断上下文，这种情况是绝对不允许发生的．换句话说是不允许睡眠的，不允许进程调度．　你可以　把　mutex_lock　注释掉再试试　．

从　Backtrace　来看，应该是　i2c_transfer　中调用　mutex_lock　导致　schedule　调用而产生　进程调度，导致死机．　而在中断上下文，这种情况是绝对不允许发生的．换句话说是不允许睡眠的，不允许进程调度．　你可以　把　mutex_lock　注释掉再试试　．

可能网上有很多说话。下面是我自己的看法。首先，缓冲池为空，就没有没有产品，;full=0,这里还要强调，mutex是全局互斥信号量。这个时候先来了个消费者，他的程序如下：wait(mutex);挂起了，并且占用了mutex，wait(full);……不管来多少消费者，都在mutex队列排队，死锁了。这个时候；生产者，的程序wait(empty);可行wait(mutex)：也挂起了， 因为mutex给消费者用了，就是说缓冲区给消费者占用了啦！生产者和消费者都等待了，系统死锁了。希望你能明白我说的。

没有一个进程进入临界区。互斥信号量，初始值为1，取值范围为（负1，0，1）。当信号量为1时，表示两个进程皆未进入需要互斥的临界区。当信号量为0时，表示有一个进程进入临界区运行，另一个必须等待。当信号量为负1时，表示有一个进程正在临界区运行，另一个进程因等待而阻塞在信号量队列中，需要当前已在临界区运行的进程退出时唤醒。

hai

可能网上有很多说话。下面是我自己的看法。首先，缓冲池为空，就没有没有产品，;full=0,这里还要强调，mutex是全局互斥信号量。这个时候先来了个消费者，他的程序如下：wait(mutex);挂起了，并且占用了mutex，wait(full);……不管来多少消费者，都在mutex队列排队，死锁了。这个时候；生产者，的程序wait(empty);可行wait(mutex)：也挂起了， 因为mutex给消费者用了，就是说缓冲区给消费者占用了啦！生产者和消费者都等待了，系统死锁了。希望你能明白我说的。

another instance of total war：shogun 2 is running please close this instance before attempting to run another instance 意思是：另一个幕府2全面战争的实例： 试图运行另一个实例之前，请关闭这个实例 出现了：Mutex error 的界面 原因是Mutex的错误 我个人来讲的话，是你电脑配置问题或你下载的游戏是坏的 幕府将军2配置的要求 处理器方面，建议采用四核处理器，主频保证在2.8GHz以上； 内存方面，建议保证3GB或者更高容量的内存； 显卡方面，建议GTX460或HD6850级别的产品。 所以楼主你的配置比起这个要求来是差了很远 官方配置： 最低配置： ·CPU：英特尔双核 2 GHz / 英特尔单核 2.6 GHz 或 等效AMD (支持 SSE2) ·内存：1GB (XP) / 2GB (Vista 或 Windows7) ·显卡：显存256 MB 支持DirectX 9.0c (SM3.0) ·硬盘：20 GB ·显示器：1024×768 分辨率 推荐配置： ·CPU：第二代英特尔酷睿 i5 / 等效AMD（i7比较好，有测试证明） ·内存：2GB (XP), 4GB (Vista 或 Windows7) ·显卡：AMD Radeon HD 5000 和 6000 或等效的支持DirectX 11的显卡 ·硬盘：20 GB ·显示器：1280×1024 分辨率 你自己看看吧不懂得你可以来Q我 QQ：1060669328

参考: c++ - Map of mutex c++11 - Stack Overflow std::mutex不好放进map的主要原因是: TL;DR: just use operator [] like std::map<std::string, std::mutex> map; map[filename]; Why do you need to use an std::unique_ptr in the first place? I had the same problem when I had to create an std::map of std::mutex objects. The issue is that std::mutex is neither copyable nor movable, so I needed to construct it "in place". I couldn"t just use emplace because it doesn"t work directly for default-constructed values. There is an option to use std::piecewise_construct like that: but it"s IMO complicated and less readable. My solution is much simpler - just use the operator[] - it will create the value using its default constructor and return a reference to it. Or it will just find and return a reference to the already existing item without creating a new one.

http://www.xfbbs.com/Book/jinghuawenzhai/VB_1/htmapi73.htm我也没有明白她写的是什么意思，但也许有用吧！

http://www.codeproject.com/KB/threads/ThreadingDotNet.aspx

那就不调用啊，你的A函数已经加锁了。干嘛好调用AAA再加一次锁。而且互斥锁只能加锁一次，你的A里面加完锁，进入到AAA里面就就会导致AAA函数永远没办法获取到锁，从而阻塞在那里。

mutex_lock是用来保护资源。比如某一个变量，多个函数都会对该变量进行操作，为了保证在同一时间，只能有同一个函数对该变量的操作，需要对该变量进行加锁和解锁操作，用来防止不可预知的错误。多线程，多进程中更应该如此。希望对你有帮助！

① 点击菜单上的新建； ② 设置一个名称，设置类型为 Linux，版本 Ubuntu(64 bit) 2 设置内存大小为2048 3 点击下一步 4 点击下一步 5 点击下一步 6 设置硬盘40G

enter mutex进入互斥leave mutex离开互斥

选D，需要释放资源

这和mutex没直接关系，你只是触发对已经删除的函数的调用了。比如mutex的operator=

问题出在CreateMutex()函数调用的参数上。把第二个参数改为true或者TRUE就行了。为什么会出现这个问题？第二个参数指定这个互斥量是否立即被这个进程使用，如果指定为true，则立即生效，否则无效的.呵呵，这个问题挺隐晦的(以后得小心了）！你的线程里不要直接使用在main()中定义的循环变量，这会出问题的，也就是临界区问题！你问的问题线程会自动释放互斥量吗？当然不会的，只有当进程退出后，未被释放的互斥量会被操作系统释放的。我提个小建议，阁下应该改改你的编码风格了，你目前使用的编码风格不大漂亮！呵呵下面是改过的源代码(加了一些注释，你可以看看）.. 有问题的话追问! #include <iostream>#include <Windows.h>#include <stdio.h>#include <stdlib.h>using namespace std; #define Thread_Num 3 //C++中尽量不要用宏,应该使用const int thread_num = 3; /*变量名对象名一般全小写，宏的名字一般用全部大写*/HANDLE hMutex;DWORD WINAPI ThreadFun(LPVOID); int main() { int id; HANDLE handle[Thread_Num]; hMutex=CreateMutex(NULL,TRUE,NULL); for(int i=0;i<Thread_Num;i++) { /*在线程中不要直接使用i*/ handle[i]=CreateThread(NULL,0,ThreadFun,(LPVOID)i,0,(LPDWORD)&id); if(handle[i]) { cout<<"线程"<<id<<"被创建"<<endl; } } WaitForMultipleObjects(Thread_Num,handle,TRUE,INFINITE); system("pause"); return EXIT_SUCCESS; //这一行可以不要的，编译器会自动加上去的}DWORD WINAPI ThreadFun(LPVOID lp) { WORD result= WaitForSingleObject(hMutex,INFINITE); cout<<(int)lp<<endl; WaitForSingleObject(hMutex,INFINITE); return 0;}

你这种方式是比较合理的方式，lpClassName 是要查的，而且也是固定的。如果你不用 lpClassName ，可以用程序的标题IntPtr hWnd = FindWindow(null, "标题"); ShowWindowAsync(hWnd, 1); SetForegroundWindow(hWnd);

从Backtrace来看，应该是i2c_transfer中调用mutex_lock导致schedule调用而产生进程调度，导致死机．而在中断上下文，这种情况是绝对不允许发生的．换句话说是不允许 睡眠的，不允许进程调度． 你可以把mutex_lock注释掉再试试．

1、将字符串数组定义为全局数组;2、线程A:pthread_mutex_lock(mutex);接收输入；写入数组；pthread_mutex_unlock(mutex);3、线程B：pthread_mutex_lock(mutex);显示数组内容；清空数组；pthread_mutex_unlock(mutex);

总线程锁定、数据监控 和 多用户终端执行程序

mutex 互斥(体) /mjuteks/

Linux mutex不能用在中断函数原因：Backtrace来看，应该是i2c_transfer中调用mutex_lock导致schedule调用。pthread_mutex_lock(&qlock);表示尝试去把qlock上锁，它会先判断qlock是否已经上锁，如果已经上锁这个线程就会停在这一步直到其他线程把锁解开。它才继续运行。所以代码中要么是线程1先执行完后执行线程2，要么就是线程2先执行，再执行线程1.而线程3一开始就执行了。中断函数防止方法：要防止中断冲突，其实就是要知道什么设备容易产生中断冲突，只要知道了这点，在使用这些设备时稍微注意一下就可以了。下面我列出一些容易冲突的设备，希望对读者有用。1、声卡：一些早期的ISA型声卡，系统很有可能不认，就需要用户手动设置（一般为5）。2、内置调制解调器和鼠标：一般鼠标用COM1，内置调制解调器使用COM2的中断（一般为3），这时要注意此时COM2上不应有其它设备。

一般mutex为1，0，-1，……，1表示程序可以进入临界区，可以执行p操作，但执行后要令1变为0

Mutex是一把钥匙，一个人拿了就可进入一个房间，出来的时候把钥匙交给队列的第一个，一般的用法是用于串行化对临界区代码的访问，保证这段代码不会被并行的运行。Semaphore是一件可以容纳N人的房间，如果人不满就可以进去，如果人满了，就要等待有人出来。对于N=1的情况，称为binary semaphore，一般的用法是，用于限制对于某一资源的同时访问。在有的系统中Binary semaphore与Mutex是没有差异的

1、首先，缓冲池为空，就没有产品。full=0,这里还要强调，mutex是全局互斥信号量。2、这个时候先来了个消费者，他的程序如下：wait(mutex);挂起了，并且占用了mutex，wait(full);不管来多少消费者，都在mutex队列排队，死锁了。3、这个时候生产者的程序wait(empty);可行wait(mutex)也挂起了， 因为mutex给消费者用了，就是说缓冲区给消费者占用了啦！生产者和消费者都等待了，系统死锁了。

信号量是一个被线程共享的非负变量。信号量是一个发信号的机制。一个等待一个信号量的线程可以被其他线程通知（signal）。这个机制通过 wait 和 signal 两个原子操作（atomic operations）来实现进程同步。 一个信号量要么允许访问资源，要么不允许访问资源。二者只能选其一。而具体是哪一种，则要看设置。 详情可参考《 信号量：二进位信号量和计数信号量 》这篇文章。 互斥锁其实是一个对象。Mutex的全称是Mutual Exclusion Object，也就是互斥锁是一个互斥对象。它是一种特殊的二进位信号量（binary semaphore），用来控制访问共享区域资源。它包括一个优先级继承机制，以避免扩展的优先级反转问题。它允许当前优先级较高的任务在阻塞状态下维持的时间尽可能的少。然而，优先级继承并不能完全避免优先级反转，而只会最小化其影响。 对于单个缓冲区（single buffer），我们可以将4kb缓冲区分成四个1kb缓冲区。信号量可以与这四个缓冲区相关联。这允许用户和生产者同时处理不同的缓冲区。 互斥锁用于提供互斥，它使得拥有钥匙（key or mutex）的生产者才能访问资源。只要生产者占用了缓冲区（buffer），用户必须等待，反之亦然。在互斥锁的机制中，整块缓冲区始终只能提供给一个线程访问。 下面列举信号量的优点： 下面列举互斥锁的优点： 下面列举信号量的缺点： 下面列举互斥锁的缺点：

mutex 互斥(体) /mjuteks/

mutex为互斥信号量，其初值为1,取值范围为(-1, 0, 1)。 当mutex=1时，表示两个进程皆未进入需要互斥的临界区;当mutex=0时，表示有一个进程进入临界区运行，另外-一个必须等待，挂入阻塞队列;当mutex=-1时，表示有一个进程正在临界区运行，另外一个进程因等待而阻塞在信号量队列中，需要被当前已在临界区运行的进程退出时唤醒。

可以认为是一种更加轻量级的latch, 两者的区别在于：mutex是内存结构本身所包含，随着内存的分配而分配、销毁而销毁，latch是一种独立的内存结构。基于这个特性，mutex保护的内存结构更细粒度，并发性、支持性要好于latch. 与shared latch一样可使mutex用cas模式申请latch. 因此也可以把mutex当成一种shared latch, 只是其粒度更细，更加轻量级。mutex采用spin+FIRO策略，而shared latch采用spin+FIFO策略。更多详细关于mutex的原理可以参见： 从10.2.0.2版本开始，oracle的mutex机制逐步替代了传统的library cache的一些机制。 #### 10.2.0.5 #### #### 11.2.0.4 #### 不同版本中，对于library cache的latch变化较大，特别是从Oracle 10gR2(10.2.0.2)开始，引入了mutex来替代cursor的latch. 在该版本上通过隐含参数_kks_use_mutex_pin的调整可以限制是否使用Mutex机制来实现Cursor Pin. mutex与latch的对应关系如下： 以下参数在11.2.0.2以上才有 由于mutex采用了传统的spin+sleep机制而不是latch的spin+post机制，所以sleep time的设置对于mutex性能具有重要地位，一般来说由于mutex的冲突远比latch要小，所以合适的yield和更小的sleep选择是恰当的。一般情况不需要改动，默认都是1ms. 不同模式的比较可以参考： 不包含sleep, 只在简单yield之后进行不断的mutex spin. 显然，在冲突不发生的情况下会有最好的性能，但是在有冲突的时候可能会消耗很高的CPU资源。 对10g模式的一种修正，增加了sleep部分以降低CPU消耗，sleep时间收到参数_first_spare_parameter的控制 在Solaris SPARC 10.2.0.4这个参数是_second_spare_parameter. mutex的spin次数受mutex_spin_count控制，默认为255. 该参数可以动态修改。 某些时候，该值可能需要适当增大来获取更好的性能。设置方法可参考latch的spin count设置方法。v$mutex_sleep_history视图包含相关的gets和sleep信息。 关于mutex_spin_conut设置对mutex响应性能的影响可参考：

楼主，你的程序也太乱了吧。Mutex的用法也很简单，在main函数里创建一个Mutex，在线程里进入一段代码前用WaitForSIngleObject，退出代码后用ReleaseMutex就行了。下面是从static int count=5开始的程序，前面的不用改。static int count=5;static HANDLE h1;static HANDLE h2;HANDLE g_hMutex;void func1();void func2();int _tmain(int argc, TCHAR* argv[], TCHAR* envp[]){int nRetCode = 0;DWORD dwThreadID1,dwThreadID2;g_hMutex = CreateMutex(NULL, FALSE, NULL);h1=CreateThread((LPSECURITY_ATTRIBUTES)NULL, 0, (LPTHREAD_START_ROUTINE)func1, (LPVOID)NULL, 0,&dwThreadID1);if(h1==NULL) printf("Thread1 create Fail! ");elseprintf("Thread1 create Success! ");h2=CreateThread((LPSECURITY_ATTRIBUTES)NULL, 0, (LPTHREAD_START_ROUTINE)func2, (LPVOID)NULL, 0,&dwThreadID2);if(h1==NULL) printf("Thread2 create Fail! ");elseprintf("Thread2 create Success! ");Sleep(1000);CloseHandle(h1);CloseHandle(h2);ExitThread(0);return nRetCode;}void func2(){int r2;WaitForSingleObject(g_hMutex, INFINITE);r2=count;_sleep(100);r2=r2+1;count=r2;printf("count in func2=%d ",count);ReleaseMutex(g_hMutex);}void func1(){int r1;WaitForSingleObject(g_hMutex, INFINITE);r1=count;_sleep(500);r1=r1+1;count=r1;printf("count in func1=%d ",count);ReleaseMutex(g_hMutex);}

尊敬的客户，您好：为了更有效解决您的问题，建议您通过“金蝶桌面服务系统”获取服务支持，在“金蝶桌面服务系统”中您可以选择多种方式解决您的问题，不仅可以通过“知识库”、“文档中心”等实现自助服务，还可以通过“服务预约”与我们的服务工程师取得联系，或者在“需求反馈”中及时将您对金蝶产品的任何建议反馈给金蝶公司，欢迎您体验！下载地址：http://kdweibo.com/GxA感谢您对金蝶公司的支持！

两者有不同的用途，atomic 常用于引用计数，mutex 常用于线程同步两者可以互相替代，如果你知道怎么做并且你想把事情弄复杂的话

如果线程终止而未释放 Mutex，则认为该 mutex 已放弃。这是严重的编程错误，因为该 mutex 正在保护的资源可能会处于不一致的状态。在 .NET Framework 2.0 版中，获取该 mutex 的下一个线程中将引发 AbandonedMutexException。这个问题是由于, 在一个子线程中,获取了mutex,但是在线程退出以前没有调用相应的ReleaseMutex方法,其他线程在等待这个mutex就会出现这个异常. 解决方法:在获取到mutex后, 一定要调用相应的ReleaseMutex方法