nodejs
diff --git a/‎src/node_worker.cc‎
Lines changed: 14 additions & 4 deletions b/‎src/node_worker.cc‎
Lines changed: 14 additions & 4 deletions
diff --git a/‎src/node_worker.h‎
Lines changed: 1 addition & 1 deletion b/‎src/node_worker.h‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎test/parallel/test-worker-nearheaplimit-deadlock.js‎
Lines changed: 22 additions & 0 deletions b/‎test/parallel/test-worker-nearheaplimit-deadlock.js‎
Lines changed: 22 additions & 0 deletions
@@ -328,7 +328,10 @@ void Worker::Run() {
       Debug(this, "Created Environment for worker with id %llu", thread_id_.id);
       if (is_stopped()) return;
       {
-        CreateEnvMessagePort(env_.get());
+        if (!CreateEnvMessagePort(env_.get())) {
+          return;
+        }
+
         Debug(this, "Created message port for worker %llu", thread_id_.id);
         if (LoadEnvironment(env_.get(), StartExecutionCallback{}).IsEmpty())
           return;
@@ -352,17 +355,24 @@ void Worker::Run() {
   Debug(this, "Worker %llu thread stops", thread_id_.id);
 }
 
-void Worker::CreateEnvMessagePort(Environment* env) {
+bool Worker::CreateEnvMessagePort(Environment* env) {
   HandleScope handle_scope(isolate_);
-  Mutex::ScopedLock lock(mutex_);
+  std::unique_ptr<MessagePortData> data;
+  {
+    Mutex::ScopedLock lock(mutex_);
+    data = std::move(child_port_data_);
+  }
+
   // Set up the message channel for receiving messages in the child.
   MessagePort* child_port = MessagePort::New(env,
                                              env->context(),
-                                             std::move(child_port_data_));
+                                             std::move(data));
   // MessagePort::New() may return nullptr if execution is terminated
   // within it.
   if (child_port != nullptr)
     env->set_message_port(child_port->object(isolate_));
+
+  return child_port;
 }
 
 void Worker::JoinThread() {
 
@@ -70,7 +70,7 @@ class Worker : public AsyncWrap {
   static void LoopStartTime(const v8::FunctionCallbackInfo<v8::Value>& args);
 
  private:
-  void CreateEnvMessagePort(Environment* env);
+  bool CreateEnvMessagePort(Environment* env);
   static size_t NearHeapLimit(void* data, size_t current_heap_limit,
                               size_t initial_heap_limit);
 
 
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+// Do not use isMainThread so that this test itself can be run inside a Worker.
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
+  const opts = {
+    resourceLimits: {
+      maxYoungGenerationSizeMb: 0,
+      maxOldGenerationSizeMb: 0
+    }
+  };
+
+  const worker = new Worker(__filename, opts);
+  worker.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_WORKER_OUT_OF_MEMORY');
+  }));
+} else {
+  setInterval(() => {}, 1);
+}