Chapter 14 ■ Concurrency

5.In your application, there is a producer component that keeps adding new items to a fixed-size queue; the consumer component fetches items from that queue. If the queue is full, the producer has to wait for items to be fetched; if the queue is empty, the consumer has to wait for items to be added.

Which one of the following utilities is suitable for synchronizing the common queue for concurrent use by a producer and consumer?

A.  RecursiveAction

B.  ForkJoinPool C.  Future

D.  Semaphore

E.  TimeUnit

Answer:

D.  Semaphore

(The question is a classic producer–consumer problem that can be solved by using semaphores. The objects of the synchronizer class java.util.concurrent.Semaphore can be used to guard the common queue so that the producer and consumer can synchronize their access to the queue. Of the given options, semaphore is the only synchronizer; other options are unrelated to providing synchronized access to a queue.

Option A) RecursiveAction supports recursive ForkJoinTask, and option B) ForkJoinPool provides help in running a ForkJoinTask in the context of the Fork/Join framework. Option C) Future represents the result of an asynchronous computation whose result will be “available in the future once the computation is complete.” Option E) TimeUnit is an enumeration that provides support for different time units such as milliseconds, seconds, and days.)

Summary

Using java.util.concurrent Collections

•A semaphore controls access to shared resources. A semaphore maintains a counter to specify number of resources that the semaphore controls.

•CountDownLatch allows one or more threads to wait for a countdown to complete.

•The Exchanger class is meant for exchanging data between two threads. This class is useful when two threads need to synchronize between each other and continuously exchange data.

•CyclicBarrier helps provide a synchronization point where threads may need to wait at a predefined execution point until all other threads reach that point.

•Phaser is a useful feature when few independent threads have to work in phases to complete a task.

482

Chapter 14 ■ Concurrency

Applying Atomic Variables and Locks

•Java provides an efficient alternative in the form of atomic variables where one needs to acquire and release a lock just to carry out primitive operations on variables.

•A lock ensures that only one thread accesses a shared resource at a time.

•A Condition supports thread notification mechanism. When a certain condition is not satisfied, a thread can wait for another thread to satisfy that condition; that other thread could notify once the condition is met.

Using Executors and ThreadPools

•The Executors hierarchy abstracts the lower-level details of multi-threaded programming and offers high-level user-friendly concurrency constructs.

•The Callable interface represents a task that needs to be completed by a thread. Once the task completes, the call() method of a Callable implementation returns a value.

•A thread pool is a collection of threads that can execute tasks.

•Future represents objects that contain a value that is returned by a thread in the future.

•ThreadFactory is an interface that is meant for creating threads instead of explicitly creating threads by calling a new Thread().

Using the Parallel Fork/Join Framework

•The Fork/Join framework is a portable means of executing a program with decent parallelism.

•The framework is an implementation of the ExecutorService interface and provides an easy-to-use concurrent platform in order to exploit multiple processors.

•This framework is very useful for modeling divide-and-conquer problems.

•The Fork/Join framework uses the work-stealing algorithm: when a worker thread completes its work and is free, it takes (or “steals”) work from other threads that are still busy doing some work.

•The work-stealing technique results in decent load balancing thread management with minimal synchronization cost.

•ForkJoinPool is the most important class in the Fork/Join framework. It is a thread pool for running fork/join tasks—it executes an instance of ForkJoinTask. It executes tasks and manages their lifecycles.

•ForkJoinTask<V> is a lightweight thread-like entity representing a task that defines methods such as fork() and join().

483

Chapter 15

OCPJP 7 Quick Refresher

This chapter provides a quick summary to important points to remember from the OCPJP 7 exam perspective. A summarized list of exam tips is also compiled to help you prepare for the exam. Read this chapter the day before taking the exam. Good luck!

Exam Tips 

•Most questions in the OCPJP 7 exam are about predicting the behavior of the program. In our experience taking the exam, we found that if we read the question and immediately start looking at the answers, the answers confused us in many cases (leading us

to selecting the wrong answer!). To avoid this confusion, we suggest an alternative approach: first understand the question and arrive at an answer, and then check the options to see if there is a matching answer. This is especially important for questions related to pattern matching (in regex, glob, etc.); if you look at the answers first, they can often mislead you to choosing the wrong answer!

•Questions in the OCPJP 7 exam clearly mention the number of correct options that you should select for a given question. The exam software will not warn you if you choose only one option for a question that requires selecting multiple answers and vice versa.

So, beware of this pitfall, and ensure that you select only the exact number of answers as explicitly mentioned for each question.

•While taking the OCPJP 7 exam, you can mark the question to revisit later if you’re not sure of the answer. The exam software provides a check box at the top right side of the screen.

•There are many questions in the exam that are long or time-consuming. If you’re taking too long to read or answer a particular question, mark it for revisiting later.

•Many of the questions ask you to predict the behavior of a program, and most of the options will provide possible output with one of the options mentioning that the prgoram will result in a compiler error (without giving the specific compiler error). It is a common mistake to be “optimistic” and assume that the program will compile without errors! For example, you know that you will get a compiler error if you try to instantiate an abstract class; however, in a question that presents you a 20-25 lines program, it is easy to miss an attempt to instantiate an abstract class if you directly look at the list of answers. To avoid this pitfall, we recommend that you first look for possible compiler errors in the program before checking other options relating to the output of the program.

485

Chapter 15 ■ OCPJP 7 Quick Refresher

•Look out for potential exceptions that the program can throw before looking at the answers. For example, check if the program could result in an

IllegalThreadStateException for the program relating to thread state transition. Similarly, programs that perform downcasts without checking the type first can result in a ClassCastException. Yes, it is obvious, but in our experience in taking the exam, we found that it was easy to miss out on such common runtime exceptions when answering the questions.

•There are many APIs in which arguments are passed to specify the range. For example, the subpath(int beginIndex, int endIndex) method in the Path interface takes beginIndex and endIndex as arguments. In this case, note that beginIndex is the index of the first name element, inclusive of itself, and endIndex is the index of the last name element, exclusive of itself. In other words, in most Java APIs methods that specify a range (such as the nextInt() method in Random), the first argument is inclusive and the second argument is exclusive. When answering a question whose answer depends on the range, and when you don’t know if the arguments are inclusive or not, an educated guess would be to treat the first argument as inclusive and the second argument as exclusive!

•In questions involving assertions, the question will mention if assertions are enabled or disabled by mentioning if the –ea or –da option is passed in the command line (if it is not explicitly mentioned, remember that the assertions are disabled in a program by default). Answer questions about the behavior of the program, keeping in mind whether assertions are enabled or disabled.

•For questions relating to passing null to APIs, do not always assume that the API will throw a NullPointerException. For example, the add() method in ArrayList accepts null arguments and does not throw a NullPointerException. In general, while reviewing the behavior of methods in the Java library, give a special attention to the corner cases and the exceptions that the methods can throw.

•While reviewing APIs, understand the differences between similar looking classes or methods (for example, similarities and differences between the Comparable and Comparator interfaces).

•When predicting the output of the programs relating to threads and concurrency, give special attention to how thread scheduling and thread interleaving can affect the output.

•When taking the exam, you may be given an erasable scribble board. You may find it handy for answering certain kinds of questions. For example, we recommend that you to quickly draw the class relationships on the board for selecting the correct option(s) for questions relating to class relationships (such as is-a and has-a relationships).

Chapter 3: Java Class Design

•You cannot access the private methods of the base class in the derived class.

•You can access the protected method from a class in the same package (just like package private or default) as well as a derived class (even belonging to another package).

•You can have overloaded constructors. You can call a constructor of the same class in another constructor using the this keyword.

486