nodegit
diff --git a/‎generate/templates/manual/include/nodegit.h‎
Lines changed: 4 additions & 1 deletion b/‎generate/templates/manual/include/nodegit.h‎
Lines changed: 4 additions & 1 deletion
diff --git a/‎generate/templates/templates/nodegit.cc‎
Lines changed: 39 additions & 5 deletions b/‎generate/templates/templates/nodegit.cc‎
Lines changed: 39 additions & 5 deletions
@@ -4,11 +4,12 @@
 #include <set>
 #include <vector>
 #include <uv.h>
+#include <memory>
 
 class LockMaster {
 
   std::set<const void *> objects_to_lock;
-  std::vector<uv_mutex_t *> object_mutexes;
+  std::vector<std::shared_ptr<uv_mutex_t> > object_mutexes;
 
   template<typename T>
   void AddLocks(const T *t) {
@@ -36,6 +37,7 @@ class LockMaster {
   void Unregister();
   void Lock();
   void Unlock();
+  void CleanupMutexes();
 
 public:
 
@@ -53,6 +55,7 @@ class LockMaster {
   {
     Unregister();
     Unlock();
+    CleanupMutexes();
   }
 
   class TemporaryUnlock
 
@@ -6,6 +6,7 @@
 #include <map>
 #include <algorithm>
 #include <set>
+#include <memory>
 
 #include "../include/nodegit.h"
 #include "../include/wrapper.h"
@@ -16,9 +17,30 @@
   {% endif %}
 {% endeach %}
 
-std::map<const void *, uv_mutex_t *> mutexes;
+std::map<const void *, std::shared_ptr<uv_mutex_t>> mutexes;
 uv_mutex_t map_mutex;
 uv_key_t current_lock_master_key;
+uv_async_t cleanup_mutexes_handle;
+
+void cleanup_mutexes(uv_async_t *async) {
+  uv_mutex_lock(&map_mutex);
+
+  for(std::map<const void *, std::shared_ptr<uv_mutex_t> >::iterator it=mutexes.begin(); it != mutexes.end(); )
+  {
+    std::shared_ptr<uv_mutex_t> &mutex = it->second;
+    // if the mutex is only referenced by the mutexes map,
+    // we can destroy it (because any LockMaster that is using the mutex would
+    // hold it in its object_mutexes)
+    if (mutex.unique()) {
+      uv_mutex_destroy(mutex.get());
+      it = mutexes.erase(it);
+    } else {
+      it++;
+    }
+  }
+
+  uv_mutex_unlock(&map_mutex);
+}
 
 extern "C" void init(Local<v8::Object> target) {
   // Initialize libgit2.
@@ -35,6 +57,7 @@ extern "C" void init(Local<v8::Object> target) {
 
   uv_mutex_init(&map_mutex);
   uv_key_create(&current_lock_master_key);
+  uv_async_init(uv_default_loop(), &cleanup_mutexes_handle, cleanup_mutexes);
 }
 
 void LockMaster::GetMutexes()
@@ -46,8 +69,8 @@ void LockMaster::GetMutexes()
     if(object) {
       // ensure we have an initialized mutex for each object
       if(!mutexes[object]) {
-        mutexes[object] = (uv_mutex_t *)malloc(sizeof(uv_mutex_t));
-        uv_mutex_init(mutexes[object]);
+        mutexes[object] = std::shared_ptr<uv_mutex_t>((uv_mutex_t *)malloc(sizeof(uv_mutex_t)));
+        uv_mutex_init(mutexes[object].get());
       }
 
       object_mutexes.push_back(mutexes[object]);
@@ -72,12 +95,23 @@ void LockMaster::Lock()
   // lock the mutex (note locking the mutexes one by one can lead to
   // deadlocks... we might be better off locking them all at once
   // (using trylock, then unlocking if they can't all be locked, then lock & wait, repeat...)
-  std::for_each(object_mutexes.begin(), object_mutexes.end(), uv_mutex_lock);
+  for(std::shared_ptr<uv_mutex_t> &mutex : object_mutexes) {
+    uv_mutex_lock(mutex.get());
+  }
 }
 
 void LockMaster::Unlock()
 {
-  std::for_each(object_mutexes.begin(), object_mutexes.end(), uv_mutex_unlock);
+  for(std::shared_ptr<uv_mutex_t> &mutex : object_mutexes) {
+    uv_mutex_unlock(mutex.get());
+  }
+}
+
+void LockMaster::CleanupMutexes()
+{
+  // schedule mutex cleanup on the main event loop
+  // this somewhat delays and debounces cleanup (uv_async_send coalesces calls)
+  uv_async_send(&cleanup_mutexes_handle);
 }
 
 LockMaster::TemporaryUnlock::TemporaryUnlock() {