Implement 'std::mutex'

Author: Ttimofeyka

specifications/std/thread.md

@@ -131,4 +131,62 @@ void main {
 
     // data == 8
 }
-```
+```
+
+## std::mutex
+
+Blocking mutex implementation that uses kernel-level synchronization primitives:
+- On Unix: uses pthread mutex (futex-based blocking)
+- On Windows: uses CRITICAL_SECTION
+
+This is more efficient than spinlock for longer-held locks, as waiting threads are put to sleep instead of spinning.
+
+### lock
+
+Acquires the mutex, blocking if it's already held by another thread.
+
+### unlock
+
+Releases the mutex, allowing other waiting threads to acquire it.
+
+### trylock
+
+Attempts to acquire the mutex without blocking. Returns 0 on success, non-zero if the mutex is already locked.
+
+### destroy
+
+Destroys the mutex and releases associated resources. Should be called when the mutex is no longer needed.
+
+Example:
+
+```d
+import <std/io> <std/thread>
+
+int counter = 0;
+std::mutex mtx;
+
+int increment(char* arg) {
+    for (int i=0; i<10000; i++) {
+        mtx.lock();
+        counter += 1;
+        mtx.unlock();
+    }
+}
+
+void main {
+    std::thread t1 = std::thread();
+    std::thread t2 = std::thread();
+    std::thread t3 = std::thread();
+
+    t1.run(increment, null);
+    t2.run(increment, null);
+    t3.run(increment, null);
+
+    t1.join();
+    t2.join();
+    t3.join();
+
+    mtx.destroy();
+
+    std::println("Counter: ", counter);
+}

std/pthread.rave

@@ -11,6 +11,10 @@ with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
             int __align;
         }
 
+        struct mutexattr {
+            char[40] __data;
+        }
+
         struct mutex {
             char[40] __data;
         }
@@ -24,6 +28,10 @@ with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
             int __align;
         }
 
+        struct mutexattr {
+            char[24] __data;
+        }
+
         struct mutex {
             char[24] __data;
         }
@@ -37,4 +45,11 @@ namespace pthread {
     extern(linkname: "pthread_exit") void exit(char* retVal);
     extern(linkname: "pthread_cancel") int cancel(ulong thread);
     extern(linkname: "pthread_detach") int detach(ulong thread);
+
+    // Mutex functions
+    extern(linkname: "pthread_mutex_init") int mutex_init(pthread::mutex* mutex, pthread::mutexattr* attr);
+    extern(linkname: "pthread_mutex_lock") int mutex_lock(pthread::mutex* mutex);
+    extern(linkname: "pthread_mutex_unlock") int mutex_unlock(pthread::mutex* mutex);
+    extern(linkname: "pthread_mutex_destroy") int mutex_destroy(pthread::mutex* mutex);
+    extern(linkname: "pthread_mutex_trylock") int mutex_trylock(pthread::mutex* mutex);
 }

std/thread.rave

@@ -104,4 +104,59 @@ namespace std {
 
         (inline) void unlock => std::thread::spinlock::unlock(this.&value);
     }
+}
+
+// Blocking mutex implementation (not spinning)
+@if (__RAVE_OS != "WINDOWS") {
+    namespace std {
+        struct mutex {
+            pthread::mutex __mutex;
+
+            std::mutex this {
+                pthread::mutex_init(return.&__mutex, cast(pthread::mutexattr*)null);
+            }
+
+            (inline) void lock => pthread::mutex_lock(this.&__mutex);
+
+            (inline) void unlock => pthread::mutex_unlock(this.&__mutex);
+
+            (inline) int trylock => pthread::mutex_trylock(this.&__mutex);
+
+            (inline) void destroy => pthread::mutex_destroy(this.&__mutex);
+        }
+    }
+}
+@else {
+    namespace std {
+        // Windows CRITICAL_SECTION provides blocking mutex
+        namespace thread {
+            extern(linkname: "InitializeCriticalSection") void __InitCriticalSection(char* cs);
+            extern(linkname: "EnterCriticalSection") void __EnterCriticalSection(char* cs);
+            extern(linkname: "LeaveCriticalSection") void __LeaveCriticalSection(char* cs);
+            extern(linkname: "DeleteCriticalSection") void __DeleteCriticalSection(char* cs);
+            extern(linkname: "TryEnterCriticalSection") int __TryEnterCriticalSection(char* cs);
+        }
+
+        struct mutex {
+            // CRITICAL_SECTION structure size (platform-dependent)
+            @if (__RAVE_PLATFORM == "X86_64") {
+                char[40] __cs;
+            }
+            @else {
+                char[24] __cs;
+            }
+
+            std::mutex this {
+                std::thread::__InitCriticalSection(return.&__cs);
+            }
+
+            (inline) void lock => std::thread::__EnterCriticalSection(this.&__cs);
+
+            (inline) void unlock => std::thread::__LeaveCriticalSection(this.&__cs);
+
+            (inline) int trylock => std::thread::__TryEnterCriticalSection(this.&__cs);
+
+            (inline) void destroy => std::thread::__DeleteCriticalSection(this.&__cs);
+        }
+    }
 }