From: Vadim Zeitlin <vadim@wxwidgets.org>
Date: Sun, 8 Apr 2001 22:49:09 +0000 (+0000)
Subject: made mutexes recursive under Unix as well as under Win32
X-Git-Url: https://git.saurik.com/wxWidgets.git/commitdiff_plain/7a56de34aba1bfe923f133986a0ca88fcbdd77e0

made mutexes recursive under Unix as well as under Win32


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@9683 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
---

diff --git a/docs/latex/wx/mutex.tex b/docs/latex/wx/mutex.tex
index 4864ec96e0..348ae108c4 100644
--- a/docs/latex/wx/mutex.tex
+++ b/docs/latex/wx/mutex.tex
@@ -3,7 +3,11 @@
 A mutex object is a synchronization object whose state is set to signaled when
 it is not owned by any thread, and nonsignaled when it is owned. Its name comes
 from its usefulness in coordinating mutually-exclusive access to a shared
-resource. Only one thread at a time can own a mutex object.
+resource. Only one thread at a time can own a mutex object but the mutexes are
+recursive in the sense that a thread can lock a mutex which it had already
+locked before (instead of dead locking the entire process in this situation by
+starting to wait on a mutex which will never be released while the thread is
+waiting).
 
 For example, when several thread use the data stored in the linked list,
 modifications to the list should be only allowed to one thread at a time
@@ -55,7 +59,7 @@ Notice how wxMutexLocker was used in the second function to ensure that the
 mutex is unlocked in any case: whether the function returns TRUE or FALSE
 (because the destructor of the local object {\it lock} is always called). Using
 this class instead of directly using wxMutex is, in general safer and is even
-more so if yoor program uses C++ exceptions.
+more so if your program uses C++ exceptions.
 
 \wxheading{Derived from}
 
diff --git a/src/unix/threadpsx.cpp b/src/unix/threadpsx.cpp
index f0a19482a0..a56b6f751c 100644
--- a/src/unix/threadpsx.cpp
+++ b/src/unix/threadpsx.cpp
@@ -164,8 +164,13 @@ wxMutex::wxMutex()
 {
     m_internal = new wxMutexInternal;
 
-    pthread_mutex_init(&(m_internal->m_mutex),
-                       (pthread_mutexattr_t*) NULL );
+    // support recursive locks like Win32, i.e. a thread can lock a mutex which
+    // it had itself already locked
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+    pthread_mutex_init(&(m_internal->m_mutex), &attr);
+
     m_locked = 0;
 }