mutex

I'm using Rocket which has a State that it passes to the HTTP requests. This struct contains a Mutex<DatastoreInstance> which gives access to a SQLite database and is locked with a mutex to make read and writes safe. pub struct DatastoreInstance { conn: Connection, } When the DatastoreInstance struct looked like this, with only a SQLite connection everything worked fine, but I then also wanted to add a transaction object within this struct: pub struct DatastoreInstance { conn: Connection, events_transaction: Transaction, } This did not compile because the Transaction object needs to reference

This code demonstrates that the mutex is being shared between two threads, but one thread has it nearly all of the time. #include <thread> #include <mutex> #include <iostream> #include <unistd.h> int main () { std::mutex m; std::thread t ([&] () { while (true) { { std::lock_guard <std::mutex> thread_lock (m); sleep (1); // or whatever } std::cerr << "#"; std::cerr.flush (); } }); while (true) { std::lock_guard <std::mutex> main_lock (m); std::cerr << "."; std::cerr.flush (); } } Compiled with g++ 7.3.0 on Ubuntu 18.04 4.15.0-23-generic. The output is a mix of both # and . characters, showing

MSDN says If the function fails, the return value is WAIT_FAILED. To get extended error information, call GetLastError. The code is: HANDLE m_mutex_handle; /**< m_mutex_handle. The handle to the created mutex. */ m_mutex_handle = ::CreateMutex( 0, false, NULL ); ::WaitForSingleObject( m_mutex_handle, INFINITE ); But what are the reasons that could happen? If you lack the SYNCHRONIZE privilege on the object, then you cannot wait. WAIT_FAILED will be returned. Passing in a bogus object might cause that. Closing a handle while the handle is being waited on can also cause undefined behaviour. I

Unfortunately the cygwin GCC 4.5.3 pthread library implementation doesn't support the POSIX standard function int pthread_mutex_timedlock(pthread_mutex_t* mutex, struct timespec* abstime); Has anyone a good idea how to implement a good workaround for this method in a mutex wrapper class? May be using pthread_mutex_trylock() with a (milliseconds based) nanosleep() call? I don't have a good feeling about the latter idea, but anyway the C++ implementation could look like this: bool MyPosixMutexWrapper::try_lock(const TimeDuration<>& timeout) { if(valid) { if(timeout == TimeDuration<>::Zero) { if

I get surprising and conflicting behavior when I try to run the following code. #include <iostream> #include <mutex> int main() { std::mutex mtx; std::unique_lock<std::mutex> lock1(mtx); std::unique_lock<std::mutex> lock2(mtx, std::try_to_lock); std::cout << "lock1 owns lock: " << lock1.owns_lock() << std::endl; std::cout << "lock2 owns lock: " << lock2.owns_lock() << std::endl; } When I run this on my computer (linux with either clang++ 4.0.1 or g++ 7.3.0) it prints out that both lock1 and lock2 own the lock (surprising). When I run this on cpp.sh it says that lock1 does own, but lock2 does

I have a Windows Forms application that allows only one instance to be running at the time. I have implemented Singleton by using Mutex. The Application must be startable from commandline (with or without parameters). Application is started and exited by script. User can not take any action on it. So, application purpose is simple "indicator" application that will just display some visual and graphical information for the enduser. End user can not do anything with it, just see it. It is windows forms application because then visual and graphical appearance is relatively easy implement (you can