mutex

Author: 埃博拉酱

.vscode/settings.json

@@ -100,6 +100,7 @@
 		"concepts": "cpp",
 		"numbers": "cpp",
 		"format": "cpp",
-		"variant": "cpp"
+		"variant": "cpp",
+		"mutex": "cpp"
 	}
 }

examples/Mutex/Mutex.ino

@@ -0,0 +1,16 @@
+#include <Cpp_Standard_Library.h>
+#include <mutex>
+void setup() {
+  Serial.begin(9600);
+  std::mutex Mutex;
+  std::lock_guard LockGuard{ Mutex };
+
+  Serial.println("已锁定");
+
+  Serial.flush();
+  /*
+	此调用永远不会返回，也永远不会输出上面写的文字，因为上了锁之后无法中断，串口缓存依赖中断输出，无法中断就永远无法输出，卡死在这里。
+	反之，如果注释掉这一行，反而能输出文字，因为此函数结束后会解锁，串口缓存得以输出。
+	*/
+}
+void loop() {}

src/bits/gthr.cpp

@@ -0,0 +1,2 @@
+#include<bits/gthr.h>
+std::unordered_set<__gthread_mutex_t*> _CSL_MutexSet;

src/bits/gthr.h

@@ -1,5 +1,5 @@
 #pragma once
-#ifdef ARDUINO_ARCH_AVR
+// 此文件为架构特定，由埃博拉酱手动实现
 /* Threads compatibility routines for libgcc2 and libobjc.  */
 /* Compile this one with gcc.  */
 /* Copyright (C) 1997-2024 Free Software Foundation, Inc.
@@ -28,6 +28,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #ifndef GCC_GTHR_SINGLE_H
 #define GCC_GTHR_SINGLE_H
 
+#include <unordered_set>
+#include <cerrno>
+#include <Arduino.h>
+
 /* Just provide compatibility for mutex handling.  */
 
 typedef int __gthread_key_t;
@@ -37,7 +41,10 @@ typedef int __gthread_recursive_mutex_t;
 
 #define __GTHREAD_ONCE_INIT 0
 #define __GTHREAD_MUTEX_INIT 0
-#define __GTHREAD_MUTEX_INIT_FUNCTION(mx) do {} while (0)
+#define __GTHREAD_MUTEX_INIT_FUNCTION(mx) \
+  do                                      \
+  {                                       \
+  } while (0)
 #define __GTHREAD_RECURSIVE_MUTEX_INIT 0
 
 #define UNUSED __attribute__((__unused__))
@@ -51,15 +58,15 @@ static void *thread_local_storage = NULL;
 
 /* Initialize the threads subsystem.  */
 static inline int
-__gthread_objc_init_thread_system (void)
+__gthread_objc_init_thread_system(void)
 {
   /* No thread support available */
   return -1;
 }
 
 /* Close the threads subsystem.  */
 static inline int
-__gthread_objc_close_thread_system (void)
+__gthread_objc_close_thread_system(void)
 {
   /* No thread support available */
   return -1;
@@ -69,37 +76,37 @@ __gthread_objc_close_thread_system (void)
 
 /* Create a new thread of execution.  */
 static inline objc_thread_t
-__gthread_objc_thread_detach (void (* func)(void *), void * arg UNUSED)
+__gthread_objc_thread_detach(void (*func)(void *), void *arg UNUSED)
 {
   /* No thread support available */
   return NULL;
 }
 
 /* Set the current thread's priority.  */
 static inline int
-__gthread_objc_thread_set_priority (int priority UNUSED)
+__gthread_objc_thread_set_priority(int priority UNUSED)
 {
   /* No thread support available */
   return -1;
 }
 
 /* Return the current thread's priority.  */
 static inline int
-__gthread_objc_thread_get_priority (void)
+__gthread_objc_thread_get_priority(void)
 {
   return OBJC_THREAD_INTERACTIVE_PRIORITY;
 }
 
 /* Yield our process time to another thread.  */
 static inline void
-__gthread_objc_thread_yield (void)
+__gthread_objc_thread_yield(void)
 {
   return;
 }
 
 /* Terminate the current thread.  */
 static inline int
-__gthread_objc_thread_exit (void)
+__gthread_objc_thread_exit(void)
 {
   /* No thread support available */
   /* Should we really exit the program */
@@ -109,23 +116,23 @@ __gthread_objc_thread_exit (void)
 
 /* Returns an integer value which uniquely describes a thread.  */
 static inline objc_thread_t
-__gthread_objc_thread_id (void)
+__gthread_objc_thread_id(void)
 {
   /* No thread support, use 1.  */
-  return (objc_thread_t) 1;
+  return (objc_thread_t)1;
 }
 
 /* Sets the thread's local storage pointer.  */
 static inline int
-__gthread_objc_thread_set_data (void *value)
+__gthread_objc_thread_set_data(void *value)
 {
   thread_local_storage = value;
   return 0;
 }
 
 /* Returns the thread's local storage pointer.  */
 static inline void *
-__gthread_objc_thread_get_data (void)
+__gthread_objc_thread_get_data(void)
 {
   return thread_local_storage;
 }
@@ -134,37 +141,37 @@ __gthread_objc_thread_get_data (void)
 
 /* Allocate a mutex.  */
 static inline int
-__gthread_objc_mutex_allocate (objc_mutex_t mutex UNUSED)
+__gthread_objc_mutex_allocate(objc_mutex_t mutex UNUSED)
 {
   return 0;
 }
 
 /* Deallocate a mutex.  */
 static inline int
-__gthread_objc_mutex_deallocate (objc_mutex_t mutex UNUSED)
+__gthread_objc_mutex_deallocate(objc_mutex_t mutex UNUSED)
 {
   return 0;
 }
 
 /* Grab a lock on a mutex.  */
 static inline int
-__gthread_objc_mutex_lock (objc_mutex_t mutex UNUSED)
+__gthread_objc_mutex_lock(objc_mutex_t mutex UNUSED)
 {
   /* There can only be one thread, so we always get the lock */
   return 0;
 }
 
 /* Try to grab a lock on a mutex.  */
 static inline int
-__gthread_objc_mutex_trylock (objc_mutex_t mutex UNUSED)
+__gthread_objc_mutex_trylock(objc_mutex_t mutex UNUSED)
 {
   /* There can only be one thread, so we always get the lock */
   return 0;
 }
 
 /* Unlock the mutex */
 static inline int
-__gthread_objc_mutex_unlock (objc_mutex_t mutex UNUSED)
+__gthread_objc_mutex_unlock(objc_mutex_t mutex UNUSED)
 {
   return 0;
 }
@@ -173,131 +180,136 @@ __gthread_objc_mutex_unlock (objc_mutex_t mutex UNUSED)
 
 /* Allocate a condition.  */
 static inline int
-__gthread_objc_condition_allocate (objc_condition_t condition UNUSED)
+__gthread_objc_condition_allocate(objc_condition_t condition UNUSED)
 {
   return 0;
 }
 
 /* Deallocate a condition.  */
 static inline int
-__gthread_objc_condition_deallocate (objc_condition_t condition UNUSED)
+__gthread_objc_condition_deallocate(objc_condition_t condition UNUSED)
 {
   return 0;
 }
 
 /* Wait on the condition */
 static inline int
-__gthread_objc_condition_wait (objc_condition_t condition UNUSED,
-			       objc_mutex_t mutex UNUSED)
+__gthread_objc_condition_wait(objc_condition_t condition UNUSED,
+                              objc_mutex_t mutex UNUSED)
 {
   return 0;
 }
 
 /* Wake up all threads waiting on this condition.  */
 static inline int
-__gthread_objc_condition_broadcast (objc_condition_t condition UNUSED)
+__gthread_objc_condition_broadcast(objc_condition_t condition UNUSED)
 {
   return 0;
 }
 
 /* Wake up one thread waiting on this condition.  */
 static inline int
-__gthread_objc_condition_signal (objc_condition_t condition UNUSED)
+__gthread_objc_condition_signal(objc_condition_t condition UNUSED)
 {
   return 0;
 }
 
 #else /* _LIBOBJC */
 
 static inline int
-__gthread_active_p (void)
+__gthread_active_p(void)
 {
   return 0;
 }
 
 static inline int
-__gthread_once (__gthread_once_t *__once UNUSED, void (*__func) (void) UNUSED)
+__gthread_once(__gthread_once_t *__once UNUSED, void (*__func)(void) UNUSED)
 {
   return 0;
 }
 
 static inline int UNUSED
-__gthread_key_create (__gthread_key_t *__key UNUSED, void (*__func) (void *) UNUSED)
+__gthread_key_create(__gthread_key_t *__key UNUSED, void (*__func)(void *) UNUSED)
 {
   return 0;
 }
 
 static int UNUSED
-__gthread_key_delete (__gthread_key_t __key UNUSED)
+__gthread_key_delete(__gthread_key_t __key UNUSED)
 {
   return 0;
 }
 
 static inline void *
-__gthread_getspecific (__gthread_key_t __key UNUSED)
+__gthread_getspecific(__gthread_key_t __key UNUSED)
 {
   return 0;
 }
 
 static inline int
-__gthread_setspecific (__gthread_key_t __key UNUSED, const void *__v UNUSED)
+__gthread_setspecific(__gthread_key_t __key UNUSED, const void *__v UNUSED)
 {
   return 0;
 }
 
 static inline int
-__gthread_mutex_destroy (__gthread_mutex_t *__mutex UNUSED)
+__gthread_mutex_destroy(__gthread_mutex_t *__mutex UNUSED)
 {
   return 0;
 }
-
+extern std::unordered_set<__gthread_mutex_t *> _CSL_MutexSet;
 static inline int
-__gthread_mutex_lock (__gthread_mutex_t *__mutex UNUSED)
+__gthread_mutex_lock(__gthread_mutex_t *__mutex)
 {
-  return 0;
+  if (_CSL_MutexSet.contains(__mutex))
+    return EBUSY;
+  else
+  {
+    if (_CSL_MutexSet.empty())
+      noInterrupts();
+    _CSL_MutexSet.insert(__mutex);
+    return 0;
+  }
 }
 
 static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *__mutex UNUSED)
+__gthread_mutex_trylock(__gthread_mutex_t *__mutex UNUSED)
 {
   return 0;
 }
 
 static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *__mutex UNUSED)
+__gthread_mutex_unlock(__gthread_mutex_t *__mutex UNUSED)
 {
   return 0;
 }
 
 static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
+__gthread_recursive_mutex_lock(__gthread_recursive_mutex_t *__mutex)
 {
-  return __gthread_mutex_lock (__mutex);
+  return __gthread_mutex_lock(__mutex);
 }
 
 static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
+__gthread_recursive_mutex_trylock(__gthread_recursive_mutex_t *__mutex)
 {
-  return __gthread_mutex_trylock (__mutex);
+  return __gthread_mutex_trylock(__mutex);
 }
 
 static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
+__gthread_recursive_mutex_unlock(__gthread_recursive_mutex_t *__mutex)
 {
-  return __gthread_mutex_unlock (__mutex);
+  return __gthread_mutex_unlock(__mutex);
 }
 
 static inline int
-__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
+__gthread_recursive_mutex_destroy(__gthread_recursive_mutex_t *__mutex)
 {
-  return __gthread_mutex_destroy (__mutex);
+  return __gthread_mutex_destroy(__mutex);
 }
 
 #endif /* _LIBOBJC */
 
 #undef UNUSED
 
-#endif /* ! GCC_GTHR_SINGLE_H */
-#else
-#include_next <bits/gthr.h>
-#endif
+#endif /* ! GCC_GTHR_SINGLE_H */