3 files changed, 70 insertions, 1 deletions

diff --git a/platform/android/src/android_thread_pool.cpp b/platform/android/src/android_thread_pool.cpp
index 3c1ef4ac46..afa3a90ad9 100644
--- a/platform/android/src/android_thread_pool.cpp
+++ b/platform/android/src/android_thread_pool.cpp
@@ -1,6 +1,8 @@
 #include "android_thread_pool.hpp"
 #include <mbgl/util/platform.hpp>
 
+#include <cassert>
+
 namespace mbgl {
 namespace android {
 
@@ -12,7 +14,23 @@ void AndroidThreadLifecycle::onThreadDestroyed() const {
     detach_jni_thread(theJVM, &env, true);
 }
 
-AndroidThreadPool::AndroidThreadPool(size_t count) : mbgl::ThreadPool(count, std::make_unique<AndroidThreadLifecycle>()) {}
+//AndroidThreadPool::AndroidThreadPool(size_t count) : mbgl::ThreadPool(count, std::make_unique<AndroidThreadLifecycle>()) {}
+
+const auto onThreadCreated =
+    [] {
+        JNIEnv *env = nullptr;
+        attach_jni_thread(theJVM, &env, platform::getCurrentThreadName());
+        return env;
+    };
+
+const auto onThreadDestroyed =
+    [] (void* data) {
+        assert(data);
+        JNIEnv* env = static_cast<JNIEnv*>(data);
+        detach_jni_thread(theJVM, &env, true);
+    };
+
+AndroidThreadPool::AndroidThreadPool(size_t count) : mbgl::ThreadPool(count, {onThreadCreated, onThreadDestroyed}) {}
 
 } // namespace android
 } // namespace mbgl
diff --git a/platform/default/include/mbgl/util/default_thread_pool.hpp b/platform/default/include/mbgl/util/default_thread_pool.hpp
index c28e369f71..6535cdf23f 100644
--- a/platform/default/include/mbgl/util/default_thread_pool.hpp
+++ b/platform/default/include/mbgl/util/default_thread_pool.hpp
@@ -15,10 +15,32 @@ struct ThreadLifecycle {
     virtual ~ThreadLifecycle() = default;
 };
 
+struct ThreadLifecycleV2 {
+    ThreadLifecycleV2() = default;
+    ThreadLifecycleV2(std::function<void*()> onThreadCreated_,
+                      std::function<void(void*)> onThreadDestroyed_) :
+                      onThreadCreatedFn(onThreadCreated_),
+                      onThreadDestroyedFn(onThreadDestroyed_) {}
+
+    void onThreadCreated() const {
+        privateData = onThreadCreatedFn();
+    }
+
+    void onThreadDestroyed() const {
+        onThreadDestroyedFn(privateData);
+    }
+
+private:
+    std::function<void*()> onThreadCreatedFn = []{return nullptr;};
+    std::function<void(void*)> onThreadDestroyedFn = [](void*){};
+    mutable void* privateData = NULL;
+};
+
 class ThreadPool : public Scheduler {
 public:
     explicit ThreadPool(std::size_t count);
     ThreadPool(std::size_t count, std::unique_ptr<ThreadLifecycle> _lifecycle);
+    ThreadPool(std::size_t count, ThreadLifecycleV2 = ThreadLifecycleV2());
     ~ThreadPool() override;
 
     void schedule(std::weak_ptr<Mailbox>) override;
diff --git a/platform/default/src/mbgl/util/default_thread_pool.cpp b/platform/default/src/mbgl/util/default_thread_pool.cpp
index e24fe9e80e..ce084a70c0 100644
--- a/platform/default/src/mbgl/util/default_thread_pool.cpp
+++ b/platform/default/src/mbgl/util/default_thread_pool.cpp
@@ -7,6 +7,35 @@ namespace mbgl {
 
 ThreadPool::ThreadPool(std::size_t count) : ThreadPool::ThreadPool(count, nullptr) {}
 
+ThreadPool::ThreadPool(std::size_t count, ThreadLifecycleV2 lifecycleV2) {
+    threads.reserve(count);
+    for (std::size_t i = 0; i < count; ++i) {
+        threads.emplace_back([this, i, lifecycleV2]() {
+            platform::setCurrentThreadName(std::string{ "Worker " } + util::toString(i + 1));
+            lifecycleV2.onThreadCreated();
+
+            while (true) {
+                std::unique_lock<std::mutex> lock(mutex);
+
+                cv.wait(lock, [this] {
+                    return !queue.empty() || terminate;
+                });
+
+                if (terminate) {
+                    lifecycleV2.onThreadDestroyed();
+                    return;
+                }
+
+                auto mailbox = queue.front();
+                queue.pop();
+                lock.unlock();
+
+                Mailbox::maybeReceive(mailbox);
+            }
+        });
+    }
+}
+
 ThreadPool::ThreadPool(std::size_t count, std::unique_ptr<ThreadLifecycle > _lifecycle) : lifecycle(std::move(_lifecycle)) {
     threads.reserve(count);
     for (std::size_t i = 0; i < count; ++i) {