{"id":55,"date":"2023-03-01T15:40:25","date_gmt":"2023-03-01T15:40:25","guid":{"rendered":"https:\/\/java-online-training.de\/?p=55"},"modified":"2023-03-19T08:36:10","modified_gmt":"2023-03-19T08:36:10","slug":"java-19-structured-concurrency","status":"publish","type":"post","link":"https:\/\/java-online-training.de\/?p=55","title":{"rendered":"Java 19: Structured Concurrency"},"content":{"rendered":"\n

Another very interesting feature that will most likely be available with Java 21 is the introduction of the Structured Concurrency<\/strong> API developed under JEP 428<\/a> by Project Loom. Structured concurrency will greatly simplify the use of virtual threads and provide an API similar to the well know ExecutorService <\/em>API to execute Callables<\/em>. If you haven’t heard about virtual threads yet, check out this blog post <\/a>which explains the pros and cons of virtual vs platform threads. Structured Concurrency is currently available as an incubator feature in Java 19. <\/p>\n\n\n\n

The centerpiece of the new API is the class StructuredTaskScope<\/em>, which is used to start a virtual thread with a given Callable <\/em>to execute. In exchange you get a Future <\/em>that provides access to the result of the Callable <\/em>after it finished. Here is simple example of StructuredTaskScope <\/em>in action:<\/p>\n\n\n\n

<\/path><\/path><\/svg><\/span>
try<\/span> (<\/span>var<\/span> <\/span>scope<\/span> <\/span>=<\/span> <\/span>new<\/span> StructuredTaskScope<<\/span>String<\/span>>()){<\/span><\/span>\n<\/span>\n  Callable<\/span><<\/span>String<\/span>> <\/span>callable<\/span> <\/span>=<\/span> () <\/span>-><\/span> <\/span>"Running ... Finished!"<\/span>;<\/span><\/span>\n<\/span>\n  Future<\/span><<\/span>String<\/span>> <\/span>result<\/span> <\/span>=<\/span> scope.<\/span>fork<\/span>(callable);<\/span><\/span>\n            <\/span><\/span>\n  scope.<\/span>join<\/span>();<\/span><\/span>\n            <\/span><\/span>\n  System.out.<\/span>println<\/span>(result.<\/span>get<\/span>());<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
In line (1) I create a new StructuredTaskScope <\/em>in a try-with-resource block. StructuredTaskScope <\/em>implements the interface AutoClosable <\/em>and we can just conveniently close it like this after use. In line (3) and (5), I create a Callable <\/em>and start it with the fork<\/em> <\/strong>method of StructuredTaskScope<\/em>. Finally, I wait for the Callable <\/em>to finish in line (7) by invoking the join <\/em>method. The code blocks in line (7) until the Callable <\/em>is completed and then resumes by printing the result into the console.<\/p>\n\n\n\n
On short note on running the above code yourself. Since structured concurrency is an incubator feature<\/strong>, you won’t be able to just run it with Java 19 installed. You will need to explicitly activate preview features<\/strong> and the concurrency incubator feature<\/strong> when you run your program:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
java <\/span>--<\/span>enable<\/span>-<\/span>preview <\/span>--<\/span>add<\/span>-<\/span>modules<\/span>=<\/span>jdk.incubator.concurrent a.b.Example<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Let’s expand our code a little bit to see multiple virtual threads running at the same time.  As a simple business case, I want to call a service that returns currency conversion rates from Euros into a bunch of other currencies. The service has a slight delay build in to simulate a slow operation to query the exchange rate, e.g. a web service call or database access. Since I want to keep this example simple, I will just stop the thread for 500 milliseconds instead of implementing a real web service or database access. Here is the code for the currency conversion rate service:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
public<\/span> <\/span>class<\/span> <\/span>CurrencyConversionService<\/span> {<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> Double <\/span>getConvertionRate<\/span>(Currency <\/span>currency<\/span>) <\/span>throws<\/span> Exception {<\/span><\/span>\n        Thread.<\/span>sleep<\/span>(<\/span>500l<\/span>);<\/span><\/span>\n        <\/span>return<\/span> currency.<\/span>getRate<\/span>();<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> ConversionResult <\/span>getEuroConvertionResult<\/span>(Double <\/span>amount<\/span>, Currency <\/span>target<\/span>) <\/span>throws<\/span> Exception {<\/span><\/span>\n        <\/span>return<\/span> <\/span>new<\/span> <\/span><\/span>\n          <\/span>ConversionResult<\/span>(<\/span><\/span>\n            Double.<\/span>valueOf<\/span>(amount<\/span>*<\/span>getConvertionRate<\/span>(target)),<\/span><\/span>\n            target,<\/span><\/span>\n            amount);<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>enum<\/span> <\/span>Currency<\/span> { <\/span><\/span>\n    <\/span><\/span>\n        <\/span>USD<\/span>(<\/span>1.2d<\/span>) , <\/span>EUR<\/span>(<\/span>1d<\/span>) , <\/span>JPY<\/span>(<\/span>144d<\/span>) , <\/span>CAD<\/span>(<\/span>1.44d<\/span>) , <\/span>GBP<\/span>(<\/span>0.88d<\/span>); <\/span><\/span>\n    <\/span><\/span>\n        <\/span>private<\/span> Double<\/span> <\/span>rate;<\/span><\/span>\n<\/span>\n        <\/span>private<\/span> <\/span>Currency<\/span>(Double <\/span>rate<\/span>){ <\/span>this<\/span>.rate <\/span>=<\/span> rate;}<\/span><\/span>\n<\/span>\n        <\/span>public<\/span> Double <\/span>getRate<\/span>(){ <\/span>return<\/span> rate; }<\/span><\/span>\n    };<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
The supported currencies including the rates are hardcoded in the Currency <\/em>enumeration to keep things simple.  There are two business methods in this service, one that returns the conversion rate (getConvertionRate<\/em>) and the second that converts a given amount in Euros to another currency (getEuroConvertionResult<\/em>).  The second method returns a ConversionResult<\/em> object, which is a simple record that stores the result of the conversion, the currency and the original amount in Euros. We will use the second method later in this post.<\/p>\n\n\n\n
I will now expand the first example, so that the service class is called for all available conversion rates in a virtual thread and collect the results into a HashMap. <\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
 CurrencyConversionService<\/span> <\/span>currencyService<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>CurrencyConversionService<\/span>();<\/span><\/span>\n <\/span><\/span>\n <\/span>try<\/span>(<\/span>var<\/span> <\/span>scope<\/span> <\/span>=<\/span> <\/span>new<\/span> StructuredTaskScope<<\/span>Double<\/span>>()){<\/span><\/span>\n<\/span>\n   Map<\/span><<\/span>Currency<\/span>,<\/span>Future<\/span><<\/span>Double<\/span>>> <\/span>results<\/span> <\/span>=<\/span> <\/span>new<\/span> HashMap<>();<\/span><\/span>\n<\/span>\n   results.<\/span>put<\/span>(USD, scope.<\/span>fork<\/span>( () <\/span>-><\/span> currencyService.<\/span>getConvertionRate<\/span>(USD) ));<\/span><\/span>\n   results.<\/span>put<\/span>(JPY, scope.<\/span>fork<\/span>( () <\/span>-><\/span> currencyService.<\/span>getConvertionRate<\/span>(JPY) ));<\/span><\/span>\n   results.<\/span>put<\/span>(EUR, scope.<\/span>fork<\/span>( () <\/span>-><\/span> currencyService.<\/span>getConvertionRate<\/span>(EUR) ));<\/span><\/span>\n   results.<\/span>put<\/span>(CAD, scope.<\/span>fork<\/span>( () <\/span>-><\/span> currencyService.<\/span>getConvertionRate<\/span>(CAD) ));<\/span><\/span>\n   results.<\/span>put<\/span>(GBP, scope.<\/span>fork<\/span>( () <\/span>-><\/span> currencyService.<\/span>getConvertionRate<\/span>(GBP) ));<\/span><\/span>\n<\/span>\n   scope.<\/span>join<\/span>();<\/span><\/span>\n<\/span>\n   <\/span>for<\/span>(<\/span>var<\/span> <\/span>currency<\/span> <\/span>:<\/span> results.<\/span>keySet<\/span>()) {<\/span><\/span>\n     System.out.<\/span>println<\/span>(<\/span>"Conversion rate for "<\/span>+<\/span> currency <\/span>+<\/span> <\/span>" is "<\/span> <\/span>+<\/span><\/span>\n       results.<\/span>get<\/span>(currency).<\/span>get<\/span>() );<\/span><\/span>\n   }<\/span><\/span>\n }<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
The main difference to our first example is, that I am creating five Callables <\/em>and start each with the fork <\/em>method of the StructuredTaskScope<\/em> in line (7) to (11). The, I call the  join <\/em>on the StructuredTaskScope <\/em>to wait until all tasks are done in line (13).   All Futures are stored in a HashMap and after all tasks finished, I can print the results to the console with the the currency as the key and the result as the entry. <\/p>\n\n\n\n
Now you might think why this code is so special compared to the use of a regular ExecutorService to start Callables<\/em>. First thing to mention is, that creating a ExecutorService <\/em>is a very costly operation and ExecutorServices<\/em> are usually created as a singleton. So creating it locally like in line (3) is a no-go looking at performance. The second point is, that using an ExecutorService <\/em>to start a couple of blocking operations is also not the greatest idea, since the amount of platform threads you can have at a any given time is quite limited. Each platform thread has its on stack trace in memory and also needs some memory to do its job. The wise people that write Apache Tomcat picked 200 threads as the default for a Tomcat installation and this is actually a good number in many cases. If you run the code above on Apache Tomcat with an ExecutorService <\/em>instead of a StructuredTaskScope<\/em>, the server would become unresponsive if you started the code  more than 40 times.<\/p>\n\n\n\n
However, by using StructuredTaskScope <\/em>and virtual threads, the server will never become unresponsive because it runs out of threads. Virtual threads are very lightweight compared to platform threads and blocking them is quite cheap, since the underlying platform thread that executes the virtual thread will simply work on another virtual thread in the meantime.  You can easily start a million virtual threads without breaking your application. This is the beauty when using virtual threads to execute business logic concurrently. You don’t need to think about shared thread pools and ExecutorServices <\/em>anymore. You simply create as many virtual threads as you need by a local StructuredTaskScope <\/em>and your application will run just fine. No more worrying about thread starvation because the virtual thread will make sure that your platform threads can be as productive as possible without you optimizing it.  <\/p>\n\n\n\n
Subclassing StructuredTaskScope<\/h4>\n\n\n\n
One thing that could be improved in the code of the last example, is the use of a HashMap to store the results of our Callables<\/em>. It would be much nicer, if we could simply start all Callables <\/em>and get the results back from the StructuredTaskScope<\/em> and the API has a nice callback to achieve that.  You can override the handleComplete <\/em>method which gets called when a Callable completed and is passed the corresponding Future. In this method you can manipulate the result or store it somewhere for easy access.  <\/p>\n\n\n\n
Subclassing StructuredTaskScope <\/em>will look like this:<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
public<\/span> <\/span>class<\/span> <\/span>CurrencyConverterScope<\/span> <\/span>extends<\/span> <\/span>StructuredTaskScope<\/span><<\/span>ConversionResult<\/span>> {<\/span><\/span>\n<\/span>\n    Queue<\/span><<\/span>ConversionResult<\/span>> <\/span>queue<\/span> <\/span>=<\/span> <\/span>new<\/span> ConcurrentLinkedQueue<<\/span>ConversionResult<\/span>>();<\/span><\/span>\n<\/span>\n    @<\/span>Override<\/span><\/span>\n    <\/span>protected<\/span> <\/span>void<\/span> <\/span>handleComplete<\/span>(Future<<\/span>ConversionResult<\/span>> <\/span>future<\/span>) {<\/span><\/span>\n        <\/span>if<\/span> (future.<\/span>isDone<\/span>()){<\/span><\/span>\n            <\/span>try<\/span> {<\/span><\/span>\n                queue.<\/span>add<\/span>(future.<\/span>get<\/span>());<\/span><\/span>\n            } <\/span>catch<\/span> (Exception <\/span>e<\/span>) {<\/span><\/span>\n                System.out.<\/span>println<\/span>(<\/span>"Exception converting result."<\/span>);<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> Queue<<\/span>ConversionResult<\/span>> <\/span>getResults<\/span>(){ <\/span>return<\/span> queue;}<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
In line (1), I create a subclass of a StructuredTaskScope <\/em>to later override the handleComplete <\/em>method. As the generic, we use the specialized record ConversionResult<\/em>, which gives us a way to store the result in a structured way. In line (3), I define a ConcurrentLinkedQueue <\/em>to later store the result in. This needs to be a concurrent data structure, because some Callables <\/em>might complete at the same time. If you used a regular ArrayList <\/em>here, you might get the infamous ConcurrentModificationException <\/em>if two threads inserted an element into the list at the same time. From line (5) to (14) I override the handleComplete <\/em>method and put the result into the queue. Finally, there is a getter for the results queue in line (16). <\/p>\n\n\n\n
Let’s modify our example to use the CurrencyConverterScope <\/em>and the ConversionResult<\/em>. I will also use the second business method of our converter service, which already uses the ConversionResult<\/em>.<\/p>\n\n\n\n
<\/path><\/path><\/svg><\/span>
try<\/span>(<\/span>var<\/span> <\/span>scope<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>CurrencyConverterScope<\/span>()){<\/span><\/span>\n    scope.<\/span>fork<\/span>( () <\/span>-><\/span> currencyService.<\/span>getEuroConvertionResult<\/span>(<\/span>100d<\/span>,USD) );<\/span><\/span>\n    scope.<\/span>fork<\/span>( () <\/span>-><\/span> currencyService.<\/span>getEuroConvertionResult<\/span>(<\/span>100d<\/span>,JPY) );<\/span><\/span>\n    scope.<\/span>fork<\/span>( () <\/span>-><\/span> currencyService.<\/span>getEuroConvertionResult<\/span>(<\/span>100d<\/span>,EUR) );<\/span><\/span>\n    scope.<\/span>fork<\/span>( () <\/span>-><\/span> currencyService.<\/span>getEuroConvertionResult<\/span>(<\/span>100d<\/span>,CAD) );<\/span><\/span>\n    scope.<\/span>fork<\/span>( () <\/span>-><\/span> currencyService.<\/span>getEuroConvertionResult<\/span>(<\/span>100d<\/span>,GBP) );<\/span><\/span>\n<\/span>\n    scope.<\/span>join<\/span>();<\/span><\/span>\n<\/span>\n    <\/span>for<\/span>(<\/span>var<\/span> <\/span>result<\/span> <\/span>:<\/span> scope.<\/span>getResults<\/span>()) {<\/span><\/span>\n        System.out.<\/span>println<\/span>(result);<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
The code looks much cleaner like this. We use the second method of our conversion service to store the result and input parameters in a ConversionResult<\/em>, which are later returned by our Futures<\/em>. All ConversionResults <\/em>are available by the getResults <\/em>method of our custom scope.  This way we encapsulated all logic concerning the threading and result processing inside the CurrencyConverterScope<\/em>. <\/p>\n\n\n\n
Conclusion<\/h4>\n\n\n\n
That’s all I want to cover about structured concurrency for today. I think it will provide a nice API to write easy to understand and clean code once it is fully released. It will make concurrent coding a lot more accessible and many drawbacks of the old platform thread model are simply resolved in the background for you when using virtual threads.  There are also quite nice callback methods you can override to encapsulate your result processing and provide results in a convenient way. <\/p>\n\n\n\n
If you want to check out the code examples, you can find them as always in my github repository<\/a>. <\/p>\n","protected":false},"excerpt":{"rendered":"
Another very interesting feature that will most likely be available with Java 21 is the introduction of the Structured Concurrency API developed under JEP 428 by Project Loom. Structured concurrency will greatly simplify the use of virtual threads and provide an API similar to the well know ExecutorService API to execute Callables. If you haven’t […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[9],"tags":[11,4,5,6],"class_list":["post-55","post","type-post","status-publish","format-standard","hentry","category-java-19","tag-incubator","tag-java-19","tag-project-loom","tag-virtual-threads"],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/java-online-training.de\/index.php?rest_route=\/wp\/v2\/posts\/55","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/java-online-training.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/java-online-training.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/java-online-training.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/java-online-training.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=55"}],"version-history":[{"count":35,"href":"https:\/\/java-online-training.de\/index.php?rest_route=\/wp\/v2\/posts\/55\/revisions"}],"predecessor-version":[{"id":281,"href":"https:\/\/java-online-training.de\/index.php?rest_route=\/wp\/v2\/posts\/55\/revisions\/281"}],"wp:attachment":[{"href":"https:\/\/java-online-training.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=55"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/java-online-training.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=55"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/java-online-training.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=55"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
How to make a Maven project that uses preview features to compile your code can be found here<\/a>.<\/p>\n\n\n\n