Imported From: https://issues.scala-lang.org/browse/SI-10169?orig=1
Reporter: Vladimir Kostyukov (vkostyukov)
Affected Versions: 2.12.1
Duplicates #8119

@som-snytt said:
I can't resist such a nicely detailed ticket with proper use of its and it's. Pinch me if I'm dreaming.

It works if foo.Pool is lazy. I wonder if all value members of package objects should be implicitly lazy.

@som-snytt said:
In general, it's desirable to avoid starting threads from static initializers (such as an object constructor) because of the risk of deadlock during class loading.

The risk increases in 2.12 with lambdas. Besides making Pool a lazy val, the following change also unblocks, but it's really no way to live:

--- a/src/main/scala/foo/package.scala
+++ b/src/main/scala/foo/package.scala
@@ -7,6 +7,13 @@ package object foo {
 
   import bar.Proxy
 
+  val Pre = new Function0[Unit] {
+    def apply() = println("pre")
+  }   
+  val Post = new Function0[Unit] {
+    def apply() = println("post")
+  }
+
   val Executor: ExecutorService = {
     val threadFactory = new Proxy(
       new ThreadFactory {
@@ -17,12 +24,15 @@ package object foo {
         }
       },
       Proxy.newProxy(
+        Pre, Post
+        /*
         () => println("pre"),
         () => println("post")
+        */
       )
     )
     Executors.newCachedThreadPool(threadFactory)
   }
 
   val Pool: WorkerPool = new WorkerPool(Executor)
}

@som-snytt said:
Linking to the canonical ticket.

Vladimir Kostyukov (vkostyukov) said:
Thanks a lot! This is the conclusion I came up with - just remove those inlined anonymous functions from the class initialization path (see twitter/finagle@225c86d).