线程和互斥的用法有什么问题
线程和互斥是并发编程中常用的同步机制，用于控制多个线程对共享资源的访问。然而，使用线程和互斥也会遇到一些问题，包括：
- 死锁：当多个线程相互等待对方释放资源时，可能会导致死锁。这种情况下，线程无法继续执行，程序可能会卡住。为避免死锁，需要合理设计锁的获取顺序，并避免持有多个锁的情况。
- 竞态条件：当多个线程同时访问共享资源，并且对资源的访问顺序会影响最终结果时，可能会出现竞态条件。这种情况下，最终结果可能是不确定的。为避免竞态条件，可以使用互斥锁来保护共享资源的访问，确保同一时间只有一个线程可以修改资源。
- 性能问题：使用互斥锁会引入额外的开销，包括锁的获取和释放操作，以及线程切换的开销。如果使用不当，可能会导致性能下降。为避免性能问题，可以使用细粒度的锁，减小锁的粒度，或者使用无锁数据结构等替代方案。
- 死锁检测和避免：在复杂的并发程序中，死锁的发生可能比较隐晦，难以排查。为了解决这个问题，可以使用死锁检测工具来检测死锁的发生，并采取相应的措施进行避免或解决。
总之，线程和互斥是并发编程中常用的同步机制，但在使用时需要注意上述问题，并采取相应的措施进行避免或解决。在腾讯云的云计算服务中，可以使用云服务器（CVM）提供的多线程编程环境来进行并发编程，并结合云数据库（CDB）等服务来实现数据的安全访问和共享。
相关·内容
一般来说，pthread_cond_wait()和pthread_cond_signal()的名称如下：
//thread 1:
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
do_something()
pthread_mutex_unlock(&mutex);
//thread 2:
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
浏览 3提问于2013-05-13得票数 74
回答已采纳
3回答
我是初学者，所以如果问题不清楚，请告诉我。
我使用两个线程，例如A和B，并且我有一个全局变量'p‘。线程A在循环和递增'p‘值的同时，B试图用其他值设置’p‘(两者都是两个不同的线程函数)。
如果我使用互斥进行同步，而线程A获得互斥并在while循环中增加'p‘，但它不会释放互斥。所以我的问题是，如果线程A不释放互斥体，那么线程B可以访问变量‘p’吗？？
编辑线程B也受到保护，使用互斥对象访问'p‘。
如果线程A使用pthread_mutex_lock()锁定而不释放它，那么如果同一个线程(A)再次尝试访问锁(请记住线程A正在循环)，会发生什么？
whil
浏览 5提问于2015-06-19得票数 0
回答已采纳
1回答
检查互斥锁释放
、、、、
我有一个用C++编写的多线程应用程序。我正在使用互斥来写文件。我怀疑在程序执行期间的某个地方，互斥锁没有被释放。
所以我想知道是否有一种方法可以通过编程或其他方式检查文件上的互斥锁和释放。
顺便说一句，我正在SuseLinux上运行代码。
谢谢,
浏览 3提问于2009-12-11得票数 1
回答已采纳
我正在Windows上用C语言编写一个(非常小的)very服务器。我需要读写文件的独占锁文件，我已经阅读了msdn文档关于锁定等，我已经找到了具有OVERLAPPED结构和Event hEvent的函数LockFileEx，我也读到了它们是如何工作的，但问题是：-在web服务器中，我们有很多文件，当一个线程锁定文件时，例如“test.txt”(独占锁)，因为对于这个文件的请求，我如何同步另一个想要在同一文件上获得锁的线程？
谢谢。
浏览 4提问于2013-03-22得票数 0
1回答
不阻塞当前(UI)线程的互斥锁
、、、、
我有一个小任务-我必须创建互斥，使用任务和异步等待，而不是阻塞当前线程(UI线程)。
互斥接口：
Lock() -返回一个任务，只有在互斥变为空闲时才能完成。此任务必须是每个锁的唯一任务，以便不允许每次释放()调用超过一个取消块。释放()-释放互斥。一个也是唯一一个由Lock()返回的任务必须完成。那个互斥必须以这样的方式工作
await mutex.Lock();
// critical code
mutex.Release();
我编写了一些代码(最后参见链接)，但如果简单地描述一下问题的话:我创建了一个类Mutex。在Lock方法中，我做了这样的事情：
await Task.Fact
浏览 4提问于2014-12-07得票数 0
回答已采纳
2回答
唤醒线程开启信号
、、
我有一个正在绘制实时动画到gtkmm窗口的编程。我有我的主线程gui线程和一个使用cairo将动画的一帧渲染到图像表面的worker threa。主线程每隔33mS发一次信号通知工作线程。现在，我让我的应用程序在每次必须渲染帧的超时时创建一个新的渲染线程。我如何着手创建一种线程池，其中gui线程中的超时通知我的工作线程唤醒并呈现一个帧，该帧向gui线程发送该帧已完成的信号，然后返回睡眠并等待再次被通知。
浏览 0提问于2010-06-17得票数 0
2回答
我目前正在研究互斥锁是如何工作的。我想我有点掌握它了。图片下面的假设是正确的吗？这里我们有两个进程，Pi和Pj，它们想要执行它们的临界区，我试图解释互斥锁是如何工作的，以防止竞争条件的发生。
Pi尝试使用acquire()获取锁。在开始时，没有任何进程正在执行其临界区，因此可用将是真的。在acquire的while循环中，条件将为false，并且不会“忙等待”，available将被设置为false。将available设置为false的原因是为了防止其他进程进入其临界区。另一方面，Pj将不被允许执行其临界区，因为可用被Pi设置为false。!available将为true，因此Pj
浏览 2提问于2017-10-16得票数 1
3回答
为什么这段代码会导致死锁？
、、、、
我惊讶地从pstack中看到这段代码会导致死锁！我不认为有同样的理由。
pthread_mutex_t lock;
_Cilk_for (int i = 0; i < N; ++i) {
int ai = A[i];
if (ai < pivot) {
pthread_mutex_lock(&lock);
A[ia++] = ai;
pthread_mutex_unlock(&lock);
}
else if (ai > pivot) {
pthread_mutex_lock(&lock);
A
浏览 5提问于2012-09-03得票数 3
回答已采纳
1回答
我读到互斥锁和二进制信号量只在一个方面不同，在互斥锁的情况下，锁定线程必须解锁，但在信号量中，锁定和解锁线程可以不同？
哪一个更有效率？
浏览 2提问于2011-02-10得票数 4
回答已采纳
我编写了以下最小示例：
#include <iostream>
#include <cstring>
#include <pthread.h>
#define SUCCESS 0
using namespace std;
int main() {
int res;
pthread_mutex_t t;
pthread_mutex_init(&t, NULL);
res = pthread_mutex_lock(&t);
res = pthread_mutex_destroy(&t);
浏览 6提问于2014-04-16得票数 4
回答已采纳
@staticmethod
def instance():
"""Returns a global `IOLoop` instance.
Most applications have a single, global `IOLoop` running on the
main thread. Use this method to get this instance from
another thread. In most other cases, it is better to use `current()`
to get t
浏览 1提问于2018-01-19得票数 0
2回答
线程同步问题
、、
我使用Qt和C++。我有一个线程列表(Qlist<QtThread>)。
我试着同步它们。所有线程都会计算一些值。我想把它们拿去。
你有什么想法吗？非常感谢
浏览 0提问于2011-06-02得票数 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回答
Poco线程同步问题
、、、、
下面是用于理解互斥线程和线程同步的示例Poco线程程序。仍然看到相同程序的不同输出。
#include "Poco/ThreadPool.h"
#include "Poco/Thread.h"
#include "Poco/Runnable.h"
#include "Poco/Mutex.h"
#include <iostream>
#include <unistd.h>
using namespace std;
class HelloRunnable: public Poco::Runnable
{
浏览 2提问于2016-07-12得票数 0
回答已采纳
如果互斥锁可以被线程递归锁定，我就不理解互斥锁的用法。为什么有人要递归地锁定互斥锁呢？在什么情况下，他们会使用这个？
浏览 1提问于2010-08-22得票数 1
互斥看起来和锁并没有太大的区别：
using System.Threading;
class WithMonitor {
object baton = new object();
void Method() {
Monitor.Enter(baton);
// Work...
Monitor.Exit(baton);
}
}
class WithMutex {
Mutex mutex = new Mutex();
void Method() {
mutex.WaitOne();
// Work...
mutex.Relea
浏览 2提问于2015-03-04得票数 1
1回答
如何将工作动态分配给线程
、、、
我试图编写代码，以找出配对和是否为偶数(从0到100000的所有可能对中)。我编写的代码使用的是静态完成工作分配的线程。这是代码
#include<iostream>
#include<chrono>
#include<iomanip>
#include<pthread.h>
using namespace std;
#define MAX_THREAD 4
vector<long long> cnt(MAX_THREAD,0);
long long n = 100000;
int work_per_thread;
void
浏览 7提问于2022-08-08得票数 0
回答已采纳
为什么线程有自己的堆栈？为什么线程不能和所有其他资源一起共享进程的堆栈？最重要的是，如果线程必须使用进程的堆栈，会出现什么问题？
浏览 0提问于2017-11-06得票数 0
两个线程访问一个共享的int，x。指令重新排序等会产生什么问题。 线程1： x = 1; 线程2： obj.f(x); 如果x声明为volatile，会发生什么变化？ 如果线程1和线程2运行在不同的内核上，会有什么变化？
浏览 5提问于2010-04-18得票数 1
我编写了一个TensorFlow Op，它包装了一个用C编写的库，该库在内部调用malloc()来分配缓冲区和保持状态。我在构造函数中初始化库，这是发生malloc()调用的地方，然后在Compute()中，我将其与互斥锁保护一起使用。析构函数对free()进行适当的调用。
在我的模型中，每个线程都在同一个图中创建Op的副本，并在共享会话中运行它。代码经常会因为与指针相关的问题而崩溃，例如“释放对象的校验和不正确-对象可能在释放后被修改”。我为Op编写的单元测试只有一个线程，运行良好。
我怀疑图形优化器可能会重用Op的单个实例，或者类似的东西。有没有办法告诉它Op是有状态的，应该保持原样？崩溃
浏览 0提问于2017-03-03得票数 0
2回答
我有一个简单的问题:我需要创建三个线程，并且在每个线程中执行一个特定的操作。第一个线程需要将100添加到array[0]并从array[1]中减去101，第二个线程需要将200添加到array[1]并从array[2]中减去201，最后第三个线程需要将300添加到array[2]，并从array[0]中减去301。
下面是正确的解决方案，但运行时间非常巨大。如果我使用一个线程执行这个任务，运行时间将小于1秒，但是三个线程将使运行时间增加到大约10秒(+-2秒)。有什么问题吗？我认为有三个线程的解决方案必须更快。可能是我用错了互斥物？
#include <stdio.h>
#incl
浏览 3提问于2017-05-22得票数 1
回答已采纳
1回答
有一个小问题与线程，请告诉我如何解决它或至少在哪个方向寻找，寻找了很长时间，但到目前为止还没有成功…问题是:有3个线程，它们可以以任何顺序运行(321;213;123...)。无论我们运行的是哪种顺序，它们都需要按照1,2,3的顺序运行。为此，请使用线程同步和一个互斥锁。在此之前谢谢。
浏览 0提问于2012-05-17得票数 1
在我的代码中，如果线程在调用.WaitOne()之前多次调用.ReleaseMutex()，将非常方便。
反之亦然:在重新启动以调用.WaitOne()开头的循环之前，调用.WaitOne()几次。
一些操作系统/编译器组合允许这样做。有些人不知道。
浏览 1提问于2018-05-15得票数 0
回答已采纳
pthread_cond_wait()调用的解锁和等待是如何原子化的？
是否有一个窗口，其中互斥锁已经解锁，但线程还没有在该部分，它实际上正在等待和能够接收通知？
IOW，在pthread_cond_wait()函数本身中是否存在丢失唤醒的可能性？
浏览 7提问于2018-01-06得票数 3
回答已采纳
3回答
这可能是一个基本的问题？
1)为什么要在同一线程上解锁互斥锁？我们有什么特别的原因吗? 2)如果我理解正确的话，为什么要保留pthraed_mutex_lock，而sem_wait/sem_post也可以做到？
浏览 1提问于2011-09-16得票数 0
2回答
我想监控线程。我使用了发送和接收HeartBeat和确认信号的条件变量。
scnMonitor_t是一种监视器结构。当添加新的线程时，它向监视器注册并添加到scnThreadlist_t。monitorHeartbeatCheck是以程序开头的线程，monitorHeartbeatProcess是添加到所有线程函数的API。
实际上，我的问题是没有正确地遵循进程的索引，它以等待第三个线程的HB条件结束&创建了死锁。应该是什么问题呢？
提前谢谢。
typedef struct scnThreadList_{
osiThread_t thread;
浏览 0提问于2011-12-07得票数 1
2回答
C++多线程应用程序崩溃
、、、、
我正在编程一个简单的3D渲染引擎，只是为了让更多的人熟悉C++。今天，我有了多线程的第一步，并且已经有了一个问题，我不能把头绕过去。当应用程序启动时，它会生成一个小的、类似于我的地形，由立方体组成。它们是在主线程中生成的。
现在，当我想要生成更多的块时，，
void VoxelWorld::generateChunk(glm::vec2 chunkPosition) {
Chunk* generatedChunk = m_worldGenerator->generateChunk(chunkPosition);
generatedChunk->shader = m_
浏览 2提问于2017-04-15得票数 0
3回答
情况：I有一个用C编写的多线程程序。如果其中一个线程分叉，则使用exec()替换子进程，其父进程等待子进程退出。
问题:在由fork()创建子进程之后，有几行代码可以编译在下面的exec()命令中使用的参数。
假设是正确的，我假设在由fork()创建的子进程与由exec()替换的子进程之间的时间内，子进程--作为父进程的副本--将拥有父进程的所有线程，因此这些线程将运行--尽管时间很短？
如果是这样的话，那么在fork()之后立即调用exec()是否是正确的解决方案？
浏览 2提问于2010-11-19得票数 11
回答已采纳
我之前用的是pthread_mutex_t的。代码有时会卡住。我有几行代码分散在我包装的函数中……
pthread_mutex_lock(&map_mutex);// Line 1
//critical code involving reading/writing wrapped around a mutex //Line 2
pthread_mutex_unlock(&map_mutex); //Line 3
不确定代码是如何/在哪里卡住的，我将pthread_mutex_t切换到了boost:mutex
1)如果我只是在第1行中用boost::lock_guard<
浏览 1提问于2012-08-21得票数 3
回答已采纳
2回答
我有两套--输入和输出--70个32位整数变量和70个bools (总共140瓦)。这些需要从3个线程中访问和修改。什么是合适的设计模式，以方便线程安全地对这140个变量进行读写访问，而不将所有变量都锁在单个互斥对象下(我预计这会导致性能不佳)？
关于性能要求的一些详细信息：
线程1 ("CAN串行通信“)每1ms接收来自硬件传感器的数据包，其中包含70个输入共享变量之一的更新值；线程用该值更新变量。另外，每5ms线程1需要复制所有70个输出变量。
线程2 ("Controller")每10 as创建一次所有输入变量的副本，并覆盖所有输出变量。
线程3 ("GU
浏览 0提问于2016-05-20得票数 4
回答已采纳
我对线程有些陌生，我正试图了解它在C++11中的工作原理。
#include <list>
#include <mutex>
#include <algorithm>
std::list<int> some_list; // A data structure accessed by multiple threads
std::mutex some_mutex; // This lock will prevent concurrent access to the shared data structure
void
add_to_list(
浏览 5提问于2013-02-02得票数 10
1回答
转门对互助器
、、、、
这个问题与一种叫做Turnstile的同步机制有关。实现和文档的示例可以找到、和。在做了一些研究之后，我仍然找不到以下问题的答案。
转门解决了什么问题？
相对于互斥，回转栅极有什么优势？
线程和转门之间的所有权关系是什么？(如有的话)。
如果我们降低了这些实现的复杂性，那么转门的最基本的最小结构是什么？
浏览 1提问于2018-11-30得票数 2
4回答
存在一个关于互斥锁和临界区之间的区别的问题，但它也不处理锁。
所以我想知道临界区是否可以用于进程之间的线程同步。
还有什么是有信号状态和无信号状态
浏览 0提问于2010-05-11得票数 12
回答已采纳
我有这个lock() unlock()互斥锁实现：
void lock (boolean *m) {
while (*m == true) {}
*m = true;
}
void unlock (boolean *m) {
*m = false;
}
问题是，这种方法有什么问题。除了明显的性能影响之外。
提前准备了很多坦克！
浏览 5提问于2019-07-09得票数 0
回答已采纳
1回答
我有一个使用Oracle Pro C预编译器的多线程(基于POSIX线程或pthread )C应用程序。应用程序使用全局sqlca结构。在一个.c文件中，它包含用于Oracle数据库访问全局sqlca结构定义，如下所示：
#include <sqlca.h>
在所有其他c文件中，它的用法如下：
#define SQLCA_STORAGE_CLASS extern
#include <sqlca.h>
我的问题是，如果多个线程试图访问数据库表以进行查询、插入或更新，并使用全局sqlca对象，我如何保证互斥或使其成为线程安全访问？另外，当我查询和插入/更新
浏览 0提问于2015-09-21得票数 6
1回答
由不同的并发运行的posix线程提供和读取动态增长的结构数组是否可取，甚至是可能的？我必须在哪里为这类应用程序寻找最佳实践--有没有什么是“共同的智慧”？我是这个领域的新手，需要一些初始的指示，从哪里开始，寻找什么。这里似乎有很多可能性，我不想落入初学者的陷阱。
浏览 2提问于2009-11-02得票数 2
3回答
线程导致意外崩溃
、、
我不知道这里有什么问题，但当我在OS上运行我的代码时，它工作得很好，但在Linux上我的程序将无法运行。
下面是我的代码：
Thread() {
- some other code -
randLane1 = rand() % 16;
randLane2 = rand() % 16;
while(randLane1 == randLane2) {
randLane2 = rand() % 16;
}
浏览 0提问于2015-11-10得票数 0
3回答
在C#中，如果我有一个列表，例如，我可以做
lock (this.mylist)
{
...
}
有了这些代码，我确信在释放锁之前，其他人都不能使用这个列表。这在多线程应用程序中很有用。我怎样才能在Qt上做同样的事情？我读过关于QMutex和QReadWriteLock的文档，但我不明白如何在特定的对象上使用它们。
浏览 0提问于2012-04-26得票数 4
回答已采纳
我的PTHREAD_MUTEX_RECURSIVE有以下问题:当互斥锁从另一个线程锁定时，它会阻塞；
pthread_mutex_t m;
pthread_mutexattr_t ma;
void* exec_th(void* arg) {
printf("THREAD %p before LOCK\n", pthread_self());
//second mutex lock
pthread_mutex_lock(&m);
printf("THREAD %p after LOCK\n", pthread_self(
浏览 0提问于2018-05-02得票数 2
回答已采纳
1回答
我正在用C++编写一个多线程合并排序。上下文:用户使用适当的标志运行程序，例如"./mergeSort 100 -t 20“
第一个数字代表程序应该生成和排序的随机数，-t标志代表使用线程，最后一个数字代表程序应该使用的最大线程数(当程序达到最大线程数时，它继续执行标准的合并排序，而不使用多线程)。
为了计算线程的数量，我使用了一个带有互斥锁的全局变量number_of_units，但我就是做不到这一点。
标准的合并排序函数打印文本“标准”，线程函数打印出"new thread #“，其中#是程序仍然可以创建的新线程数。每次启动新线程时，我都会递减计数器。下面是main()的一
浏览 0提问于2018-12-10得票数 0
1回答
在线程中使用不同的互斥锁
、、、
我已经编写了以下程序来在POSIX中实现两个线程。有一个全局共享变量sum，它由两个不同的线程同时访问。在访问共享变量时，我在每个线程中使用了互斥锁和解锁。我有个问题。在这里，我在两个线程中使用了samed互斥锁(pthread_mutex_lock(&mutex))。如果我在thread1的线程(比如pthread_mutex_lock(&mutex))和thread2的pthread_mutex_lock(&mutex1)线程中使用两个不同的互斥锁和解锁，会发生什么？我已经注释掉了代码中的混乱之处。
我的示例代码片段：
#include<stdio.h>
浏览 3提问于2015-10-18得票数 3
2回答
互斥与线程无关
、、、、
我在32核计算机上运行以下程序：
#include<iostream>
#include<algorithm>
#include<boost/thread.hpp>
using namespace std;
boost::thread_group g;
boost::mutex _mtx;
class A{
public:
void foo()
{
for(int ix = 0; ix < 10000000; ++ix)
vec.push_back(ix);
so
浏览 1提问于2013-10-02得票数 1
回答已采纳
Hy all :)
我在我的VC++项目中使用1.5.4-all (2014-10-22) (MicrosoftVisualC++编译器18.00.21005.1用于x86平台)。
我的问题是，经过一段时间后，我会得到以下错误消息。错误发生后的时间差异很大--有时在30秒后发生，有时在5分钟后发生。
我可以在第214行的LinearHashTable.h文件中找到错误的源：
我有以下方法，其中向表中添加了Shot (struct)：
void ShotSimulationService::SimulateShot(Shot shot) {
MutexThre
浏览 3提问于2015-01-09得票数 0
回答已采纳
1回答
共享内存使用无锁算法
、、、
我想使用lock-free algorithm作为共享内存，以避免互斥。我有一些共享数据的进程使用共享内存。如果一个进程正在锁定互斥对象并崩溃，所有其他进程也会崩溃。
我读了一些用链表实现无锁算法的论文。但是在我的共享内存中，我不能定义用于这个内存块的数据结构。我只有一个指向这个街区的指针。
所以我对在我的情况下应用无锁算法没有任何想法。我需要你的帮助。如果我的英语很差的话，谢谢和抱歉。
浏览 3提问于2012-09-06得票数 4
5回答
互斥粒度
、
我有个关于线程的问题。我们知道，基本上当我们调用互斥(锁)时，这意味着线程继续执行代码部分，不受其他线程的干扰，直到它遇到互斥(解锁)为止。(至少他们在书中是这么说的)所以我的问题是，是否有可能有几个不互相干扰的范围的WriteLocks。例如，如下所示：
如果我有一个有N个元素的缓冲区，但是没有任何新的元素，那么高频更新(比如Kth元素的更改值)是否可以对每个元素设置一个不同的锁，以便线程唯一会停止和等待的时间是，如果实际上有两个或更多线程试图更新相同的元素？
浏览 7提问于2014-09-25得票数 5
回答已采纳
2回答
我有一组对象，每个对象有两个线程:任务线程处理数据，并通知决策线程数据已准备好，然后等待决策线程做出是否继续操作的决策；决策线程等待任务线程获取数据，然后消费数据并做出决策(通知任务线程决策已准备好获取)。
Task.cpp:
class Task{
public:
void DoTask(){
// process data
{
std::unique_lock<std::mutex> lck(mtx);
data_ready = true
浏览 1提问于2015-09-02得票数 3
1回答
多个互斥锁是如何工作的？
、、、、
我正在学习POSIX线程，我的教授已经开始教授第一个读者-作家问题。这是我关于解决问题的伪代码(只适用于第一种情况:读者的偏好)。
semaphore rw_mutex = 1; /* semaphore common to both reader & writer */
semaphore mutex = 1; /* semaphore for reading (reader lock) */
int read_count = 0; /* track number of readers in CS */
Writer:
do {
lock(rw_mutex);
/* ensure
浏览 1提问于2016-05-02得票数 0
回答已采纳
3回答
比较和交换的工作原理
、、、
我读过相当多的帖子，说比较和交换保证原子性，但是我仍然不能理解它是如何做到的。下面是比较和交换的通用伪代码：
int CAS(int *ptr,int oldvalue,int newvalue)
{
int temp = *ptr;
if(*ptr == oldvalue)
*ptr = newvalue
return temp;
}
这如何保证原子性呢？例如，如果我用它来实现一个互斥锁，
void lock(int *mutex)
{
while(!CAS(mutex, 0 , 1));
}
这如何防止两个线程同时获取互斥锁？如果有任何建议，我们
浏览 2提问于2014-03-12得票数 28
我们在CMSIS和FreeRTOS的STM32F407板上遇到了互斥锁的问题。
有两个线程可以通过UART访问硬件无线电。我们使用互斥锁来确保一次只能有一个线程与收音机对话。
每次成功捕获或释放互斥对象时，使用SWO将其打印到串口，我们可以看到在某些情况下会发生以下情况：
线程1成功地使用osMutexWait(radioAccessMutex，400)捕获互斥体。
线程2使用osMutexRelease(radioAccessMutex)成功地释放相同的互斥体。
据我理解，互斥只能由当前持有互斥的线程释放。
两个互斥调用的返回值都是osOK。配置文件中已关闭递归互斥。两个线程
浏览 0提问于2018-02-13得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
