我正在Linux RT多核机器上测试我的多线程应用程序。
但是，在测试期间，我们观察到Linux中的调度(使用SCHED_FIFO调度策略创建)并不是按照SCHED_FIFO策略进行的。我们可以在多个地方看到，较高优先级的线程正在被低优先级线程抢占。
根据我们在internet上所做的一些研究，我们发现以下内核参数需要从
/proc/sys/kernel/sched_rt_period_us containing 1000000
/proc/sys/kernel/sched_rt_runtime_us containing 950000
至
/proc/sys/kernel/sched_rt_
浏览 2提问于2014-10-01得票数 2
1回答
我正在从浏览并发部分，在遍历互斥部分时，我对此感到困惑：
为了避免繁忙的等待，互斥实现采用了park() / unpark()机制(在Sun上)，该机制将一个等待线程与其线程ID放在队列中。在pthread_mutex_unlock()期间，它将一个线程从队列中移除，以便由调度程序选择。类似地，Futex的实现(Linux上的互斥实现)使用相同的机制。
我还不清楚排队的人在哪里。它是在正在运行的进程的地址空间中还是在内核中的某个位置？
我的另一个疑问是关于条件变量。pthread_cond_wait()和pthread_cond_signal()是使用普通的和等待方法，还是使用它的某些
浏览 1提问于2014-08-21得票数 4
回答已采纳
1回答
我想在Tasklet计时器中断的下半部分技术中使用信号量，但我从理论上知道，tasklet不会睡觉，但是信号量会休眠。有什么解决办法吗？
浏览 4提问于2014-08-24得票数 1
回答已采纳
2回答
我知道内核可以通过spinlock方法同步进程。然而，当涉及到一个处理器时，它如何做到这一点呢？它如何使用同步对象来确保互斥？
信号量是在执行层吗？内核是如何在这里发挥作用的？
互斥锁只在内核级别实现吗？当资源空闲时，它们不会发出信号或消息。
浏览 0提问于2012-11-13得票数 0
2回答
对文件linux的并发访问
、、、、
我在linux中查看了syscall读/写是如何完成的，我发现了以下内容：
....
loff_t pos = file_pos_read(f.file);
ret = vfs_read(f.file, buf, count, &pos);
file_pos_write(f.file, pos);
fdput(f);
...`
我的问题是：
锁到哪里去了？我会想像这样的东西：
....
lock(f.file); // <-- lock file struct
loff_t pos = file_pos_read(f.file);
ret = vfs_read(f.file,
浏览 2提问于2013-01-30得票数 10
回答已采纳
3回答
我对Linux很陌生，所以我有一些关于使用mmap和线程的问题。
在Linux中，互斥会导致上下文切换吗？我做了谷歌，有些人说是，另一些人说不。因此，关键部分更好吗？我只使用一个程序。
所以，我是用户，我已经注册了一些HW寄存器。我有代码，基本上是这样的：
setRegisterBits( offset, fromBit, toBit )
{
ReadRegister()
ModifyRegister()
WriteRegister()
}
许多线程可以访问相同的mmap，所以我需要这个函数是原子的。Linux程序员会有什么建议？
浏览 1提问于2014-09-11得票数 1
回答已采纳
2回答
进程同步
、、、
将一段代码指定为关键部分的因素
据我所知，process synchronization是使用内核数据结构(如semaphores )来防止并发访问代码的critical section的。一般来说，我认为定义是，“关键部分是可以访问共享数据(或)共享资源的代码段”。所以问题是：
共享数据是一个用户空间实体。因此，用户进程有责任确保其访问的一致性。
我认为通过多个进程并发访问资源是内核应该注意的事情。那里需要什么样的用户级同步？
用户空间程序中的一段代码被确定为关键部分的因素是什么。
浏览 4提问于2012-11-08得票数 2
回答已采纳
2回答
死锁是将进程放入较高的CPU使用率，还是这两个进程都“休眠”，等待另一个进程完成？
我试图在Linux系统上调试一个用C++编写的多线程程序。我注意到一个特定进程的CPU利用率过高，我想知道这是否是由于死锁问题造成的。我已经确定，一个进程总是比我预期的(使用top)使用更多的CPU，并且这个过程可以工作，但是它工作得很慢。如果死锁导致进程休眠，并且不会导致较高的CPU使用率，那么至少我知道这不是一个死锁问题。
浏览 5提问于2014-08-14得票数 5
回答已采纳
3回答
我正在阅读有关给定测试用例的临界区和互斥量之间的C#性能差异的。我正在考虑是否有更多的文档为C++应用程序的各种锁定类提供性能开销，特别是在Windows32或64位平台上运行的MFC？
我问这个问题的原因是，我在广泛的自动化测试中得到的分析器结果显示，我在互斥代码中花费了大量时间。我试图弄清楚的是，在等待资源变得可用时，这其中有多少是合理的延迟，以及有多少是由于锁定结构的实现和细节造成的。我只处理一个包含多个线程的进程，并且正在考虑切换到临界区。长期自动化测试表明，我不需要互斥类提供的超时。
因此，有没有人知道任何与不同Windows平台上不同MFC锁定机制的性能开销相关的参考文档？
浏览 3提问于2011-10-10得票数 3
回答已采纳
1回答
OpenMutex与线程
、、、
我注意到，在p线程库中，没有类似于Win32下的Win32或信号量下的semget()这样的函数。
为什么？
这是否意味着我必须在任何情况下使用pthread_create()？
浏览 4提问于2014-08-07得票数 0
回答已采纳
我有一个多线程应用程序挂起了对_dl_sysinfo_int80()的调用。根据gdb的说法，所有线程都被阻塞在这个调用中。
堆栈跟踪的顶部如下所示：
#0 0x002727a2 in _dl_sysinfo_int80 () from /lib/ld-linux.so.2
#1 0x004f23de in __lll_mutex_lock_wait () from /lib/tls/libpthread.so.0
#2 0x004ef00b in _L_mutex_lock_35 () from /lib/tls/libpthread.so.0
#3 0x092828ac in co
浏览 2提问于2008-11-20得票数 2
我正在为linux内核模块编写代码，并在其中经历了一种奇怪的行为。下面是我的代码：
int data = 0;
void threadfn1()
{
int j;
for( j = 0; j < 10; j++ )
printk(KERN_INFO "I AM THREAD 1 %d\n",j);
data++;
}
void threadfn2()
{
int j;
for( j = 0; j < 10; j++ )
printk(KERN_INFO "I AM THREAD
浏览 0提问于2010-11-06得票数 2
回答已采纳
为了比较std::atomic<int>++和std::mutex受保护的int++之间的性能差异，我有以下测试程序：
#include <iostream>
#include <atomic>
#include <mutex>
#include <thread>
#include <chrono>
#include <limits>
using namespace std;
#ifndef INT_MAX
const int INT_MAX = numeric_limits<std::int32_t&g
浏览 4提问于2022-09-24得票数 2
回答已采纳
1回答
当我搜索如何在C++11中使用信号量时，我看到人们经常建议我用std::mutex和std::condition_variable (例如)来制作信号量。这使我认为信号量是一个比互斥变量和条件变量更高层次的抽象。
但是，在我学习了操作系统类之后，我现在知道在内核中，信号量通常是最低的抽象级别。信号量是通过禁用中断来实现的，锁本质上是值为1的信号量，而条件变量则是在不使用信号量或锁的情况下从底层实现的。因此，与锁或条件变量相比，信号量(在内核级)似乎并不是一个更高级别的抽象。
所以我的问题是，我的结论是“信号量(在C++11中)是一个更高层次的抽象”只是标准库限制的产物吗？或者是用户级和内核级同
浏览 6提问于2016-12-19得票数 0
回答已采纳
1回答
我试着重做一个线程的例子。下面是我一个接一个地运行的两个函数。它们是典型的增量和递减函数。
void* increment(void *arg)
{
int incr_step = *(int*) arg;
free(arg);
unsigned long int i;
for(i=0; i<5;i++) {
//pthread_mutex_lock(&lock);
counter = counter + incr_step;
//pthread_mutex_unlock(&lock);
浏览 0提问于2016-12-12得票数 0
回答已采纳
目前，我有两个使用message_queue和shared_memory form boost进行通信的进程。一切都在有人照看的情况下工作。
现在我需要让其中一个进程成为多线程的(再次感谢boost )，我想知道是否需要在线程之间使用保护机制(例如互斥)，或者boost::interprocess库是否已经提供了保护机制？
我在boost文档中没有找到任何关于这方面的信息。顺便说一下，我使用的是boost 1.40。
提前谢谢。
浏览 2提问于2012-02-14得票数 5
5回答
我在网上读过很多次，互斥锁比关键section/semaphores/insert-your-preferred-synchronisation-method-here.慢。但我从来没有见过任何论文或研究或任何东西来支持这一说法。
那么，这个想法是从哪里来的？这是神话还是现实？互斥锁真的很慢吗？
浏览 3提问于2009-11-03得票数 21
回答已采纳
4回答
存在一个关于互斥锁和临界区之间的区别的问题，但它也不处理锁。
所以我想知道临界区是否可以用于进程之间的线程同步。
还有什么是有信号状态和无信号状态
浏览 0提问于2010-05-11得票数 12
回答已采纳
3回答
我有以下基准：
本质上，它会旋转k线程，然后每个线程使用自旋锁和std::mutex执行大约1600万/ k锁/增量/解锁周期。在OSX上，当竞争时，std::mutex比spinlock慢得多，而在Linux上，它更有竞争力，或者更快一些。
OSX：
spinlock 1: 334ms
spinlock 2: 3537ms
spinlock 3: 4815ms
spinlock 4: 5653ms
std::mutex 1: 813ms
std::mutex 2: 38464ms
std::mutex 3: 44254ms
std::mutex 4
浏览 1提问于2014-04-06得票数 7
1回答
CodeBlockA;
Lock;
CodeBlockB;
Unlock;
CodeBlockC
代码块可能包含很多代码，只需将其作为一个单元。
CodeBlockA CodeBlockB CodeBlockC是否始终以串行方式执行？lock是如何做到这一点的？
浏览 14提问于2021-07-29得票数 0
我正在寻找一些可以用于C/C++中轮询的东西(比如select、kqueue、epoll，也就是不繁忙的轮询)。换句话说，我需要阻塞一个线程，然后在另一个线程中唤醒它，并尽可能减少的开销()。
mutex + condition variable可以工作，但是开销很大。一个futex也能工作，但是它只适用于Linux (或者不是？)。只要轮询本身正常工作，就不需要额外的同步，例如，当我在两个线程中调用wait和wake时，没有竞争。
编辑:如果FreeBSD中不存在这样的“工具”，那么如何使用C++11内置类型和系统调用创建一个工具呢？
Edit2:既然这个问题被迁移到了这个问题上，我想使它更
浏览 0提问于2014-04-24得票数 13
2回答
为什么管道里没有临界截面？例如，在共享内存中。在管道中有通用数据，这些数据在联合进程中常用，但在共享内存中也有通用数据，这些数据在联合进程中通常使用。
浏览 0提问于2012-11-19得票数 0
有许多不同的实时操作系统可用于微控制器。我特别寻找支持ARM Cortex M处理器的RTOS。另外，我对封闭源解决方案不感兴趣。
试图从网站和邮件列表中比较每个RTOS的相对优点似乎相当困难，因为它们似乎大多具有相同的功能，并且做同样的事情。真正的区别显然只有在尝试将每个RTOS用于某些任务之后。
我知道这是一个主观的问题，而且可能很难回答--但肯定有很多人实际上尝试过几种不同的实时操作系统，并对每个问题的相对优点形成了看法。
我对FreeRTOS、ChibiOS和Coocox CoOS特别感兴趣，但其他选择也非常受欢迎。
例如:在ChibiOS中，ISRs似乎可以调用任何系统函数，但是这
浏览 2提问于2014-02-11得票数 3
1回答
嗨，朋友们，我在这里遇到了线程同步的问题。我是一个新手，这就是为什么要向你们寻求帮助的原因。在我的代码中，我必须从串口读取数据，然后将数据发送到UDP端口。为此，我有两个额外的线程。在第一个线程中，我在无限的while循环中读取数据，在第二个线程中，我正在做一些处理，然后发送数据。
问题是，我没有得到buff1的值，它在第二个线程中的整数值is==为1，这意味着我很少得到值==1。但在第一个线程中，我不断地获得buff1的值。
我怀疑这是因为我没有使用互斥锁。我想知道在我的代码中，如果有必要，我将如何使用互斥。请指导我改进我的源代码
下面是我的代码
#include <stdio.h&g
浏览 5提问于2014-08-13得票数 0
1回答
我观看了一个关于高性能计算的，从24:55开始，其中一个演示者指出，通过获取锁进行同步需要向下切换到操作系统的内核(如果应用程序在一个内核中运行，甚至不需要虚拟机)。我希望能简要解释一下为什么会出现这种情况，以及为什么不能在JVM中处理(对于Java应用程序)。
浏览 2提问于2012-11-25得票数 0
我有以下情况：
两个C++11线程正在进行计算，它们通过std::mutex进行同步。
线程A锁定互斥对象，直到数据准备就绪，然后执行线程B。当互斥锁解除时，线程B开始工作。
线程B试图锁定互斥锁并被阻塞，直到线程A解锁为止。
void ThreadA (std::mutex* mtx, char* data)
{
mtx->lock();
//do something useful with data
mtx->unlock();
}
void ThreadB (std::mutex* mtx, char* data)
{
mtx->loc
浏览 2提问于2015-10-05得票数 4
回答已采纳
3回答
内核计时器对象和同步
、、、
我想知道是否有人可以简单地告诉我(我知道这不是一个简单的主题)如何使用内核计时器对象来同步对内核中数据结构的访问？
编辑：
内核计时器对象是内核调度程序对象的一部分，调度程序对象是内核的同步对象组。我还想知道timer对象是线程在能够继续之前必须等待获得句柄的对象，还是在计时器到期时触发的回调，线程等待获得句柄？
我希望这是有意义的。内核对我来说是一个新的课题。
浏览 0提问于2010-01-03得票数 1
回答已采纳
3回答
我对Linux设备驱动程序和内核非常陌生。我基本上想同步一个workque线程(让我们称之为A())与另一个函数(让我们称之为B())。我在这里的目的是在A运行时使B失败。
目前，我所做的工作如下。
A(){
active = true; // a variable shared b/w both A and B
...
...
...
active = false;
}
B(){
if(active){
return -EBUSY
}
}
这是同步这两个函数的正确方法吗？还有其他我应该遵循的策略吗？
浏览 2提问于2015-04-10得票数 1
我刚刚意识到它似乎在Boost中有两个互斥“世界”。boost::interprocess下的一些互斥和boost::thread..下的互斥定义两者都可以互换使用吗？例如带有boost的scoped_lock：：wait？
浏览 1提问于2011-07-18得票数 5
回答已采纳
2回答
并发:只有互斥？
、、
提供互斥(即通过自旋锁机制)是否足以确保并发的有效实现？或者我们也必须显式地实现一些同步方法？
总结一下：
提供并发性=有效的互斥实现
或
提供并发性=有效的互斥实现+有效的同步实现
谢谢。
浏览 1提问于2011-10-14得票数 0
回答已采纳
我只是好奇线程在不同风格的Unix中的工作方式是否有什么不同。
特别是Linux、Solaris和原来的Unix。
有什么想法吗？
浏览 4提问于2014-07-12得票数 2
回答已采纳
基本上，我希望在linux内核中实现自己的信号量，并能够在用户程序中使用它。
我在实现内核代码方面取得了一些进展，但是我不知道如何使信号量类型和我编写的函数对用户程序可用。
用户程序需要能够访问我的信号量类型及其函数(等待、信号...)
有没有办法让使用用我的代码编译的内核的linux能够简单地通过包含一个头文件来使用我的信号量？
当涉及到linux内核时，我不是专业人士，所以如果我犯了任何明显的错误，请随时指出它们out.Thanks。我使用的内核版本是2.6.32。
浏览 3提问于2014-12-03得票数 2
2回答
我希望在单进程多线程应用程序上使用POSIX消息队列。mqueues将用于在线程之间共享数据。
我对它们在Linux内核中的工作原理有点困惑。是否所有的消息都通过内核空间，然后在接收时返回到用户空间？又名。在用户空间线程中，我执行一个mq_send，消息最终到达内核空间，然后在接收到它时，是另一个从内核空间获取消息的系统调用。如果是这样的话，对于高使用率的消息队列来说，这不是非常低效吗？
浏览 0提问于2011-03-30得票数 6
回答已采纳
2回答
我在某个地方读到，互斥量的开销并不大，因为上下文切换只发生在争用的情况下。
在Linux中也知道Futexes。
同样的东西在Windows中也适用吗？是一个更适合于Linux中互斥的映射。
从我收集到的信息来看，与Mutex相比，关键部分提供了更好的最佳性能，这对每种情况都是正确的吗？
在Windows中，是否存在互斥量比关键部分快的情况。
假设只有一个进程线程正在访问互斥项(只是为了消除关键部分的其他好处)。
添加信息: OS windows Server，
Language C++
浏览 3提问于2013-08-06得票数 8
回答已采纳
我的意图是监视一个目录中新创建的文件，同一目录在多台计算机之间共享，下面是供您参考的脚本，一旦我运行该脚本，该脚本将标识从机器xyz (我正在运行通知程序脚本)创建的文件，并且它不识别来自机器abc的文件！在监视给定目录下新创建的文件时，是否需要考虑什么？不管文件是从哪台机器创建的。
有没有任何方法可以使用'inotify2.pm‘跟踪在不同机器上创建的文件？
use Linux::Inotify2;
my $inotify;
$inotify = new Linux::Inotify2 ;
my $dir="/home/vikas/";
opendir(DIR, $d
浏览 1提问于2017-03-30得票数 0
回答已采纳
3回答
如何同步三个相关线程
、、、、
如果我有
1. mainThread: write data A,
2. Thread_1: read A and write it to into a Buffer;
3. Thread_2: read from the Buffer.
如何在不损失太多性能的情况下安全地同步这三个线程？是否有任何现有的解决方案可供使用？我在linux上使用C/C++。
重要:目标是了解这种特殊情况下的同步机制或算法，而不是互斥或信号量是如何工作的。
浏览 0提问于2012-01-24得票数 3
回答已采纳
2回答
我使用一个非阻塞套接字向多个目标发送udp数据包，并在同一套接字上接收来自所有目标的响应。我在一个专用线程中读取，但写入(sendto)可以来自几个不同的线程。
这是一个没有任何额外同步的安全吗？我需要在拿着互斥锁的时候写东西吗？或者，写操作需要来自同一个线程，而我需要一个队列吗？
浏览 2提问于2012-06-27得票数 6
回答已采纳
什么等同于linux内核中的pthread_mutex_lock和pthread_cond_wait？以及如何使用它们。你能提供一些简单的例子(hello world)吗？
浏览 2提问于2012-04-11得票数 3
回答已采纳
可能重复：
在Linux/C中:线程之间共享的全局变量是否需要声明为易失性(假设变量在其中一个线程中被修改)？
我需要在哪些情况下将变量声明为线程中的易失性变量？
浏览 5提问于2011-11-14得票数 3
回答已采纳
2回答
在linux或linux库中，是否存在与win32中的关键部分相当的部分？
我知道Mutex，但它与关键部分不一样，因为关键部分在内部使用用户模式的自旋锁和事件对象，而且它必须比互斥快。
浏览 0提问于2012-01-16得票数 3
回答已采纳
1回答
在互斥锁的内核实现中，线程所有者字段仅当它是SMP构建时才存在。我可以理解，在良好和干净的代码下，只有在获取成功时，线程才会调用release，所以我们可以通过不跟踪线程来节省一些缓存和cpu周期。但是为什么SMP需要它呢？是因为在SMP中，互斥是混合的并且旋转，而线程拥有者在另一个cpu上并且需要这个字段作为引用，还是它背后有更多的原因？
浏览 4提问于2012-09-25得票数 0
回答已采纳
4回答
有没有办法使用cassandra内置函数来同步客户端？
我需要执行一些操作，这些操作需要与所有其他客户端同步(互斥)。
在RDBMS中，我可以锁定整个表或准备特殊的表用于同步，并使用SELECT ...关于它的更新。
我可以在没有任何第三方应用程序的情况下使用Cassandra实现这一点吗？如果不是，那么最好的方法是什么？首选的语言是Java和Python。
浏览 4提问于2011-01-18得票数 8
回答已采纳
2回答
我已经学习了一段时间的linux编程，我知道signal和system call是完全不同的概念。
据我所知，system call是内核提供给外部的接口，而signal是一种让进程从内核或其他进程接收信息的机制。对我来说，这是一个很好的反向过程。
我理解得对吗？
我的问题是：
这两个概念之间是否有深刻或简单的关系？
这可能是个愚蠢的问题，但有时我会把它们混在一起，我需要仔细考虑一下，才能区分它们。我试图得到一个简单的意见，以帮助我理解关系和区别。
浏览 4提问于2015-09-22得票数 2
回答已采纳
4回答
在进程中使用互斥/信号量
、、、
到目前为止，我在网上读到的几乎所有的代码和教程都涉及到使用互斥和信号量来实现线程间的同步。它们能用于进程间的同步吗？
我想编写如下代码：
void compute_and_print() {
// acquire mutex
// critical section
// release mutex
}
void main() {
int pid = fork();
if ( pid == 0 ) {
// do something
compute_and_print();
}
else {
// do something
compute_and_print(
浏览 4提问于2014-02-05得票数 8
我被自旋锁的功能弄糊涂了。
自旋锁用于停止进程的重新调度。然而，在一台只有一个内核的机器上，使用自旋锁来防止上下文切换是否有用？
浏览 3提问于2009-06-22得票数 16
回答已采纳
2回答
不同工艺间的产量
、、、、
我有两个C++代码，一个叫做a，一个叫做b。我在64位Linux中运行，使用Boost线程库。
A代码创建了5个线程，它们停留在一个不结束的循环中，执行一些操作。B代码创建了5个线程，这些线程停留在一个不结束的循环中，调用non()。
我在一个四核机器上..。单独调用代码时，CPU使用率几乎为400%。当单独调用b代码时，它的CPU使用率几乎为400%。我早就料到了。
但是当两者一起运行时，我希望b代码几乎不使用CPU，使用400%的CPU。但实际上两者都在使用等于CPU的部分，几乎是200%。
我的问题是，不同进程之间不产生()工作吗？有什么办法让它像我想象的那样运作吗？
浏览 5提问于2011-09-22得票数 5
回答已采纳
4回答
如果在不显式使用同步机制的情况下，在两个不同的线程中对相同的文件描述符调用read (或write，或两者)(let表示我们对本地文件感兴趣，而a表示它是套接字文件描述符)，会发生什么情况？
读取和写入是系统调用，因此，在单核CPU上，“同时”执行两个读取可能是不幸的。但是如果有多核的话。
linux内核会做什么呢？
让我们来概括一下:其他内核(如BSD)的行为总是相同的吗？
编辑:根据，我们应该确保文件描述符没有被其他线程中的syscall使用。因此，它认为在关闭文件描述符之前需要显式同步(因此，如果可能调用它的线程仍在运行，也需要读/写)。
浏览 1提问于2013-07-03得票数 12
回答已采纳
2回答
在Linux内核源代码中，存在许多内存屏障(smp_mb()等)。
但在redis的消息来源里，我没看到。在redis的Makefile中，gcc优化选项是-O2，所以需要对这些指令进行重新排序。为什么不使用mb()来确保正确的行为呢？
添加：
例如:在Linux内核的kfifo中：
unsigned int __kfifo_put(struct kfifo *fifo,unsigned char *buffer, unsigned int len)
{
unsigned int l;
len = min(len, fifo->size - fifo->i
浏览 1提问于2013-01-06得票数 2
回答已采纳
1回答
从底层实现互斥
、、
让我说我正在写一个操作系统。我不是骗子，所以我从最底层开始。过了一会儿，您就有了进程、抢占式调度程序和Malloc。现在你需要互斥和信号量。
这是代码的开始，它可以独占锁定互斥对象，或者单独增加或减少信号量。让我说我有这个密码。
然后你得到了下一步:采取互斥。假设我们有两个过程，争夺一个互斥体。进程A是第一个，在B能够触摸它之前抓取互斥物。所以现在B得等了。我的问题是关于如何处理等待阶段。我可以看到以下选项：
将进程B保持在调度程序上，每次它得到一个时间间隔，它将检查它是否能够锁定互斥锁。如果没有，重新安排，等待下一次机会。这个方法看起来完美无缺，除了浪费CPU时间在一个不能做任何事情的进
浏览 5提问于2014-11-04得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
