如何删除 win32 api 中的互斥锁和信号量？
在Win32 API中，要删除互斥锁和信号量，可以使用以下步骤：
- 打开互斥锁或信号量：使用
OpenMutex或OpenSemaphore函数打开要删除的互斥锁或信号量。这些函数将返回一个句柄，用于后续操作。 - 关闭互斥锁或信号量的句柄：使用
CloseHandle函数关闭互斥锁或信号量的句柄。这将释放资源并允许其他进程或线程访问该互斥锁或信号量。 - 删除互斥锁或信号量：使用
DeleteCriticalSection函数删除互斥锁，或使用CloseHandle函数删除信号量。这将从系统中完全删除互斥锁或信号量。
需要注意的是，删除互斥锁或信号量可能会影响其他正在使用它们的进程或线程。因此，在删除之前，确保没有其他进程或线程正在使用这些同步对象。
以下是一些相关的概念和推荐的腾讯云产品：
- 互斥锁（Mutex）：互斥锁是一种同步对象，用于控制对共享资源的访问。它确保在任何给定时间只有一个线程可以访问该资源。腾讯云提供的产品：云服务器 CVM。
- 信号量（Semaphore）：信号量是一种同步对象，用于控制对一组资源的访问。它可以限制同时访问资源的线程数。腾讯云提供的产品：弹性伸缩 AS。
请注意，以上推荐的腾讯云产品仅供参考，具体选择应根据实际需求进行评估和决策。
相关·内容
2回答
我目前正在使用win32应用程序接口用C语言编程。
我想知道如何永久删除或取消互斥和信号量。
我该怎么做呢，到目前为止，我还没有在MSDN上找到任何关于它的东西。
谢谢!
浏览 1提问于2012-01-31得票数 0
回答已采纳
2回答
在linux或linux库中，是否存在与win32中的关键部分相当的部分？
我知道Mutex，但它与关键部分不一样，因为关键部分在内部使用用户模式的自旋锁和事件对象，而且它必须比互斥快。
浏览 0提问于2012-01-16得票数 3
回答已采纳
1回答
我在我的应用程序中构建了一个终止开关，以便在一台计算机上一次只能运行一个实例。我通过在正在运行的应用程序的进程和应用程序的新实例的进程之间发布消息来实现这一点：
[DllImport("user32.dll", EntryPoint = "PostMessageA", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
private static extern int PostMessage(int hwnd, int wMsg, int wParam, int lParam)
浏览 6提问于2015-06-24得票数 5
1回答
POSIX二进制信号量
、、、
如何使用POSIX计数信号量API实现一个二进制信号量？我正在使用一个未命名的信号量，并且需要将其计数限制为1。我认为我不能使用互斥锁，因为我需要能够从另一个线程解锁。
浏览 0提问于2020-09-04得票数 1
3回答
用C/C++命名进程内部互斥锁？
、、、、
是否有使用C/C++ (在Unix/Linux中)实现命名进程内部互斥锁的方法？
诀窍是互斥锁的生存期需要是进程持久化的。例如，与命名的posix信号量和共享内存不同。
例如，您可以在动态映射中使用pthread互斥锁，并使用某个id来访问它们。但是，您需要以某种方式保护互斥体。
如果您使用内存映射文件或共享内存，您将获得文件系统持久性...
有什么想法吗？
浏览 0提问于2011-09-24得票数 0
POSIX的mutex等同于WIN32的CRITICAL_SECTION --它的作用域仅限于单个进程。Win32的互斥锁(在NT平台上实际上被称为“变种”)用作跨进程锁定机制。对于跨进程锁，pthread的等价物是什么？
浏览 0提问于2011-01-23得票数 5
回答已采纳
有没有，所以我可以在同一个mutex中有多达10个线程
类似于sem_wait()和value 10。
编辑：
发现这个：
它是信号量的实现，使用互斥变量和条件变量。
typedef struct {
int value, wakeups;
Mutex *mutex;
Cond *cond;
} Semaphore;
// SEMAPHORE
Semaphore *make_semaphore (int value)
{
Semaphore *semaphore = check_malloc (sizeof(Semaphore));
semaphore->valu
浏览 4提问于2013-01-03得票数 1
回答已采纳
2回答
同步线程，互斥
、、、、
我在努力做功课，但我被这些帖子卡住了。此函数在创建线程时调用：
size_t* mines, gold = 0, gold_collected = 0;
pthread_mutex_t mine_mutex;
int last_mine = 0;
void* dig(void *mine_start) {
int current_worker = (int)mine_start;
int mine = (int)mine_start;
// printf("Hello, it's me, thread %d\n", curr
浏览 0提问于2014-03-25得票数 2
2回答
我正在使用C++中的tbb编程。我不应该使用消息队列、FIFO、管道等，因为它们是特定于平台的。我应该使用tbb特定的API。
Thread1: // Pseuodo code exits as below
// I will take mutex
m_bIsNewSubsArrived = true;
StartSubscriptionTimer();
m_bIsFristSubsArrived = true;
// Spawn a thread here.
if(m_tbbTimerThread == NULL)
浏览 0提问于2013-07-22得票数 0
2回答
c++多线程同步
、、
这是我的问题的一个简化版本。
有N个线程在无限循环中执行以下3条指令：
A -> B -> C -> A -> B -> C -> A -> B -> .......
我希望所有线程同时执行指令B，也就是说，只有当所有线程都到达B时，任何线程才能开始执行B。所以，如果有一个线程已经执行了B -> C -> A，它应该在这里等待，直到其他线程也准备好执行B。
如果可能的话，请告诉我一个便携式的解决方案，可以在windows和MAC上运行。
浏览 1提问于2011-11-14得票数 7
1回答
OpenMutex与线程
、、、
我注意到，在p线程库中，没有类似于Win32下的Win32或信号量下的semget()这样的函数。
为什么？
这是否意味着我必须在任何情况下使用pthread_create()？
浏览 4提问于2014-08-07得票数 0
回答已采纳
3回答
有没有一些便携的方法来检查我的应用程序的并行实例的数量？
我有一个c++应用程序(win32)，我需要知道它每隔多久启动一次。问题是多个用户可以并行启动它(终端服务器)，因此我无法搜索“运行进程”列表，因为我无法访问其他用户的列表。
我试过使用Semaphore (boost & win32 CreateSemaphore)，它起作用了，但现在我遇到了问题，如果应用程序崩溃(断言或只是终止进程)，计数器不会改变。(重新启动会有所帮助)
此外，在我的代码中手动删除/重置信号量计数器也是不可能的，因为我不知道是否有人正在运行我的应用程序。
浏览 2提问于2011-09-29得票数 3
回答已采纳
2回答
我的多线程代码中有很多自旋锁，大多数时候它们都在等待其他线程工作，因此占用了大量的cpu资源。在linux中，我通常使用pthread_cond_wait和pthread_cond_signal来暂停线程，并在收到信号时唤醒线程。boost库中有这样的东西吗？我匆匆看了一眼，什么也没找到。
Visual studio 2005
浏览 1提问于2009-06-03得票数 3
回答已采纳
我正在考虑更改一些我想在linux、unix和OSX上运行的代码。代码中有一些对sem_init的调用，但pshared值被设置为零。我在Rochkind编程方面读了一些书，他基本上说，不共享的sem_init与pthread_mutex_init是一样的，因为它是以内存中的二进制方式运行的。
问题是-将这些sem_init更改为pthread_mutex_init，或者使用sem_open获得此代码的更可移植版本，这样做安全吗？
OSX不支持未命名信号量，但我猜其他两个支持。我也不希望对#ifdef(__APPLE__)或其他什么东西有单独的编译标志。
谢谢
浏览 6提问于2012-07-26得票数 4
3回答
这可能是一个基本的问题？
1)为什么要在同一线程上解锁互斥锁？我们有什么特别的原因吗? 2)如果我理解正确的话，为什么要保留pthraed_mutex_lock，而sem_wait/sem_post也可以做到？
浏览 1提问于2011-09-16得票数 0
1回答
信号量中的再入
、、
是否有一些类似的Semaphore或SemaphoreSlim实现允许重新进入？实现此功能的最佳方式是什么?使用Thread.CurrentThread.ManagedThreadId和ConcurrentDictionary还是使用具有[ThreadStatic]属性的字段是安全的？
浏览 1提问于2014-05-13得票数 0
3回答
“互斥”和“锁”有什么区别？
、、、、
我对锁和互斥之间的区别感到非常困惑。在助推文档里，它说，
锁类型
类模板lock_guardClass模板unique_lockClass模板shared_lockClass模板upgrade_lockClass模板upgrade_to_unique_lockMutex-specific类scoped_try_lock
互斥类型
mutexTypedef try_mutexClass timed_mutexClass recursive_mutexTypedef recursive_try_mutexClass recursive_timed_mutexClass shared_mutex类
浏览 2提问于2012-02-21得票数 27
回答已采纳
1回答
我的主要问题是线程锁对象会创建原子锁吗？它并没有说锁在模块文档中是原子的。在pythons的互斥锁文档中，它确实说互斥锁是原子的，但我似乎在某处读到了事实并非如此。我想知道是否有人能给我一些关于这个问题的见解。我应该使用哪个锁。我目前使用python 2.4运行我的脚本
浏览 0提问于2010-07-24得票数 8
回答已采纳
如果二进制信号量可以原子地保护资源，那么互斥的好处是什么。
例如,
sem_init(&sem, 0, 1);
sem_wait(&sem);
critical session;
sem_post(&sem);
请澄清互斥对信号量的任何好处。
浏览 0提问于2017-09-18得票数 0
1回答
我想知道二元信号量和互斥量之间的区别？这些是一样的吗？二进制信号量的值为1和0，具有互斥锁和解锁。
我真的对这些术语感到困惑。我指的是应用程序级编程透视图。在一次采访中，我被问及这个问题，并解释说信号量是用来发送信号的，互斥是用来锁定的。请用简单的例子来解释。我在googled上搜索了一下，但是知道除了上面的区别之外，信号量锁可以被其他线程解锁，而互斥锁必须由锁它的线程解锁。
浏览 3提问于2015-03-20得票数 2
网上有很多关于信号量和互斥量区别的文章/问题，但是在一个线程函数中同时使用互斥量和信号量是一个好方法吗？
类似这样的东西(在C中)
pthread_mutex_lock(&mutex);
//(Access to critical section)
sem_wait(&sem);
pthread_mutex_unlock(&mutex);
浏览 3提问于2014-11-26得票数 2
3回答
我已经阅读了Stackoverflow上关于这个主题的帖子，但不能理解大意。也许我们可以把它们的区别限制在一个特定的例子上。
有一个带锁的马桶。现在的主人出来了，把钥匙给了守卫(操作系统内核)，守卫把马桶的船主交给了另一个人。
问题陈述:我看到所有人都同意，共享资源必须由锁定它的线程中的同一互斥锁来解锁。但对于二进制信号量，它也可以在任何其他线程中解锁。
第一个人到达马桶，执行wait语句，信号量结构的值从1到0。现在，如果任何其他人(其他线程)来执行wait语句，它将阻塞，因为'value = 0‘。那么，为什么总是说任何其他线程可以解锁厕所/临界区，特别是当没有其他线程可以进入临界
浏览 0提问于2013-07-04得票数 3
8回答
我有多个用g++编译的应用程序，运行在Ubuntu中。我用命名的信号量来协调不同的进程。
所有程序都正常工作，除非在以下情况下:如果其中一个进程调用sem_wait()或sem_timedwait()来减少信号量，然后崩溃或被杀死-9在它有机会调用sem_post()之前，那么从那一刻起，命名的信号量是“不可用的”。
所谓“不可用”，我的意思是信号量计数现在为零，本应将其增加到1的进程已经死亡或死亡。
我找不到一个sem_*() API，它可能告诉我最后一次崩溃的进程是什么。
我是不是漏掉了一个API？
下面是我如何打开命名的信号量：
sem_t *sem = sem_open( "/
浏览 4提问于2010-01-13得票数 49
回答已采纳
我有几个进程需要通信，我希望同一时间只能让一个进程与另一个进程对话，例如，如果我有进程A、B、C、D，如果B想要向A发送消息，C不能发送消息，甚至不能向D发送消息。 我已经有了通信的必需品管道，并且我正在寻找WinAPI中的一个对象来实现排他性行为。 我还需要设置一个优先级，假设C正在向D发送一条消息，A和B都想要传输，当C完成时，我需要能够确保A总是最先发送。 我知道，这听起来像是会导致饥饿的情况，事实上它会的，但我试图模拟一个遭受饥饿(CANbus)的真实设置。 你知道我可以用哪种对象吗？
浏览 18提问于2019-04-02得票数 0
3回答
为什么Win32互斥体如此耗时？
、、、、
我一直在通过C/C++阅读Windows的书。在第8章第215页中，作者比较了各种同步机制的性能。我发现互斥的性能很差。当4个线程同时运行时，用于互斥同步的时间超过23秒。
为什么Win32互斥体如此耗时？我们什么时候能用互斥？
PS:我在GitHub：中发布了测试代码
谢谢你的回复。
浏览 0提问于2011-05-22得票数 2
回答已采纳
我正在使用scoped_lock和mutex实现一个版本的，但是在boost中有多个不同的预编译头文件。
scoped_lock可以通过"boost/interprocessor/sync/scoped_lock.hpp“和"boost/thread/mutex.hpp”获得
mutex可以通过"boost/thread/mutex.hpp“、"boost/signals2/mutex.hpp”和"boost/thread/win32/mutex.hpp“获得。
我可以猜到"win32/mutex.hpp“在某种程度上针对windows进行了优化
浏览 3提问于2011-10-26得票数 1
回答已采纳
1回答
程序如何尝试同时锁定多个互斥锁，并知道最终解锁的是哪一个互斥锁？本质上，我正在寻找的是一个select()的等价物，但用于互斥锁。这样的事情真的存在吗？如果没有，有没有实现它的库？
浏览 0提问于2013-03-24得票数 3
在我读过的所有关于多线程的参考资料中，互斥比信号量更常被使用和讨论。我的问题是，什么时候使用信号量而不是互斥量？我在Boost线程中没有看到信号量。这是不是意味着信号量现在不再使用太多？
据我所知，信号量允许多个线程共享一个资源。只有当这些线程只读取资源而不是写入时，这才是可能的。这是正确的吗？
浏览 0提问于2010-02-28得票数 38
回答已采纳
利用这种信号量算法解决了生产者-消费者问题，其中信号量被缓冲器大小减小，信号量减少1，表示临界截面。
如果这些操作是连续地进行的，那么为什么不正确的做法是减少1(互斥)，然后减少缓冲区大小？
我知道生产者和消费者都会同时睡觉，造成死锁，但是为什么这个小的切换会导致整个算法失败呢？
BufferSize = 3;
semaphore mutex = 1; // Controls access to critical section
semaphore empty = BufferSize; // counts number of empty buffer sl
浏览 2提问于2014-11-04得票数 3
回答已采纳
4回答
Sempahores和互斥锁
、、、、
这两种场景的区别是什么？我不知道该用哪一个。看起来他们基本上做了同样的事情。
pthread_lock(&mutex)
critical section
pthread_unlock(&mutex)
vs
sem_wait(&mutex)
section
sem_post(&mutex)
浏览 4提问于2014-04-20得票数 2
这个话题并不像看上去那么简单。如我们所知，mutex可以由带有初始count=1的信号量来实现。
但是通过几篇文章，我也发现将这两者分离开来，并将mutex作为一个与semaphore不同的独立概念进行了巨大的努力。
的问题给我带来了一个新的概念，让我感到有些困惑。
还有一些人谈到了ownership (如中所示)互斥。好吧，ownership是个不好的词。Mutex绝不是共享资源的所有者。Holding a Lock和Releasing a Lock实际上是一种发送信号的方式，比如*Hey wait !! Till I complete and signal you*。
寻找导致Mutex与
浏览 5提问于2014-01-06得票数 4
回答已采纳
1回答
如果我在中断上下文中使用信号量和互斥锁，会发生什么？通常在同步机制中使用信号量。如果我在中断上下文中使用它，会发生什么？
我正在做一个关于gpio引脚的项目，当中断发生时，我必须在ISR中发送一个信号。我用的是自旋锁。
如果我在ISR中使用信号量和mutext，会发生什么？
浏览 5提问于2015-08-14得票数 0
2回答
我知道二进制信号量是什么:当中断的ISR设置为1时，它是一个标志。
但是当我们使用先发制人的内核时，什么是信号量，FreeRTOS说？它和二进制信号量一样吗？
浏览 6提问于2015-03-27得票数 2
回答已采纳
在“Linux设备驱动程序第三版”一书中，互斥通过init_MUTEX(sem)通过信号量实现。然而，较新的内核，如内核3.2.X，已经删除了这个函数，并添加了互斥对象的支持。
但当我遇到密码时：
if (down_interruptible(&sem))
return -ERESTARTSYS;
我不能确定这个互斥方法是否有对应的。换句话说，我如何才能中断对特定互斥对象的等待？
浏览 5提问于2015-01-15得票数 1
回答已采纳
每个Java对象(及其类)都有一个关联的监视器。在pthread术语中，Java监视器等同于可重入互斥锁和条件变量的组合。
对于锁定，Win32 API提供互斥对象(可重入但重量级)和临界区(不可重入但轻量级)。它还提供了其他同步构造，如信号量和事件，但没有明确的条件变量概念。
如果我正在编写一个JVM，我如何使用这些Win32概念来实现Java监视器呢？
浏览 0提问于2008-10-06得票数 0
1回答
我有一个批量导入的要求。文件可以包含数千条记录，并且每条记录都需要验证。用户希望收到有多少条记录无效的通知。最初，我使用Ruby的Mutex和Redis的发布/订阅实现了这一点。请注意，我有20个并发线程通过Sidekiq处理每个记录：
class Record < ActiveRecord::Base
class << self
# invalidated_records is SHARED memory for the Sidekiq worker threads
attr_accessor :invalidated_records
attr_
浏览 1提问于2018-04-14得票数 0
1回答
如果信号量上有进程调用信号，会发生什么情况。
假设信号量计数为3。进程P1、P2、P3在信号量上调用wait并进入临界区。P4、P5、P6也称为等待，但由于信号量计数已经为0，它们将在信号量的等待队列中等待。现在信号来了并调用了P7 ()，等待信号量的进程(P4、P5或P6)会被唤醒吗？如果它被唤醒了，那么它就是一个错误，因为信号量计数是2，而p1，p2和p3没有离开临界区。
浏览 4提问于2019-01-11得票数 0
3回答
我一直在尝试理解可重入锁和信号量(可重入锁的嵌套与释放/解锁机制)。
似乎拥有一个信号量需要您编写一个经过更彻底测试的应用程序，因为release()方法不会检查释放许可证的线程是否真的持有它。当我测试我的测试代码时，我发现这可能会随后增加超过初始限制的许可数量。另一方面，如果一个线程在调用解锁方法时没有持有可重入锁，我们就会得到一个IllegalMonitorException。
因此，可以说没有真正的理由使用二进制信号量，因为二进制信号量可以做的所有事情都可以由ReentrantLock完成。如果我们使用二进制信号量，我们将不得不检查整个方法调用堆栈，看看之前是否获得了许可(如果有后续获取
浏览 3提问于2013-07-17得票数 35
回答已采纳
1回答
我们在詹金斯有很多工作，他们都在努力工作，有时是同时做的。不出所料的是，如果两份工作试图在相同的时间推进，一份会成功，另一份会失败。我的膝跳反应是建立某种指数退避，并重新尝试这些git推动，但我对git相当陌生。像这样的东西已经存在了吗？
我们的提交/推代码通常如下所示：
git config --global user.name "username"
git config --global user.email email@example.com
git add --ignore-errors -- dir/
git commit -m "some message&#
浏览 0提问于2020-02-12得票数 1
回答已采纳
2回答
我的项目需要一个完全递归的多读/单写锁(共享互斥)-我不同意这样的观点，如果你有完全的常量正确性，你就不应该需要它们(在boost邮件列表上有一些关于这一点的讨论)，在我的例子中，锁应该保护一个完全透明的缓存，它在任何情况下都是可变的。
至于递归MRSW锁的语义，我认为唯一有意义的是，除了共享锁之外，获取排它锁还会暂时释放共享锁，当排它锁释放时，会重新获取它。
有一个有点奇怪的效果，解锁可以等待，但我可以接受这一点--写入很少发生，递归锁定通常只通过递归代码路径发生，在这种情况下，调用者必须准备好调用在任何情况下都可能等待。要避免这种情况，仍然可以简单地升级锁，而不是使用递归锁定。
在独占锁之
浏览 2提问于2009-08-31得票数 6
2回答
我有两个进程: ProcessA和ProcessB。
当我启动应用程序时，我调用ProcessA，它使用CreateProcess()启动ProcessB。当我的应用程序收到命令A时，ProcessA被ProcessB杀死。同样，ProcessB 在收到命令B时应该重新启动ProcessA。
我被困在重新启动ProcessA的过程中。因为ProcessA有重新启动ProcessB的代码，所以我无法阻止它重新启动另一个ProcessB实例。理想情况下，我希望只有一个ProcessB实例。
为了从ProcessB中创建ProcessA，我有以下代码：
for(int i32Index = 0; i
浏览 3提问于2015-06-16得票数 3
回答已采纳
5回答
我读到信号量和互斥之间的区别之一是，在互斥的情况下，进程/线程(曾经拥有锁)只能释放锁。但是在信号量的情况下，任何其他进程都可以释放信号量。当一个没有信号量的进程可以释放信号量时，我的怀疑就出现了。有一个信号量有什么用？
假设我有两个进程A和B。假设进程A有一个信号量，正在执行一些关键任务。现在让我们假设进程B发送一个信号来释放信号量。在这种情况下，进程A是否会释放信号量，即使它正在执行一些关键任务？
浏览 1提问于2015-10-15得票数 0
我正在学习Java中的并发，并开始了解信号量，它可以用于同步，而不需要忙于等待。
现在，我想知道Java同步方法/语句和锁(例如重入锁)是不是忙于等待机制？
如果没有，如何通知其他线程，它们是否在幕后实现信号量？
synchronised method()
synchronised(object){}
reeantrant.lock()
浏览 5提问于2021-10-07得票数 0
2回答
任何实时场景的解释都将不胜感激。除了这些线程之外，还有其他方法来处理同步吗？互斥与递归互斥(任何实时场景)有何不同？
浏览 1提问于2013-08-03得票数 9
2回答
根据，我想用信号量来模拟P/C问题。我遇到了死锁，我不知道是什么问题。
public static void main(String[] args) {
CustomBlockingQueue blockingQueue = new CustomBlockingQueue();
new Thread(new Producer(blockingQueue)).start();
new Thread(new Consumer(blockingQueue)).start();
}
}
@SuppressWarnings("serial
浏览 1提问于2012-04-05得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
云直播
对象存储活动推荐
腾讯云开发者
