{"id":56857,"date":"2023-03-15T13:08:49","date_gmt":"2023-03-15T07:38:49","guid":{"rendered":"https:\/\/www.tothenew.com\/blog\/?p=56857"},"modified":"2023-03-17T13:02:16","modified_gmt":"2023-03-17T07:32:16","slug":"project-loom-launching-10-million-threads-part-2","status":"publish","type":"post","link":"https:\/\/www.tothenew.com\/blog\/project-loom-launching-10-million-threads-part-2\/","title":{"rendered":"Java Project Loom – Launching 10 million threads (Part 2)"},"content":{"rendered":"

In the previous blog<\/a>, we discussed a detailed overview of Project Loom. Now it\u2019s time for some code. If you have not read about part 2 of this series, please check it out here:<\/p>\n

Let us see how we can create virtual threads in Java.<\/p>\n

Thread.ofVirtual().unstarted(() -> System.out.println(\"Thread is not started\"<\/span>));<\/span><\/pre>\n
 Thread.ofVirtual().start(() -> System.out.println(\"Thread is not started\"<\/span>));<\/span><\/pre>\n
In the first example, we created a virtual thread but in unstarted mode. In second example, we created a virtual thread in started mode. Simple stuff. There\u2019s nothing fancy about it.<\/p>\n
Now let\u2019s run the below program and see the output<\/p>\n
public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> throws<\/span> InterruptedException {\r\n        var<\/span> thread<\/span> =<\/span> Thread.ofVirtual().unstarted(() -> System.out.println(Thread.currentThread()));\r\n        thread.start();\r\n        thread.join();\r\n    }<\/span><\/pre>\n
Output<\/p>\n
VirtualThread[#22]\/runnable@ForkJoinPool<\/span>-1-worker-1<\/span><\/span><\/pre>\n
We can see that\u00a0VirtualThread [#22]<\/em><\/strong>\u00a0has been created and is running the task of printing the line. Also, we can see\u00a0ForkJoinPool-1-worker-1\u00a0<\/em>l<\/strong>iteral in the output. This means that our\u00a0VirtualThread[#22]<\/em><\/strong>\u00a0is running on top of a platform thread with the name\u00a0ForkJoinPool-1-worker-1.\u00a0<\/em><\/strong>Clearly, virtual threads are running on top of the ForkJoinPool.\u00a0<\/em><\/strong>Is it the same common ForkJoinPool that we use to submit the task? Let\u2019s check this out by running the following program:<\/p>\n
public<\/span> static<\/span> void<\/span> main<\/span>(String[] args<\/span>) throws InterruptedException<\/span> {\r\n    ForkJoinPool.commonPool().submit(\r\n          () -> System.out<\/span>.println(Thread.currentThread())\r\n        );\r\n}<\/span><\/pre>\n
Output<\/p>\n
Thread[#22,ForkJoinPool.commonPool-worker-1,5,main]<\/span><\/span><\/pre>\n
Clearly,\u00a0ForkJoinPool-1-worker-1<\/strong>\u00a0and\u00a0ForkJoinPool.commonPool-worker-1<\/strong>\u00a0are not same. Virtual threads are running on fork join pool which is different from common fork join pool introduced in java 7.<\/p>\n
Let\u2019s see one more interesting thing about virtual thread by running the following program<\/p>\n
 public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> throws<\/span> InterruptedException {\r\n    Thread.ofVirtual().start(() -> System.out.println(\"Thread is not started\"<\/span>));\r\n    var<\/span> threads<\/span> =<\/span> IntStream.range(0<\/span>,10<\/span>)\r\n      .mapToObj(\r\n          index -> Thread.ofVirtual().unstarted(() -> {\r\n              if<\/span>(index == 0<\/span>){\r\n                  System.out.println(Thread.currentThread());\r\n              }\r\n              try<\/span> {\r\n                  Thread.sleep(10<\/span>);\r\n              } catch<\/span> (InterruptedException e) {\r\n                  throw<\/span> new<\/span> RuntimeException<\/span>(e);\r\n              }\r\n              if<\/span>(index == 0<\/span>){\r\n                  System.out.println(Thread.currentThread());\r\n              }\r\n          })).toList();\r\n    threads.forEach(Thread::start);\r\n    for<\/span>(Thread thread : threads){\r\n        thread.join();\r\n    }\r\n  }<\/span><\/pre>\n
We are creating 10 virtual threads and letting the 0th thread print its thread name. We allow it to sleep for 10 milliseconds, and then we are again trying to print the 0th thread to print its name. Let\u2019s see the result.<\/p>\n
VirtualThread[#25]\/runnable@ForkJoinPool<\/span>-1-worker-2<\/span>\r\nVirtualThread[#25]\/runnable@ForkJoinPool<\/span>-1-worker-10<\/span><\/span><\/pre>\n
We can see that\u00a0Virtual Thread #25<\/em><\/strong>\u00a0first ran on platform thread\u00a0ForkJoinPool-1-worker-2<\/strong>. It\u2019s been asleep for 10 milliseconds. When it wakes up, it is pinned to another platform thread with the name\u00a0runnable@ForkJoinPool-1-worker-10<\/em><\/strong>. So clearly, we can see that whenever the virtual thread is blocked, it releases the platform thread, and its stack is moved to the heap memory. The platform thread can now be pinned to another virtual thread to carry out its task. When the blocking operation is finished, the virtual thread will be pinned to any free platform thread and will mount its stack on that platform thread.<\/p>\n
This is new in Java, and it\u2019s great. Blocking a thread is cheap. Cost is only un-mounting the call-stack from platform thread and storing in heap and vice versa.<\/p>\n
Now it\u2019s the time to launch threads. Lets launch 100 of threads with the below program.<\/p>\n
 public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> throws<\/span> InterruptedException {\r\n     var<\/span> list<\/span> =<\/span> new<\/span> HashSet<\/span><String>();\r\n     var<\/span> millis<\/span> =<\/span> System.currentTimeMillis();\r\n     var<\/span> vthreadcounts<\/span> =<\/span> 100<\/span>;\r\n     var<\/span> threads<\/span> =<\/span> IntStream.range(0<\/span>,vthreadcounts)\r\n        .mapToObj(\r\n          index -> Thread.ofVirtual().unstarted(() -> {\r\n              var<\/span> abc<\/span> =<\/span>  \"VirtualThread[#22]\/runnable@ForkJoinPool-1-worker-1\"<\/span>.contains(\"runnable@ForkJoinPool-1\"<\/span>);\r\n              var<\/span> threadName<\/span> =<\/span> Thread.currentThread().toString();\r\n             if<\/span>(abc) list.add(threadName.substring(threadName.indexOf(\"\/\"<\/span>)));\r\n          })).toList();\r\n\r\n      threads.forEach(Thread::start);\r\n      for<\/span>(Thread thread : threads){\r\n          thread.join();\r\n      }\r\n      var<\/span> millis1<\/span> =<\/span> System.currentTimeMillis();\r\n      System.out.println(\"millis used to launch \"<\/span> + vthreadcounts + \"vthreads:\"<\/span> + (millis1 - millis) + \"ms\"<\/span>);\r\n      System.out.println(\"number of platform thread used:\"<\/span> + list.size());\r\n   }<\/span><\/pre>\n
We are using some logic to calculate the number of platform threads required to run 100 virtual threads. Also, we wrote logic to calculate the time it takes in milliseconds to execute it. Let\u2019s see the output of this program.<\/p>\n
millis used to launch 100<\/span>vthreads:23<\/span>ms\r\nnumber of platform thread used:7<\/span><\/span><\/pre>\n
It took 23 milliseconds and have used 7 platform thread.<\/p>\n
Let\u2019s us put more pressure on the program by changing the vthreadcounts to 1000. Let\u2019s see the output now.<\/p>\n
millis used to launch 1000<\/span>vthreads:23<\/span>ms\r\nnumber of platform thread used:10<\/span><\/span><\/pre>\n
Nothing, its still took 23 milliseconds and platform thread used is 10 in this case. Let us put more pressure on it and run for 10,000 threads and see the output.<\/p>\n
millis used to launch 10000<\/span>vthreads:57<\/span>ms\r\nnumber of platform thread used:10<\/span><\/span><\/pre>\n
It took now 57 milliseconds and platform thread used is 10. Quite impressive. Let us put some more pressure on it and run for 100,000 threads and see the result.<\/p>\n
millis used to launch 100000<\/span>vthreads:246<\/span>ms\r\nnumber of platform thread used:10<\/span><\/span><\/pre>\n
Still only 246 milliseconds and 10 platform threads. Still under 1 second. Time to put some serious pressure and look for 1000,000 (1 million) threads.<\/p>\n
millis used to launch 1000000<\/span>vthreads:1286<\/span>ms\r\nnumber of platform thread used:10<\/span><\/span><\/pre>\n
Now, it took 1286 milliseconds, just little more that 1 second and used 10 platform thread.<\/p>\n
Now, we are in finale and will run for 10 million threads i.e 10,000,000 threads. Have you ever done that. This is insane amount of numbers.<\/p>\n
millis used to launch 10000000<\/span>vthreads:8762<\/span>ms\r\nnumber of platform thread used:10<\/span><\/span><\/pre>\n
And we are able to run our 10 million threads in just less than 9 seconds.<\/p>\n
Even though we are not doing much in our threads but still running 10 million threads in less than 9 seconds is no mean feat.<\/p>\n
Project loom guys are doing great job. In coming parts we will be taking a look into StructuredTaskScope which is quite amazing feature of this project Loom.<\/p>\n
This blog was originally published in Medium, read here<\/a>.<\/p>\n
<\/div>","protected":false},"excerpt":{"rendered":"
In the previous blog, we discussed a detailed overview of Project Loom. Now it\u2019s time for some code. If you have not read about part 2 of this series, please check it out here: Let us see how we can create virtual threads in Java. Thread.ofVirtual().unstarted(() -> System.out.println(“Thread is not started”)); Thread.ofVirtual().start(() -> System.out.println(“Thread is […]<\/p>\n","protected":false},"author":1520,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":3},"categories":[446],"tags":[5134,5133],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/56857"}],"collection":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/users\/1520"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/comments?post=56857"}],"version-history":[{"count":6,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/56857\/revisions"}],"predecessor-version":[{"id":56902,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/56857\/revisions\/56902"}],"wp:attachment":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/media?parent=56857"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/categories?post=56857"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/tags?post=56857"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}