性能如何std::mutex相比CRITICAL_SECTION？它是否相提并论？
我需要轻量级同步对象(不需要是一个进程间对象)是否有任何接近CRITICAL_SECTION其他的STL类std::mutex？
我在基于linux的(arm)通信应用程序中在不可预测的时间遇到以下错误:
pthread_mutex_lock.c:82: __pthread_mutex_lock: Assertion `mutex->__data.__owner == 0' failed.
谷歌出现了很多关于这个错误的引用,但很少有与我的情况相关的信息.我想知道是否有人可以给我一些关于如何解决此错误的想法.有谁知道这个断言的常见原因？
提前致谢.
我在c#的线程中有点新,在一般情况下,在我的程序中我mutex只允许1个线程进入一个关键部分并且由于未知的原因做了一些cw打印我可以看到超过1个线程进入我的内部关键部分,这是我的代码:
Mutex m = new Mutex();
m.WaitOne();
<C.S> // critical section here
m.ReleaseMutex();
我非常想知道我是否在这里犯了一个错误,在此先感谢您的帮助.
编辑:
我的代码包括类,所以它基本上看起来像这样:
public class test
{
private mutex m;
public test()
{
m = new mutex();
}
public func()
{
m.WaitOne();
<C.S> // critical section here
m.ReleaseMutex();
}
}
我正在尝试使C++ API(对于Linux和Solaris)具有线程安全性,以便可以从不同的线程调用其函数,而不会破坏内部数据结构.在我目前的方法中,我使用pthread互斥锁来保护对成员变量的所有访问.这意味着一个简单的getter函数现在可以锁定和解锁互斥锁,我担心这会产生开销,特别是因为API主要用于单线程应用程序,其中任何互斥锁定看起来都是纯粹的开销.
所以,我想问一下:
我在Jenkins有一些工作,使用Selenium通过网站的前端修改数据库.如果其中一些作业同时运行,则可能导致由于脏读而导致的错误.有没有办法迫使詹金斯的某些工作无法同时运行？我宁愿不必在数据库上放置或取锁,任何数量的用户也可以读取或修改锁定.
我最近实现线程/互斥管理器的努力最终导致75%的CPU负载(4核心),而所有四个正在运行的线程都处于睡眠状态或等待互斥锁解锁.
具体的类太大了,不能完全发布在这里,但我可以把原因缩小到两个互斥锁的死锁安全获取
std::unique_lock<std::mutex> lock1( mutex1, std::defer_lock );
std::unique_lock<std::mutex> lock2( mutex2, std::defer_lock );
std::lock( lock1, lock2 );
该类的另一部分使用std::condition_variablewith wait()和notify_one()on mutex1来同时有选择地执行某些代码.
简单的改变
std::unique_lock<std::mutex> lock1( mutex1 );
std::unique_lock<std::mutex> lock2( mutex2 );
使CPU使用率降至正常的1-2%.
我不敢相信,std::lock()功能是低效的.这可能是g ++ 4.6.3中的错误吗？
编辑:(示例)
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
std::mutex mutex1, mutex2;
std::condition_variable cond_var;
bool cond = false;
std::atomic<bool>done{false};
using namespace std::chrono_literals;
void Take_Locks()
{
while( !done )
{
std::this_thread::sleep_for( 1s );
std::unique_lock<std::mutex> lock1( mutex1, std::defer_lock …我是多线程/流程编程的新手.所以这就是我需要澄清的内容.
处理代码
pthread_mutex_lock()
pthread_create(fooAPI(sharedResource)) //fooAPI creates another thread with shared resource that shares across processes.
pthread_mutex_unlock()
使用上面的伪代码,sharedResource如果未解锁互斥锁,进程B是否能够访问？
如何正确访问进程B中的sharedResource？
有没有明确的可视图解释互斥体,线程和进程之间的关系？
future和之间有什么区别shared_future？
在什么情况下我们必须使用shared_future而不是future？
我试图找到与C++ 11的这两个功能形成鲜明对比的好文档,而我在网上找不到答案(至少容易/可读).
这是我目前对差异的理解
future对象只能被查询一次get().shared_future 可以被查询任何次数.用例:如果多个线程依赖于异步任务的结果,那么我们必须使用shared_future.如果需要在同一个线程中多次查询将来的对象,那么我们必须shared_future改为使用.
欢迎提供更多信息,陷阱或一般指导方针......
我应该何时更喜欢第一段代码到第二段,并且它们有根本区别
std::mutex mtx;
mtx.lock();
... //protected stuff
mtx.unlock();
... //non-protected stuff
mtx.lock();
... //etc
和
std::mutex mtx;
std::unique_lock<std::mutex> lck(mtx);
... //protected stuff
lck.unlock();
... //non-protected stuff
lck.lock();
... //etc
我知道lock_guard基本上是一个没有锁定和解锁功能的unique_lock,但是我很难用互斥锁来区分互斥锁和锁.
根据C++参考定义:
阻塞当前线程,直到标识的线程
*this完成其执行.
这是否意味着在使用时.join(),没有必要mutex.lock()在该线程调用某些函数时？我是新的互斥和线程,所以我有点困惑.
注意:我找到了一本书C++ Concurrency in Action,我正在读这本书.这对于像我这样的多线程初学者来说非常好.
谢谢大家的帮助.