JSR-236
JSR 166 added support for concurrency utilities in the Java platform. The JSR 236’s, also known as Concurrency Utilities for Java EE, goal was to extend that support to the Java EE platform by adding asynchronous abilities to different application components.
You are might be asking “Why are we talking about JSR in a Spring book?” Spring’s scheduler adapter is based on standard JSR-236 API and is the building block of Spring’s abstraction on concurrency.
JSR 237
JCP defines JSR 237 as follows:
A work manager API providing for execution of concurrent work items within managed environments.
– jcp.org
Foo-CommonJ is a JSR 237 Timer and WorkManager implementation. It is designed to be used in containers that do not come with their own implementation – mainly plain servlet containers like Tomcat. It can also be used in fully blown JEE applications servers that do not have a WorkManager API or have a non-standard API like JBoss.
The common use case is that a Servlet or JSP needs to aggregate data from multiple sources and display them in one page. Doing your own threading inside a managed environment like a J2EE container is inappropriate and should never be done. In this case the WorkManager API can be used to retrieve the data in parallel.
Java Concurrency APIs
As a general best practice you shouldn’t use threads directly in your application. Thread management is low-level in nature and should be delegated to the framework to handle it transparently. With Java version 5 and 6 there has been higher-level support from the language itself to address this to a greater level. All the support by the language is inside the java.util.concurrent package.
Java also provides the concept of locks, wherein it allows parts of a program to be accessed by various threads at the same time. Use of keyword “synchronized”, does this for you in transparent manner.
The Java programming language provides two basic synchronization idioms: synchronized methods and synchronized statements. To make a method synchronized, simply add the synchronized keyword to its declaration as shown in Listing 20-3 below.
Listing 20-3. Code snippet showing usage of synchronized keyword in method declaration
|
1 2 3 4 5 6 7 8 9 10 11 12 |
public class LoyaltyPointsCalculator { private int loyaltyPoints = 0; public synchronized void incrementPoints() { loyaltyPoints ++; } public synchronized void decrementPoints() { loyaltyPoints --; } public synchronized int totalLoyaltyPoints() { return loyaltyPoints; } } |
Another way to create synchronized code is with synchronized statements. Unlike synchronized methods, synchronized statements must specify the object that provides the intrinsic lock. In Listing 20-4 the statements within the synchronized block will be executed if the block has lock to the executing customer object.
Listing 20-4. Usage of synchronized statements
|
1 2 3 4 5 6 7 |
public void addCustomer(Customer customer) { synchronized(this) { lastName = customer.lastName; nameCount++; } lstNameList.add(customer.lastName); } |
Apart from the low level concurrency suport that we have seen all this while which Java offers, with Java 5 it also offers high level concurrency support. As part of Java 5 the following concurrent data structures have been introduced:
- Executors
- Concurrent Collections
- Lock Objects
- Atomic Variables
Since these are the building blocks of concurrency in Java, we will cover these sections in detail in next sections.
Executors
Java provides high-level API’s for managing and launching threads. Implementations provided by Java are capable of handling thread pools which can be used in large-scale application having high scalability. In small stand-alone applications it makes sense to mix threading logic with the actual business logic. But for large-scale application it is advisable to separate the threading logic from the core business logic. The objects which encapsulate this threading logic are called executors. To describe executors in detail, I would like to introduce you to some concepts which are very relevant in this context. The following sections describe these concepts in some detail for your understanding.
Executor Interfaces
The three main interfaces in the java.util.concurrent package are as follows:
- Executor Interface
- ExecutorService Interface
- ScheduledExecutorService Interface
Executor Interface
This interface provides a way of decoupling task submission from the mechanics of how each task will be run. An Executor can be used instead of explicitly creating threads and in place of using thread’s start method, executors execute method can be called. Listing 20-5 shows the Executor interface. The Executor interface does not strictly require that execution be asynchronous, instead it can run the submitted task immediately in the caller’s thread.
Listing 20-5. Executor interface source
|
1 2 3 4 |
package java.util.concurrent; public interface Executor{ void execute(Runnable command); } |
The command in the execute method will run in a new thread, a pooled thread, or the calling thread, acccording to the Executor implementation.
Page Visitors: 25295
Tomcy John
Latest posts by Tomcy John (see all)
- A Guide to Continuous Improvement for Architects - February 2, 2023
- Cloud-first Architecture Strategy - January 26, 2023
- Architecture Strategy and how to create One - January 24, 2023