我知道自旋锁与自旋一起工作，不同的内核路径存在，内核是抢占式的，那么为什么单处理器系统中自旋锁不起作用呢？(例如，在Linux中)
浏览 1提问于2012-02-07得票数 9
回答已采纳
下面的示例代码(请参阅下面的代码)是通过线程执行的：
A: rd-lock
B: wr-lock (waiting)
A: rd-lock (recursive)
A: rd-unlock (recursive)
A: rd-unlock
B: wr-locked (wake after wait)
B: wr-unlock.
基本上读锁是递归的。它是POSIX标准所要求的(要求读锁是递归的，但不是为写锁指定的)。这在Linux、FreeBSD、Solaris上有效，但在达尔文/Mac上不起作用。
下面的示例在Linux上提供了以下输出：
read locking
read locked
wr
浏览 7提问于2012-01-10得票数 1
这是一个面试问题。
在linux上，如何确保解锁死/终止的POSIX线程中锁定的POSIX互斥锁？
我的想法是：
当Linux向程序发送终止或终止信号时，它会自动释放吗？但是，我找不到操作系统如何做到这一点的更多细节？
谢谢
浏览 2提问于2012-02-09得票数 4
回答已采纳
1回答
我测试了我的程序
以下是原始信息：
==170652== ---Thread-Announcement------------------------------------------
==170652== ----------------------------------------------------------------
==170652==
==170652== Thread #5: lock order "0x4A82168 before 0x4A82108" violated
==170652==
==170652== Observed (incorr
浏览 14提问于2022-05-03得票数 -2
1回答
我的Java程序打开一个文件并缓慢地写入该文件。当操作完成后，程序将关闭该文件并将该文件移动到其在另一个目录中的最后休息位置。问题是，在运行操作时，同一个Java程序中的另一个线程将删除该文件。
Windows将不允许在文件打开时删除该文件。Linux允许文件在打开时被删除。在NFS文件系统中，Linux将重命名该文件，然后在文件关闭时自动删除该文件。如何防止文件打开时删除？
如何才能找到删除文件的内容？如何在删除文件的程序中获得Java线程的调用堆栈？
更改文件所有者将无法工作，因为同一进程中的另一个线程正在删除该文件。
程序正在主动地写入文件，因此删除文件上的写权限将无法工作。删除目录上的
浏览 0提问于2018-01-19得票数 3
回答已采纳
1回答
我知道linux内核不支持递归自旋锁，它会死锁。
我写了一个示例代码来查看行为，即使我有多个CPU，系统也会冻结。这是预期的行为吗？
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/spinlock.h>
MODULE_LICENSE("GPL");
DEFINE_SPINLOCK(my_lock);
static int __init test_hello_init(void)
{
spin_lock(&my_lock);
浏览 3提问于2019-09-21得票数 1
2回答
在一些关于算法的文章中，有些使用了单词lockfree，有些使用了lockless。lockless和lockfree有什么区别？谢谢!
更新
第5.2节--“Linux中的无锁环缓冲区*”，这是使用单词“无锁”的一个例子
浏览 0提问于2013-12-09得票数 12
回答已采纳
2回答
如何检测互斥条件
、、
我想知道是否有可能在Linux下使用POSIX线程库实现以下逻辑。
given a mutex
if (I can get the mutex) {
lock the mutex
call fun A
unlcok the mutex
}
else {
call fun B
}
我是Linux下的线程编程新手，所以只需使用伪代码来显示我正在寻找的代码片段的逻辑即可。
浏览 1提问于2011-03-21得票数 1
回答已采纳
3回答
有一种情况，我有两个线程都在使用相同的互斥量。一个线程锁定互斥锁并崩溃。互斥状态是什么？它是否仍然被锁定，并且第二个线程永远不会拥有该互斥锁？意味着死锁的情况？
编辑-还解释了Linux系统上pthread的一个案例
浏览 1提问于2010-07-02得票数 5
回答已采纳
在这个问题之前进行一点讨论。Linux2.4内核是非抢占式的，所以当我们在内核模式下处理系统调用时，如果需要进行上下文切换，我们只需执行set_need_resched来引发一个标志，然后当我们返回到用户模式时，我们检查该标志并进行上下文切换。
让我们将其与具有抢占式内核的Linux2.6进行比较。我们不能将2.4内核的set_need_resched (提升标志)改为schedule() (重新调度的指令执行)，所以在Linux2.6内核中有一个计数器preempt_count，它在spin_lock()上每次都会增加，在spin_unlock()上会减少。
实际上，这个字段"pre
浏览 10提问于2017-12-31得票数 1
1回答
在Linux中，假设我有100个线程的代码。这些线程中有5个竞争由互斥锁保护的共享资源。我知道当临界区实际运行时，如果5个线程试图获得锁，则只有5个线程会停止执行，而其他95个线程将正常运行。
我的问题是，是否存在其他95个线程的执行将暂停或受影响的时间点，即互斥量/内核/什么决定哪些线程在互斥量上被阻塞，哪个线程应该获得锁，以及哪些线程应该能够运行，因为它们没有请求锁，等等
浏览 5提问于2013-03-29得票数 1
回答已采纳
1回答
使用不同的gcc优化，我的程序死于不同的操作系统信号，我想知道原因是否相同。
在使用O2编译的c++多线程程序中，由于abort()，我得到了一个核心转储。
Program terminated with signal 6, Aborted.
#0 0x00007ff2572d28a5 in raise () from /lib64/libc.so.6
我只是不能找出哪个是原因，因为它似乎是在本地std::vector析构函数中。这对我来说毫无意义。
(gdb) thread 1
[Switching to thread 1 (Thread 0x7ff248d6c700 (LWP 16767
浏览 2提问于2014-09-01得票数 1
我有一个文件夹，其中不断地添加新的文件。我有一个python脚本，它使用os.listdir()查找这些文件，然后自动对它们执行分析。然而，这些文件相当大，因此在它们实际上已经被完全编写/复制之前，它们似乎出现在os.listdir()中。是否有办法区分哪些文件不在移动过程中？将大小与os.path.getsize()进行比较似乎不起作用。
用Python3.7.3在Pi4上使用Raspbian。我是编程和linux的新手。
谢谢!
浏览 5提问于2020-08-04得票数 0
回答已采纳
1回答
在POSIX系统(linux等)中，当多个线程锁定一个公共互斥对象时--是总是观察到的锁定顺序，还是在调度关键部分中的下一个线程时，线程优先级偏高的线程？
标准中有没有提到任何关于行为的内容？因为据我所见，它似乎只提到了所需的接口。
请注意，我正在寻找关于任何符合POSIX的系统(不仅仅是linux)的指导，所以请随意建议其他OSes (QNX、Minix等)的行为。
浏览 8提问于2012-04-30得票数 2
4回答
我在Linux上使用读/写锁，并且我发现试图将读锁对象升级为写锁死锁。
即
// acquire the read lock in thread 1.
pthread_rwlock_rdlock( &lock );
// make a decision to upgrade the lock in threads 1.
pthread_rwlock_wrlock( &lock ); // this deadlocks as already hold read lock.
我读过手册页，它很具体。
调用线程如果在调用时持有读-写锁(无论是读锁还是写锁)，则可能会死锁。
在这种
浏览 1提问于2010-03-09得票数 16
回答已采纳
2回答
我正在尝试使用pthread以并行方式实现串行算法。下面是我写的代码：
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <string>
#include <cmath>
#include <sys/time.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include
浏览 1提问于2014-05-05得票数 0
1回答
我今天写了一个p线程代码：
#include <pthread.h>
#include <stdio.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *thread1(void *arg)
{
while (1) {
pthread_mutex_lock(&mutex);
sleep(1);
printf("thread1...\n");
pthread_mutex_unlock(&mutex)
浏览 1提问于2013-01-04得票数 2
回答已采纳
3回答
我不确定锁将如何与多处理器/核心一起工作，我打算在我的应用程序或FIFO中使用共享内存，我担心的是锁，我有一个2 CPU的服务器，锁如何能够锁定一个CPU上的一个变量，而另一个操作是对同一个变量的第二个CPU呢？我在Linux环境中使用C，我在网上搜索了一些有用的信息，谢谢你的帮助
浏览 0提问于2012-07-17得票数 2
回答已采纳
我在哪里可以找到关于“自适应”pthread互斥的文档？符号PTHREAD_MUTEX_ADAPTIVE_NP是在我的系统上定义的，但是我在网上找到的并没有说明什么是自适应互斥，或者什么时候适合使用它。
所以..。它是什么，我应该什么时候使用它？
作为参考，我的libc版本是：
GNU C Library (Ubuntu EGLIBC 2.15-0ubuntu10.5) stable release version 2.15, by Roland McGrath et al.
Copyright (C) 2012 Free Software Foundation, Inc.
This is f
浏览 2提问于2013-11-09得票数 29
回答已采纳
我有一个问题:如果我们有一个不使用线程的应用程序，我们可以通过两种方式链接它：
1)链接照常，不带-lpthread和-ldl
2)在链接中添加两个库: libpthread和libdl。
例如。
$ cat a.c
int main(){printf("Hehe");}
$ gcc a.c -w -o a
$ gcc a.c -w -o a1 -ldl -lpthread
默认情况下，两个库都是动态链接的：
$ ldd a
linux-gate.so.1
libc.so.6
/lib/ld-linux.so.2
$ ldd a1
linux-g
浏览 2提问于2011-06-07得票数 11
回答已采纳
我做了一些关于互斥锁的研究，但找不到任何有价值的东西来阐明我所能理解的东西。我可以很容易地在linux上使用互斥锁。但是我不知道为什么我的互斥锁不能在我的应用程序上工作。我还寻找了一些示例，并实现了它。但这不可能；
这是我的互斥初始化；
public static Mutex mutex = new Mutex(true,"mut");
在这里，我使用互斥锁来锁定；
private void button4_Click(object sender, RoutedEventArgs e) //Challenge Start/Stop
{
浏览 4提问于2013-02-06得票数 0
在我的测试程序中，我启动了两个线程，每个线程只执行以下逻辑：
1) pthread_mutex_lock()
2) sleep(1)
3) pthread_mutex_unlock()
但是，我发现一段时间后，两个线程中的一个将在pthread_mutex_lock()上永久阻塞，而另一个线程正常工作。这是一种非常奇怪的行为，我认为这可能是一个潜在的严重问题。通过Linux手册，在获取pthread_mutex_t时并不禁止使用sleep()。所以我的问题是:这是一个真正的问题，还是我的代码中有任何bug？
以下是测试程序。在代码中，第一个线程的输出被定向到stdout
浏览 1提问于2011-11-11得票数 4
1回答
📷
这些是数据包接收进程的单独线程。有什么方法可以杀死任何一个线程吗？Linux是否提供任何特定的命令，可以杀死或发送停止信号给进程下的任何特定线程？
浏览 0提问于2017-11-12得票数 13
2回答
在linux或linux库中，是否存在与win32中的关键部分相当的部分？
我知道Mutex，但它与关键部分不一样，因为关键部分在内部使用用户模式的自旋锁和事件对象，而且它必须比互斥快。
浏览 0提问于2012-01-16得票数 3
回答已采纳
1回答
我正在尝试编写一个单一生产者-单一消费者队列。它抛出了分割错误。我已经附加在主体它自己与gdb输出的情况。我是多线程的新手，因此不知道为什么malloc会失败。有人能帮帮忙吗。
像这样编译代码
clang++ -std=c++11 ConcurrentQueue.cpp -o test -lpthread
下面是我的并发队列代码。在主模块中也给出了失败的情况。
#include <cmath>
#include <functional>
#include <iostream>
#include <mutex>
#include <stdex
浏览 5提问于2021-11-01得票数 0
我需要创建与Linux多线程应用程序正确工作的命名锁。应用程序的每个实例可以使用多个具有不同名称的命名锁。
我知道fcntl/flock，但如果试图从一个应用程序的不同线程或从一个线程锁定两次，它就不起作用。
我知道open(..., O_CREATE | O_EXCL)，但如果应用程序被信号杀死或由于分段故障而崩溃，那么这个文件锁将不会被删除，并且在重新启动应用程序后需要手动删除锁定文件。
还有别的办法吗？
浏览 4提问于2017-07-20得票数 0
2回答
我正在尝试移植一个依赖SIGCONT来停止应用程序的某些线程的代码。对于目前的linux nptl实现，在2.6.x内核中似乎不能依赖于此。我正在尝试设计一种方法来阻止其他线程。目前我只能考虑互斥和条件变量。如有任何提示，欢迎光临。
浏览 0提问于2010-04-19得票数 2
class MyClass
{
public:
void PushMessage(MyMessage m) // Thread 1 calls this
{
boost::mutex::scoped_lock lock(mMutex);
mQueue.push_back(m);
mCondition.notify_one();
}
MyMessage PopMessage()
{
boost::mutex::scoped_lock lock(mMutex);
while(m
浏览 0提问于2011-05-07得票数 4
2回答
互斥访问和系统调用
、、、、
我知道，在Linux中，互斥被实现为下面的futexes，futex使用比较和交换机制。通常，为了获取锁，用户空间线程不需要进行系统调用，因为锁是在用户空间中解析的。
现在，我的问题是，当存在很高的争用和许多线程试图同时锁定互斥时，会发生什么。那么，是否发生了系统调用，以便内核决定授予互斥对象哪个线程？尤其是当线程优先级不同的时候？我自己也这么认为。
浏览 3提问于2011-08-15得票数 11
回答已采纳
我在操作系统类中按需要分配Linux 手册页，作为对学生在设计同步原语时不要自满的警告。
futex()系统调用是Linux提供的允许用户级线程同步原语在必要时休眠和唤醒的API。手册页描述了可以使用futex()系统调用调用的5种不同操作。这两个基本操作是FUTEX_WAIT (当线程试图获取同步对象而有人已经持有它时，线程使用它来使自己休眠)和FUTEX_WAKE (线程用于在释放同步对象时唤醒任何等待的线程)。
接下来的三个操作是乐趣的开始。手册页描述如下：
FUTEX_FD (present up to and including Linux 2.6.25)
[...]
浏览 6提问于2014-08-27得票数 6
我写了简单的代码(附件)，我不明白为什么某些块上的锁不能锁定作用域。
代码：
object locker = new object();
private void foo(int i)
{
Console.WriteLine( string.Format( "i is {0}", i ) );
lock( locker )
{
while( true )
{
Console.WriteLine( string.Format( &
浏览 0提问于2012-04-11得票数 7
回答已采纳
Linux
我有两个功能：functionA和functionB
这两个函数可以运行多线程，其中：
一次最多只能运行一个functionA。
一次可以运行多个functionB
functionA和functionB是排他性的，也就是说，如果functionA正在执行，那么functionB必须等待functionA完成，如果有任何functionB实例正在执行，那么functionA必须等到-- functionB的所有实例完成。
你能告诉我如何在Linux中使用线程实现这个功能吗？我尝试了很多方法，但似乎还不够清楚。
Windows
如何使用C++在Windows中完成
浏览 8提问于2011-06-23得票数 1
回答已采纳
我使用的是openmp，我的程序如下所示：
\#pragma omp parallel for
for(x = 0, y = 0, x < 5, x++, y++)
function(x, y, fp);
void function(int x , int y, FILE* fp);
{
fprintf(fp, "(%d, %d)\n", x y);
}
我希望文件的内容为
(0, 0)
(2, 2)
(1, 1)
(3, 3)
(4, 4)
排序并不重要，但坐标x，y应该是有序的，即程序不应该生成像(2，3)这样的东西。这种行为总是有保证的吗？我在
浏览 2提问于2012-05-13得票数 5
回答已采纳
1回答
我在Linux服务器上使用Java的文件锁定API，并试图在远程Linux系统上锁定文件。有一些问题已经弹出，日志显示，2不同的集群节点、运行相同Java应用程序的能够两个获得同一个NFS文件的锁。
在线阅读Java如何处理锁和Linux文件锁定(我们通常部署在Windows上，所以很少有经验)，我们所做的应该工作。我们实际上是在发出建议锁，但是由于两个集群节点运行的代码相同，它们正在协作进程，并且在开始执行任何读写操作之前检查锁的获取情况。然而，情况似乎并非如此，这两个系统都能够同时成功地获得文件上的锁。
这些都是已知的问题吗？许多评论/文章在线声明NFS文件锁定是不稳定的，应该避免。为什么
浏览 4提问于2022-08-08得票数 0
回答已采纳
3回答
请帮助我理解如何在多线程Linux应用程序中使用互斥，其中：
在数据写入过程中，需要在写入和读取时锁定变量。
在从变量读取数据时，需要在写时锁定它。
因此，可以同时阅读，但写作操作是一个单一的操作在同一时间。在编写过程中，所有其他操作都应该在完成之前等待。
浏览 2提问于2011-06-27得票数 0
回答已采纳
4回答
CPython使用。Linux已经移除了的所有痕迹。这些锁的替代方案是什么？一个系统如何才能充分利用一个真正的多核或多处理器系统，而不会把一切都搞得一团糟？
浏览 3提问于2011-03-03得票数 6
回答已采纳
1回答
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mx;
void some_function()
{
while(1)
{
std::lock_guard<std::mutex> mx_guard(mx);
std::cout << "some_function()\n";
}
}
void some_other_function()
{
while(1)
{
浏览 0提问于2015-05-25得票数 1
回答已采纳
我有一个多线程应用程序，其中我生成了一些线程，并在完成时执行一个pthread_join。 主线程派生线程，并等待pthread_join()上的工作线程加入。我正面临这样一个问题:主线程在pthread_join()中无限期等待，而所有工作线程都已退出，导致程序挂起。我通过检查gdb上的info thread确定所有工作线程都已退出，因为它只列出了主线程。众所周知，在已退出的线程上调用pthread_join()将立即返回。但这次似乎有所不同。这是gdb堆栈跟踪。 #0 0x00007f45fefebeec in __lll_lock_wait_private () from /lib6
浏览 164提问于2020-01-07得票数 1
2回答
在Linux qt 4.7.4下，使用gcc 4.4.3，以下代码可以很好地编译，并且没有运行时错误。
class TestThread: public QThread {
private:
QReadWriteLock mutex;
public:
bool mStop;
TestThread(): mutex(QReadWriteLock::NonRecursive),mStop(false) {}
void run() {
while(!mStop) {
mutex.lockForRead();
浏览 0提问于2011-12-07得票数 1
3回答
我正在阅读“高级Linux编程”这本书。
可以使用init函数动态初始化互斥：
pthread_mutex_t theMutex;
pthread_mutex_init(&theMutex, NULL);
互斥锁可以通过宏静态初始化
pthread_mutex_t result = PTHREAD_MUTEX_INITIALIZER;
书中说，如果我们动态创建互斥锁，我们必须调用"pthread_mutex_destroy(&theMutex)“，互斥锁将在堆区域创建，因此我们必须手动删除它。
但是，如果我们静态地创建互斥锁，其效果将等同于通过调用pthrea
浏览 1提问于2013-11-28得票数 1
2回答
假设您有两个线程，thread1和thread2。如果您同时调用thread1.start()和thread2.start()，并且它们都打印出1到5之间的数字，那么它们将同时运行，并且会以任意顺序随机打印出这些数字。为了防止出现这种情况，您可以使用.join()方法来确保首先执行某个线程。如果这就是.join()方法的作用，那么Lock对象是用来做什么的呢？
浏览 42提问于2019-05-13得票数 0
1回答
函数可以锁定互斥锁吗？
、、、
我正在为linux内核编写一个内存管理器，它在线程之间共享PID的循环列表(学校项目)。这个程序找到僵尸，并使用1生产者，2消费者模型杀死他们。(强加于我们以便我们能够理解共享内存)。
我想让这个列表成为一个对象，并让函数处理指针的迭代和检查单元格的值。
那么，如果一个线程调用了一个外部函数，那么这个函数可以拥有互斥量吗？还是必须从线程内部完成？
我的想法是完全错误的吗？
非常感谢-Jared
浏览 0提问于2013-02-15得票数 1
回答已采纳
我想在代码中的pthread_cond_wait抽象中添加一些调试代码，以检查调用代码是否真的拥有互斥锁。这是为了检查其余调用者的正确性。
有没有办法检查互斥锁是否被锁定，或者在pthread实现(在Linux上)中启用调试模式来告诉我它是否被锁定？
浏览 1提问于2012-03-01得票数 2
回答已采纳
1回答
我正在尝试在Windows和Linux上锁定数据。
我用来测试的代码看起来像这样：
#include <mutex>
#include <time.h>
#include <iostream>
#include <vector>
#include <thread>
using namespace std;
mutex m;
unsigned long long dd = 0;
void RunTest()
{
for(int i = 0; i < 100000000; i++)
{
浏览 1提问于2014-03-27得票数 0
1回答
我用C编写了一个用户空间应用程序，它使用插件库plugin.so与底层Linux内核驱动程序交互。我使用dlopen()打开DLL。我有一个信号处理程序，在接收到dlclose()时调用SIGINT。在代码检查之后，我得到了反馈意见，即不能从信号处理程序调用dlclose()。若然，为甚麽会这样呢？
浏览 1提问于2013-02-13得票数 1
回答已采纳
2回答
我让两个线程A，B定期更新两个全局传感器读取变量，它们执行相同的例程。第三个线程C将在这些值被更新时立即对它们进行一些计算。我设置了一些条件变量，当A和B都更新了全局变量时，C会立即读取。我担心线程C错过了一些传感器读数，因为它使用循环的轮询是在新的A，B更新之后安排的。我不确定我的担心是不是必要的，因为我是pthread的新手。我的开发环境是嵌入式linux板，目前正在学习pthread。还有比为每个全局变量设置两个条件变量更好的方法吗？
浏览 0提问于2012-04-18得票数 4
3回答
您使用了哪些工具来检测Linux中多线程程序的争用条件。
我使用了工具，它来自于val砂矿，但我注意到它有时会错过比赛条件。
浏览 5提问于2011-11-05得票数 3
回答已采纳
在2010年关于问题的评论中，jilles声称：
glibc强大的互斥量之所以如此之快，是因为glibc采用了危险的捷径。当内核将互斥锁标记为“将导致EOWNERDEAD”时，不能保证互斥锁仍然存在。如果互斥锁被销毁，内存被替换为内存映射文件，该文件恰好在正确的位置包含最后一个拥有线程的ID，并且最后一个拥有线程在写入锁字之后(但在从拥有互斥锁的列表中完全删除互斥锁之前)终止，则该文件将被损坏。Solaris和will-be-FreeBSD9健壮的互斥锁速度较慢，因为它们不想冒这个风险。
我不能理解这种说法，因为销毁互斥是不合法的，除非它是解锁的(因此不在任何线程的健壮列表中)。我也找不到
浏览 8提问于2012-08-14得票数 16
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
