Safely stop the heartbeat thread

Previously we were not ensuring that the heartbeat thread had stopped before
exiting, and were closing the context in an unsafe way. This was causing hangs
on Mac and segfaults on Windows.

Author: JamesWrigley

src/IJulia.jl

@@ -175,11 +175,13 @@ function Base.close(kernel::Kernel)
     popdisplay()
 
     # Close all sockets
-    close(kernel.publish[])
-    close(kernel.raw_input[])
     close(kernel.requests[])
     close(kernel.control[])
-    close(kernel.heartbeat_context[])
+    close(kernel.publish[])
+    close(kernel.raw_input[])
+
+    # Wait for the heartbeat thread
+    stop_heartbeat(kernel)
 
     # The waitloop should now be ready to exit
     kernel.inited = false

src/handlers.jl

@@ -214,8 +214,8 @@ request](https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-s
 sending the reply this will exit the process.
 """
 function shutdown_request(socket, kernel, msg)
-    # stop heartbeat thread by closing the context
-    close(kernel.heartbeat_context[])
+    # stop heartbeat thread
+    stop_heartbeat(kernel)
 
     # In protocol 5.4 the shutdown reply moved to the control socket
     shutdown_socket = VersionNumber(msg) >= v"5.4" ? kernel.control[] : kernel.requests[]

src/heartbeat.jl

@@ -23,7 +23,23 @@ function heartbeat_thread(heartbeat::Ptr{Cvoid})
 end
 
 function start_heartbeat(heartbeat, kernel)
+    heartbeat.linger = 0
     heartbeat_c = @cfunction(heartbeat_thread, Cint, (Ptr{Cvoid},))
     ccall(:uv_thread_create, Cint, (Ptr{Int}, Ptr{Cvoid}, Ptr{Cvoid}),
           kernel.heartbeat_threadid, heartbeat_c, heartbeat)
 end
+
+function stop_heartbeat(kernel)
+    # First we call zmq_ctx_shutdown() to ensure that the zmq_proxy() call
+    # returns. We don't call ZMQ.close(::Context) directly because that
+    # currently isn't threadsafe:
+    # https://github.com/JuliaInterop/ZMQ.jl/issues/256
+    ZMQ.lib.zmq_ctx_shutdown(kernel.heartbeat_context[])
+    @ccall uv_thread_join(kernel.heartbeat_threadid::Ptr{Int})::Cint
+
+    # Now that the heartbeat thread has joined and its guaranteed to no longer
+    # be working on the heartbeat socket, we can safely close it and then the
+    # context.
+    close(kernel.heartbeat[])
+    close(kernel.heartbeat_context[])
+end