refs #15 @1h

Author: HerbertKoelman

include/pthread/mutex.hpp

@@ -46,14 +46,15 @@ namespace pthread {
         void lock();
 
         /**
-         The function pthread_mutex_trylock is identical to pthread_mutex_lock except tha
-         if the mutex object referenced by mutex is currently locked (by any thread,
-         including the current thread), the call returns immediately.
-
-         @throw mutex_exception if error conditions preventing this method to succeed.
-         @see lock
+         * The function pthread_mutex_trylock is identical to pthread_mutex_lock except that
+         * if the mutex object referenced by mutex is currently locked (by any thread,
+         * including the current thread), the call returns immediately.
+         *
+         * @return
+         * @throw mutex_exception if error conditions preventing this method to succeed.
+         * @see lock
          */
-        void try_lock();
+        bool try_lock();
 
         /**
          The pthread_mutex_unlock function releases the mutex object referenced by mutex.  The manner in which a mutex is released is dependent upon the mutex's type attribute. If there are threads blocked on the mutex object referenced by mutex when unlock is called, resulting in the mutex becoming available, the scheduling policy is used to determine which thread shall acquire the mutex.

src/mutex.cpp

@@ -10,38 +10,41 @@
 
 namespace pthread {
 
-  mutex::mutex () {
-    auto rc = pthread_mutex_init (&_mutex, NULL);
-    if ( rc != 0 ) {
-      throw mutex_exception ( "In constructor of mutex pthread_mutex_init(&mutex, NULL) failed. ", rc );
+    mutex::mutex() {
+        auto rc = pthread_mutex_init(&_mutex, NULL);
+        if (rc != 0) {
+            throw mutex_exception("In constructor of mutex pthread_mutex_init(&mutex, NULL) failed. ", rc);
+        }
     }
-  }
 
-  mutex::~mutex () {
-    pthread_mutex_destroy (&_mutex);
-  }
+    mutex::~mutex() {
+        pthread_mutex_destroy(&_mutex);
+    }
 
-  void mutex::lock () {
-    int rc = -1;
-    rc = pthread_mutex_lock ( &_mutex );
-    if ( rc != 0 ){
-      throw mutex_exception("pthread_mutex_lock failed.", rc);
+    void mutex::lock() {
+        int rc = -1;
+        rc = pthread_mutex_lock(&_mutex);
+        if (rc != 0) {
+            throw mutex_exception("pthread_mutex_lock failed.", rc);
+        }
     }
-  }
 
-  void mutex::try_lock () {
+    bool mutex::try_lock() {
+        bool status = false;
 
-    auto rc = pthread_mutex_trylock ( &_mutex );
-    if ( rc != 0 ){
-      throw mutex_exception("pthread_mutex_trylock failed, already locked.", rc);
+        auto rc = pthread_mutex_trylock(&_mutex);
+        if (rc == 0) {
+            status = true;
+        } else {
+            throw mutex_exception("pthread_mutex_trylock failed, already locked.", rc);
+        }
     }
-  }
 
-  void mutex::unlock () {
-    auto rc = pthread_mutex_unlock ( &_mutex );
-    if ( rc != 0 ){
-      throw mutex_exception("pthread_mutex_unlock failed.", rc);
+    void mutex::unlock() {
+        auto rc = pthread_mutex_unlock(&_mutex);
+        if (rc != 0) {
+            throw mutex_exception("pthread_mutex_unlock failed.", rc);
+        }
     }
-  }
 
 }

tests/concurrency_tests.cpp

@@ -18,8 +18,6 @@ TEST(concurrency, mutex) {
   try {
     pthread::lock_guard<pthread::mutex> lock(mutex);
     success = true;
-    // std::cout << "in critical section (mutex)" << std::endl;
-
   } catch ( std::exception &err) {
     std::cerr << "something went wrong: " << err.what() << std::endl;
   }catch ( ... ){
@@ -54,4 +52,49 @@ TEST(concurrency, read_write_lock) {
   }
 
   EXPECT_TRUE(success);
-}
+}
+
+TEST(concurrency, condition_variable_wait_for){
+    pthread::condition_variable condition;
+    pthread::mutex              mutex;
+
+    EXPECT_EQ(pthread::cv_status::timedout, condition.wait_for(mutex, 1*1000));
+    EXPECT_THROW(mutex.try_lock(), pthread::pthread_exception);
+    mutex.unlock();
+
+    {
+        pthread::lock_guard<pthread::mutex> lock{mutex};
+        EXPECT_EQ(pthread::cv_status::timedout, condition.wait_for(lock, 1 * 1000));
+    }
+    EXPECT_NO_THROW(mutex.try_lock());
+}
+
+/* NOSONAR for later use
+   class test_thread: public pthread::abstract_thread{
+    public:
+        void run() noexcept override{
+            pthread::this_thread::sleep_for(5*1000);
+            std::cout << "thread is waiting for mutex" << std::endl;
+            pthread::lock_guard<pthread::mutex> lock(*_mutex);
+            std::cout << "thread got mutex" << std::endl;
+        }
+
+        test_thread( pthread::mutex *mutex): _mutex(mutex){
+
+        }
+    private:
+        pthread::mutex *_mutex;
+    };
+
+    pthread::mutex mutex;
+
+    test_thread thread{&mutex};
+    thread.start();
+    {
+        pthread::lock_guard<pthread::mutex> lock(mutex);
+        pthread::this_thread::sleep_for(10*1000);
+    }
+
+    thread.join();
+
+ */