ChaPTer 15 ■ OCPJP 7 QuICk reFreSher

•The assert statement is of two forms: the one that takes a Boolean argument and the other one that takes an additional string argument.

•If the Boolean condition given in the assert argument fails (i.e., evaluates to false), the program will terminate after throwing an AssertionError. It is not advisable to catch and recover from when an AssertionError is thrown by the program.

•By default, assertions are disabled at runtime. You can use the command-line arguments –ea (for enabling asserts) and –da (for disabling asserts) and their variants when you invoke the JVM.

Chapter 12: Localization

•A locale represents a language, culture, or country; the Locale class in Java provides an abstraction for this concept.

•Each locale can have three entries: the language, country, and variant. You can use standard codes available for language and country to form locale tags. There are no standard tags for variants; you can provide variant strings based on your need.

•There are many ways to create or get a Locale object corresponding to a locale:

•Use the constructor of the Locale class.

•Use the forLanguageTag(String languageTag) method in the Locale class.

•Build a Locale object by instantiating Locale.Builder and then calling setLanguageTag() from that object.

•Use the predefined static final constants for locales in the Locale class.

•A resource bundle is a set of classes or property files that help define a set of keys and map those keys to locale-specific values.

•The class ResourceBundle has two derived classes: PropertyResourceBundle and ListResourceBundle. You can use ResourceBundle.getBundle() to automatically load a bundle for a given locale.

•The PropertyResourceBundle class provides support for multiple locales in the form of property files. For each locale, you specify the keys and values in a property file for that locale. You can use only Strings as keys and values.

•The naming convention for a fully qualified resource bundle name is packagequalifier. bundlename + "_" + language + "_" + country + "_" + (variant + "_#" | "#") + script + "-" + extensions.

•The search sequence to look for a matching resource bundle is presented here. Search starts from Step 1. If at any step the search finds a match, the resource bundle is loaded. Otherwise, the search proceeds to the next step.

•Step 1: The search starts by looking for an exact match for the resource bundle with the full name.

•Step 2: The last component (the part separated by _) is dropped and the search is repeated with the resulting shorter name. This process is repeated till the last locale modifier is left.

•Step 3: The search is restarted using the full name of the bundle for the default locale.

•Step 4: Search for the resource bundle with just the name of the bundle.

•Step 5: The search fails, throwing a MissingBundleException.

501

Chapter 15 ■ OCPJP 7 Quick Refresher

•For the resource bundles implemented as classes extended from ListResourceBundles, Java uses the reflection mechanism to find and load the class. You need to make sure that the class is public so that the reflection mechanism will find the class.

•To handle date and time, numbers, and currencies in a culture-sensitive way, you can use the java.text.Format class and its two main derived classes, NumberFormat and DateFormat. Figure 15-3 shows Format and its important derived classes.

Figure 15-3.  The Format class and its important derived classes

•The NumberFormat class provides methods to format or parse numbers. “Formatting” means converting a numeric value to a textual form suitable for displaying to users; “parsing” means converting a number back to numeric form for use in the program. The parse() method returns a Number if successful; otherwise it throws ParseException (a checked exception).

•NumberFormat has many factory methods: getInstance(), getCurrencyInstance(), getIntegerInstance(), and getPercentInstance().

•The Currency class provides good support for handling currency values in a locale-sensitive way.

•The DateFormat class provides support for processing date and time in a locale-sensitive manner.

•DateFormat has three overloaded factory methods—getDateInstance(), getTimeInstance(), and getDateTimeInstance()—that return DateFormat instances for processing date, time, and both date and time, respectively.

•SimpleDateFormat (derived from DateFormat) uses the concept of a pattern string to support custom formats for date and time. Here is the list of important letters and their meanings for creating patterns for dates:

502

Chapter 15 ■ OCPJP 7 Quick Refresher

w Week (in year)

WWeek (in month)

DDay (in year)

d Day (in month)

FDay of week in month

EDay name in week

u Day number of week (value range 1–7)

•Similarly, here are the important letters useful for defining a custom time pattern: a Marker for the text am/pm marker

HHour (value range 0–23)

Chapter 13: Threads

•You can create classes that are capable of multi-threading by implementing the Runnable interface or by extending the Thread class.

•Always implement the run() method. The default run() method in Thread does nothing.

•Call the start() method and not the run() method directly in code. (Leave it to the JVM to call the run() method.)

•Every thread has thread name, priority, and thread-group associated with it; the default toString() method implementation in Thread prints them.

•If you call the sleep() method of a thread, the thread does not release the lock and it holds on to the lock.

•You can use the join() method to wait for another thread to terminate.

•In general, if you are not using the “interrupt” feature in threads, it is safe to ignore the InterruptedException; however it’s better still to log or print the stack trace if that exception occurs.

•Threads are non-deterministic: in many cases, you cannot reproduce problems like deadlocks or data races by running the program again.

•There are three basic thread states: new, runnable and terminated. When a thread is just created, it is in new state; when it is ready to run or running, it is in runnable state. When the thread dies, it’s in terminated state.

•The runnable state has two states internally (at the OS level): ready and running states.

•A thread will be in the blocked state when waiting to acquire a lock. The thread will be in the timed_waiting state when timeout is given for calls like wait. The thread will be in the waiting state when, for example, wait() is called (without time out value).

•You will get an IllegalThreadStateException if your operations result in invalid thread state transitions.

503

Chapter 15 ■ OCPJP 7 Quick Refresher

•Simultaneous reads and writes to common resources shared by multiple threads may lead to the “data race” (also known as “race condition” and “race hazard”) problem.

•You must use thread synchronization (i.e., locks) to access shared values and avoid data races. Java provides thread synchronization features to provide protected access to shared resources—namely, synchronized blocks and synchronized methods.

•Using locks can introduce problems such as deadlocks. When a deadlock happens, the process will hang and will never terminate.

•A deadlock typically happens when two (or more) threads acquire locks in opposite order. When one thread has acquired one lock and waits for another lock, another thread has acquired that other lock and waits for the first lock to be released. So, no progress is made and the program deadlocks.

•To avoid deadlocks, it is better to avoid acquiring multiple locks. When you must acquire such multiple locks, ensure that they are acquired in the same order in all places in the program.

•When a thread has to wait for a particular condition or event to be satisfied by another thread, you can use a wait/notify mechanism as a communication mechanism between threads.

•When a thread needs to wait for a particular condition/event, you can call wait() with or without timeout value specified.

•To avoid notifications getting lost, it is better to always use notifyAll() instead of notify().

Chapter 14: Concurrency

•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 them and also 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 a few independent threads have to work in phases to complete a task.

•Instead of acquiring and releasing a lock just to carry out operations on primitive type variables, Java provides an efficient alternative in the form of atomic variables.

•Classes AtomicInteger and AtomicLong extend from the Number class. All other classes in the java.util.concurrent.atomic subpackage inherit directly from the Object class and do not extend the Number class.

•Conditions support 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.

•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.

504

Chapter 15 ■ OCPJP 7 Quick Refresher

•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 new Thread().

•The Fork/Join framework allows for exploiting parallelism (available in the form of multiple cores) for certain kinds of tasks. A task that can be modeled as a divide-and-conquer problem is suitable to be used with Fork/Join framework.

•The Fork/Join framework is an implementation of the ExecutorService interface.

•The Fork/Join framework uses the work-stealing algorithm—in other words, 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.

•In Fork/Join, it looks acceptable to call fork() for both the subtasks (if you are splitting in two subtasks) and call join() two times. It is correct—but inefficient. Why? In this case, the original thread will be waiting for the other two tasks to complete, which is inefficient considering task creation cost. That is why you call fork() once and call compute() for the second task.

•ForkJoinPool is the most important class for the Fork/Join framework. It is a thread pool for running fork/join tasks—in other words, 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().

505