As I explained in a previouse entry, since java 1.5 there are new classes and interfaces to help the implementation of parallel systems. These structures are found in the
java.util.concurrent package. But how are these structures to be used.
The package description recalls the main types of interfaces and classes in this package:
- executors
- queues
- concurrent collections
- synchronizers
- atomic (in package: java.util.concurrent.atomic )
- locks (in package: java.util.concurrent.locks )
Of course, the structures discussed in this package have somewhat similar to the one found in typical kernel discussions: work queues and semaphores...
Let us now take a look at the different parts.
Executors
Executors are containers taking care of the execution of tasks, just as SwingUtilities used to do it. Different kinds of executors are imaginable:
- DirectExecutor (performing the task but not asynchronously)
- ThreadPerTaskExecutor (one thread is created for each task to be performed)
- SerialExecutor (each task is performed sequentially)
- ThreadPoolExecutor (executor performing using a pool of threads)
- ScheduledThreadPoolExecutor (executor performing using a pool of threads at certain specified moments or periodically)
The implentations of the
java.util.concurrent package implement the ExecutorService interface which provides a number of supplementary methods.
Queues
Another useful data structure for performing task in parallel and asynchronously are queues (also known as FIFO data structures). The
java.util.concurrent package provides a number of data structures for this purpose too. One particular kind of FIFO are blocking queues, for which five different versions exist:
- LinkedBlockingQueue
- ArrayBlockingQueue
- SynchronousQueue
- PriorityBlockingQueue
- DelayQueue
The first two are queue data structure backed by a linked list, respectively an array. The synchronous queue is special in the way that the queue accept elements only if at the same times elements are removed from the queue on the other end (though I must admit I still need to look at how this actually performed).
The priority blocking queue is a FIFO with priority to use the same ordering as a PriorityQueue.
Finally, the delay queue is a blocking queue only providing elements when a certain delay as passed for the element to be retrieved.
Synchronizers
A number of possible techniques can be used to synchronize threads. Among these are semaphores which we discussed in the linux kernel context. Other types provided by the
java.util.concurrent package, such as the CountDownLatch, used to block some actions until a number of events or elements have been counted, the CyclicBarrier, which is a resettable multiway synchronization mechanism, an exchanger to allow threads to exchange objects at some definite point and the already mentioned locks.
Concurrent Collections
The java.util Collection Framework already contained a number of snychronized or synchronizable classes. However, the
java.util.concurrent package introduces new structures useful in a multithreaded context:
- ConcurrentHashMap,
- ConcurrentSkipListMap,
- ConcurrentSkipListSet,
- CopyOnWriteArrayList, and
- CopyOnWriteArraySet
The synchronization approach of the usual synchonized classes came with a drawback for the scalability, because they imposed a strong check on the serializability of the action performed on the data structure. The Concurrent implementations are on contrary not as restrcited. It remains in the job of the developper to know when to prefer which implementation.
Timing Units
The
java.util.concurrent package also introduces a new class
TimingUnit to provide different kind of granularity as to which unit of interval for time measurements should be used. Here again, it would be useful to take a look at the implementation of the kernel and compare.
Atomic and Locks
Since atomic variables and locks are in other packages, I will describe them in other entries.
However, it is again interesting to note that the same topics were already discussed in other entries of this blog.
