Clojure Running Multiple Threads with Functions with zero or one input - multithreading

Question

I'm experimenting in Clojure with running independent threads and I'm getting different behaviors I don't understand.
For my code editor I'm using Atom (not emacs), REPL is Chlorine.
I'm testing a really simple function that just prints numbers.
This one prints from 100 to 1 and takes no inputs:
(defn pl100 []
"pl100 = Print Loop from 100 to 1"
(loop [counter 100]
(when (pos? counter)
(do
(Thread/sleep 100)
(println (str "counter: " counter))
(recur (dec counter))))))
This one does the exact same thing, except it takes an input:
(defn pl-n [n]
"pl-n = Print Loop from n to 1"
(loop [counter n]
(when (pos? counter)
(do
(Thread/sleep 100)
(println (str "counter: " counter))
(recur (dec counter))))))
When I use
(.start (Thread. #(.run pl100)))
; --> prints to console REPL
; --> runs with no errors
this code
prints to the console REPL (where I call lein) and
runs with no errors
When I use
(.start (Thread. #(.run (pl-n 100))))
; prints to console REPL
; --> java.lang.NullPointerException: Cannot invoke "Object.getClass()" because "target" is null
this code
prints to the console REPL
ends with the above exception
When I use
(.start (Thread. pl100))
; --> prints to the console REPL
; --> runs with no errors
this code
prints to the console REPL
runs with no errors
When I use
(.start (Thread. (pl-n 100)))
; --> prints to Atom REPL, not console REPL!
; ends with exception
; Execution error (NullPointerException) at java.lang.Thread/<init> (Thread.java:396).
; name cannot be null
; class java.lang.NullPointerException
this code
prints to the Atom REPL (I'm using Atom, not emacs)! Not to the console REPL like the others
ends with exception
So, can someone please help me understand:
Why is it when I'm running a function that takes an input, Java gives an error? Why are the function calls not equivalent?
What is (.run ...) doing?
Why is it that sometimes the code prints to the console and other times to Atom/Chlorine?

Answer 1

To answer in brief: Thread.run requires a function. Your first exhibit gives it a function, pl100, and works as you expect:
#(.run pl100)
Something altogether different would happen if you gave .run not a function, but instead the value returned by calling the pl100 function. In fact, pl100 returns nil, so Thread.run would throw a NullPointerException:
#(.run (pl100)) ;; NullPointerException
That explains why your second exhibit did not do what you expected. pl-n returned nil, and then you got an exception when you passed nil to Thread.run:
#(.run (pl-n 100)) ;; NullPointerException
To bridge the gap - between Thread.run which requires a function of no arguments, and your function pl-n which requires an argument, you could introduce a function-of-no-arguments (to satisfy Thread.run) which calls pl-n with the desired argument. Idiomatically this would be an anonymous function. Unfortunately, you can't nest #() within #(), so you will have to use the more verbose (fn [] ...) syntax for one of the anonymous functions, most likely the outer one.

Answer 2

Try something like this:
(ns tst.demo.core
(:use demo.core tupelo.core tupelo.test)
(:require [tupelo.string :as str]))
(defn pl100 []
"pl100 = Print Loop from 100 to 1"
(loop [counter 10]
(when (pos? counter)
(do
(Thread/sleep 100)
(println (str "pl100 counter: " counter))
(recur (dec counter))))))
(defn pl-n [n]
"pl-n = Print Loop from n to 1"
(loop [counter n]
(when (pos? counter)
(do
(Thread/sleep 100)
(println (str "pl-n counter: " counter))
(recur (dec counter))))))
(dotest
(newline)
(.start (Thread. pl100))
(Thread/sleep (* 2 1000))
(newline)
(.start (Thread. #(pl-n 5)))
(Thread/sleep (* 2 1000))
(newline)
(println :done)
)
Clojure functions are already an instance of Runnable, and you don't need #(.run xxx) syntax. Result:
--------------------------------------
Clojure 1.10.2-alpha1 Java 15
--------------------------------------
Testing tst.demo.core
pl100 counter: 10
pl100 counter: 9
pl100 counter: 8
pl100 counter: 7
pl100 counter: 6
pl100 counter: 5
pl100 counter: 4
pl100 counter: 3
pl100 counter: 2
pl100 counter: 1
pl-n counter: 5
pl-n counter: 4
pl-n counter: 3
pl-n counter: 2
pl-n counter: 1
:done
To make it even simpler, just use a Clojure future:
(future (pl100))
(Thread/sleep (* 2 1000))
(newline)
(future (pl-n 5))
(Thread/sleep (* 2 1000))
(newline)
(println :done)
If you remove the Thread/sleep, you can see them running in parallel:
(future (pl100))
(future (pl-n 5))
(Thread/sleep (* 2 1000))
(newline)
(println :done)
with result
pl100 counter: 10
pl-n counter: 5
pl100 counter: 9
pl-n counter: 4
pl100 counter: 8
pl-n counter: 3
pl100 counter: 7pl-n counter: 2
pl100 counter: 6pl-n counter: 1
pl100 counter: 5
pl100 counter: 4
pl100 counter: 3
pl100 counter: 2
pl100 counter: 1