Articles of 互斥

为什么Nginx默认使用“accept_mutex”?

我发现'accept_mutex'在Nginx中默认为'on',如下所示: http://wiki.nginx.org/EventsModule 那么接受连接是否需要互斥? 为什么?

如何在一个线程上花费比互斥体更长的时间?

我试图测量一个线程唤醒睡眠线程时的延迟。 由于据说许多同步前体是在futex之上开发的,我期望futex总是更快。 但是,我的testing结果是相反的。 我想知道我做错了什么,或者它实际上是一个事实。 这是我testing的细节: 进程已经被设置为一个特定的核心 时间由RDTSC()指令返回的数字进行比较 创build2个线程,其中醒来的线程2具有较高的FIFO优先级 线程1通过解锁互斥体来发送信号,所以线程2应该在下一个时间表中唤醒。 thread1上的sleep(1)是为了确保在调用mutex_unlock的时候thread2正在等待互斥量。 void *Thread1(void *dummy) { while(1) { pthread_mutex_lock( &mutx ); sleep(1); t1 = rdtsc(); pthread_mutex_unlock( &mutx ); pthread_yield(); } return NULL; } void *Thread2(void *dummy) { while(1) { pthread_mutex_lock( &mutx ); t2 = rdtsc(); if(t1>0) { // print out the result cout << t2-t1 << endl; […]

当一个线程locking一个大地图时如何避免冻结其他线程

如何避免冻结其他线程试图访问当前线程正在locking的地图? 见下面的代码: //pseudo code std::map<string, CSomeClass* > gBigMap; void AccessMapForWriting(string aString){ pthread_mutex_lock(&MapLock); CSomeClass* obj = gBigMap[aString]; if (obj){ gBigMap.erase(aString); delete obj; obj = NULL; } pthread_mutex_unlock(&MapLock); } void AccessMapForReading(string aString){ pthread_mutex_lock(&MapLock); CSomeClass* obj = gBigMap[aString]; //below code consumes much time //sometimes it even sleeps for milliseconds if (obj){ obj->TimeConsumingOperation(); } pthread_mutex_unlock(&MapLock); } //other threads will […]

等待线程/ s直到onther线程/ s结束c ++ linux操作系统

我有三个函数在我的项目用c ++编写,在同一个.cpp文件中,我有两个.h文件。 现在,我有三个对应的线程,第二个线程从第一个线程获取输出,最后一个线程等待,直到第二个线程结束其操作。注意线程在“永久循环”中使用iewhile(1) {} …. //source.cpp看起来像这样: #include <iostream> #include "source.h" #include "glob_variables.h" #include "armadillo" #include <vector> using namespace arma; using namespace std; void source::first_function(int size) { for(int i=0;i<size;i++) { container.push_back(i);//container is global variable vector of type int declared in glob_variables.h } } //~~~~~~~~~~~~~~~~~~~~~~ void source::second_function() { //sleep until the first function fills the the vector […]

我们是否确实需要与“PTHREAD_MUTEX_ROBUST”相反的属性“PTHREAD_MUTEX_STALLED”的互斥锁?

我正在阅读APUE第12章(第三版),它说:我们可以设置PTHREAD_MUTEX_STALLED或PTHREAD_MUTEX_ROBUST到互斥量。 但是我不认为我们需要使用属性PTHREAD_MUTEX_STALLED互斥,互斥量应该总是“健壮的”,这样我们才能被通知,如果locking互斥量的那一边是死的。 如果互斥体“停滞”,我们将永远悬浮。 而且我知道Windows的互斥体总是“健壮”,如果locking互斥体的那一面死了,我们将会收到错误WAIT_ABANDONED通知。 那么,在什么样的情况下,我们不得不使用“停滞”的互斥体,而不是“健壮的”互斥体呢? 感谢您的关注。

线程退出但仍保持互斥

一个持有互斥体的线程死亡。 另一个线程在调用“pthread_mutex_lock”时会死锁,尽pipe我使用了“PTHREAD_MUTEX_ERRORCHECK”属性。 #include <pthread.h> #include <iostream> #include <unistd.h> using namespace std; pthread_mutex_t mutex; void *handler(void *) { cout << "child thread" << endl; int ret = pthread_mutex_lock(&mutex); cout << "child ret: " << ret << endl; pthread_exit(NULL); } int main() { pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK); pthread_mutex_init(&mutex, &attr); pthread_mutexattr_destroy(&attr); pthread_t tid; pthread_create(&tid, NULL, handler, NULL); […]

我可以在不同的方法中使用相同的互斥体吗?

情况:我有两种方法: method1加载config的值; method2返回加载configuration的值。 这两种方法可能被不同的线程调用。 问题:我想使用一个互斥锁来locking/解锁两个方法。 所以当method1被locking时 ,当method2被调用时,它也应该被locking 。 当我读到互斥体时,我感到困惑,当他们说我locking代码的区域,直到解锁被调用。 问题:当我locking方法1时,我是否也locking方法2? 期望:我想要发生的是当方法1正在更新将由方法2返回的configuration数据时调用方法2。 示例代码: void Class::method1() { pthread_mutex_lock(mutex1); string1 = "a value"; pthread_mutex_unlock(mutex1); }; void Class::method2(string& aString) { pthread_mutex_lock(mutex1); aString = string1; pthread_mutex_unlock(mutex1); return; };

分段错误(core dumped)错误信息

#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <pthread.h> #include <semaphore.h> pthread_mutex_t mutex_lock; /* semaphore declarations */ sem_t students_sem; /* ta waits for a student to show up, student notifies ta his/her arrival */ sem_t ta_sem; /* students waits for ta to help, ta notifies student he/she is ready to help */ /* the number of […]

在Linux中的跨进程locking

我期待在Linux中创build一个应用程序,一次只能运行一个应用程序实例。 我想使它健壮,如果应用程序的一个实例崩溃,它不会无限期地阻止所有其他实例。 我真的很感激一些示例代码如何做到这一点(因为在网上有很多关于这个话题的讨论,但是当我尝试的时候我找不到任何有用的东西)。

如果在获得互斥锁之后发生中断,会发生什么情况

我有一个multithreading的C / C ++程序,非常频繁地为读取和写入请求提供服务。 为了同步的目的,我使用了一个互斥锁来解锁。 所有读取和写入线程在执行操作之前都会获得locking。 如果一个线程获取locking,并且在释放locking之前发生中断,会发生什么? 该线程恢复执行,否则我将不得不手动处理它?