
- •Contents at a Glance
- •Contents
- •About the Authors
- •About the Technical Reviewer
- •Acknowledgments
- •Introduction
- •Oracle Java Certifications: Overview
- •FAQ 1. What are the different levels of Oracle Java certification exams?
- •FAQ 4. Is OCPJP 7 prerequisite for other Oracle certification exams?
- •FAQ 5. Should I take the OCPJP 7 or OCPJP 6 exam?
- •The OCPJP 7 Exam
- •FAQ 7. How many questions are there in the OCPJP 7 exam?
- •FAQ 8. What is the duration of the OCPJP 7 exam?
- •FAQ 9. What is the cost of the OCPJP 7 exam?
- •FAQ 10. What are the passing scores for the OCPJP 7 exam?
- •FAQ 11. What kinds of questions are asked in the OCPJP 7 exam?
- •FAQ 12. What does the OCPJP 7 exam test for?
- •FAQ 13. I’ve been a Java programmer for last five years. Do I have to prepare for the OCPJP 7 exam?
- •FAQ 14. How do I prepare for the OCPJP 7 exam?
- •FAQ 15. How do I know when I’m ready to take the OCPJP 7 exam?
- •Taking the OCPJP 7 Exam
- •FAQ 16. What are my options to register for the exam?
- •FAQ 17. How do I register for the exam, schedule a day and time for taking the exam, and appear for the exam?
- •The OCPJP 7 Exam: Pretest
- •Answers with Explanations
- •Post-Pretest Evaluation
- •Essentials of OOP
- •FunPaint Application: An Example
- •Foundations of OOP
- •Abstraction
- •Encapsulation
- •Inheritance
- •Polymorphism
- •Class Fundamentals
- •Object Creation
- •Constructors
- •Access Modifiers
- •Public Access Modifier
- •Private Access Modifier
- •Protected and Default Access Modifier
- •Overloading
- •Method Overloading
- •Constructor Overloading
- •Overload resolution
- •Points to Remember
- •Inheritance
- •Runtime Polymorphism
- •An Example
- •Overriding Issues
- •Overriding: Deeper Dive
- •Invoking Superclass Methods
- •Type Conversions
- •Upcasts and Downcasts
- •Casting Between Inconvertible Types
- •Using “instanceof” for Safe Downcasts
- •Java Packages
- •Working with Packages
- •Static Import
- •Summary
- •Abstract Classes
- •Points to Remember
- •Using the “final” Keyword
- •Final Classes
- •Final Methods and Variables
- •Points to Remember
- •Using the “static” Keyword
- •Static Block
- •Points to Remember
- •Flavors of Nested Classes
- •Static Nested Classes (or Interfaces)
- •Points to Remember
- •Inner Classes
- •Points to Remember
- •Local Inner Classes
- •Points to Remember
- •Anonymous Inner Classes
- •Points to Remember
- •Enum Data Types
- •Points to Remember
- •Summary
- •Interfaces
- •Declaring and Using Interfaces
- •Points to Remember
- •Abstract Classes vs. Interfaces
- •Choosing Between an Abstract Class and an Interface
- •Object Composition
- •Composition vs. Inheritance
- •Points to Remember
- •Design Patterns
- •The Singleton Design Pattern
- •Ensuring That Your Singleton Is Indeed a Singleton
- •The Factory Design Pattern
- •Differences Between Factory and Abstract Factory Design Patterns
- •The Data Access Object (DAO) Design Pattern
- •Points to Remember
- •Summary
- •Generics
- •Using Object Type and Type Safety
- •Using the Object Class vs. Generics
- •Container Implementation Using the Object Class
- •Container Implementation Using Generics
- •Creating Generic Classes
- •Diamond Syntax
- •Interoperability of Raw Types and Generic Types
- •Generic Methods
- •Generics and Subtyping
- •Wildcard Parameters
- •Limitations of Wildcards
- •Bounded Wildcards
- •Wildcards in the Collections Class
- •Points to Remember
- •The Collections Framework
- •Why Reusable Classes?
- •Basic Components of the Collections Framework
- •Abstract Classes and Interfaces
- •Concrete Classes
- •List Classes
- •ArrayList Class
- •The ListIterator Interface
- •The LinkedList Class
- •The Set Interface
- •The HashSet Class
- •The TreeSet Class
- •The Map Interface
- •The HashMap Class
- •Overriding the hashCode() Method
- •The NavigableMap Interface
- •The Queue Interface
- •The Deque Interface
- •Comparable and Comparator Interfaces
- •Algorithms (Collections Class)
- •The Arrays Class
- •Methods in the Arrays Class
- •Array as a List
- •Points to Remember
- •Summary
- •Generics
- •Collections Framework
- •Processing Strings
- •String Searching
- •The IndexOf() Method
- •The regionMatches() Method
- •String Parsing
- •String Conversions
- •The Split() Method
- •Regular Expressions
- •Understanding regex Symbols
- •Regex Support in Java
- •Searching and Parsing with regex
- •Replacing Strings with regex
- •String Formatting
- •Format Specifiers
- •Points to Remember
- •Summary
- •Reading and Writing from Console
- •Understanding the Console Class
- •Formatted I/O with the Console Class
- •Special Character Handling in the Console Class
- •Using Streams to Read and Write Files
- •Character Streams and Byte Streams
- •Character Streams
- •Reading Text Files
- •Reading and Writing Text Files
- •“Tokenizing” Text
- •Byte Streams
- •Reading a Byte Stream
- •Data Streams
- •Writing to and Reading from Object Streams: Serialization
- •Serialization: Some More Details
- •Points to Remember
- •Summary
- •A Quick History of I/O APIs
- •Using the Path Interface
- •Getting Path Information
- •Comparing Two Paths
- •Using the Files Class
- •Checking File Properties and Metadata
- •Copying a File
- •Moving a File
- •Deleting a File
- •Walking a File Tree
- •Revisiting File Copy
- •Finding a File
- •Watching a Directory for Changes
- •Points to Remember
- •Summary
- •Introduction to JDBC
- •The Architecture of JDBC
- •Two-Tier and Three-Tier JDBC Architecture
- •Types of JDBC Drivers
- •Setting Up the Database
- •Connecting to a Database Using a JDBC Driver
- •The Connection Interface
- •Connecting to the Database
- •Statement
- •ResultSet
- •Querying the Database
- •Updating the Database
- •Getting the Database Metadata
- •Points to Remember
- •Querying and Updating the Database
- •Performing Transactions
- •Rolling Back Database Operations
- •The RowSet Interface
- •Points to Remember
- •Summary
- •Define the Layout of the JDBC API
- •Connect to a Database by Using a JDBC driver
- •Update and Query a Database
- •Customize the Transaction Behavior of JDBC and Commit Transactions
- •Use the JDBC 4.1 RowSetProvider, RowSetFactory, and RowSet Interfaces
- •Introduction to Exception Handling
- •Throwing Exceptions
- •Unhandled Exceptions
- •Try and Catch Statements
- •Programmatically Accessing the Stack Trace
- •Multiple Catch Blocks
- •Multi-Catch Blocks
- •General Catch Handlers
- •Finally Blocks
- •Points to Remember
- •Try-with-Resources
- •Closing Multiple Resources
- •Points to Remember
- •Exception Types
- •The Exception Class
- •The RuntimeException Class
- •The Error Class
- •The Throws Clause
- •Method Overriding and the Throws Clause
- •Points to Remember
- •Custom Exceptions
- •Assertions
- •Assert Statement
- •How Not to Use Asserts
- •Summary
- •Introduction
- •Locales
- •The Locale Class
- •Getting Locale Details
- •Resource Bundles
- •Using PropertyResourceBundle
- •Using ListResourceBundle
- •Loading a Resource Bundle
- •Naming Convention for Resource Bundles
- •Formatting for Local Culture
- •The NumberFormat Class
- •The Currency Class
- •The DateFormat Class
- •The SimpleDateFormat Class
- •Points to Remember
- •Summary
- •Introduction to Concurrent Programming
- •Important Threading-Related Methods
- •Creating Threads
- •Extending the Thread Class
- •Implementing the Runnable Interface
- •The Start( ) and Run( ) Methods
- •Thread Name, Priority, and Group
- •Using the Thread.sleep() Method
- •Using Thread’s Join Method
- •Asynchronous Execution
- •The States of a Thread
- •Two States in “Runnable” State
- •Concurrent Access Problems
- •Data Races
- •Thread Synchronization
- •Synchronized Blocks
- •Synchronized Methods
- •Synchronized Blocks vs. Synchronized Methods
- •Deadlocks
- •Other Threading Problems
- •Livelocks
- •Lock Starvation
- •The Wait/Notify Mechanism
- •Let’s Solve a Problem
- •More Thread States
- •timed_waiting and blocked States
- •waiting State
- •Using Thread.State enum
- •Understanding IllegalThreadStateException
- •Summary
- •Using java.util.concurrent Collections
- •Semaphore
- •CountDownLatch
- •Exchanger
- •CyclicBarrier
- •Phaser
- •Concurrent Collections
- •Apply Atomic Variables and Locks
- •Atomic Variables
- •Locks
- •Conditions
- •Multiple Conditions on a Lock
- •Use Executors and ThreadPools
- •Executor
- •Callable, Executors, ExecutorService, ThreadPool, and Future
- •ThreadFactory
- •The ThreadLocalRandom Class
- •TimeUnit Enumeration
- •Use the Parallel Fork/Join Framework
- •Useful Classes of the Fork/Join Framework
- •Using the Fork/Join Framework
- •Points to Remember
- •Summary
- •Using java.util.concurrent Collections
- •Applying Atomic Variables and Locks
- •Using Executors and ThreadPools
- •Using the Parallel Fork/Join Framework
- •Chapter 3: Java Class Design
- •Chapter 4: Advanced Class Design
- •Chapter 5: Object-Oriented Design Principles
- •Chapter 6: Generics and Collections
- •Chapter 7: String Processing
- •Chapter 8: Java I/O Fundamentals
- •Chapter 9: Java File I/O (NIO.2)
- •Chapter 10: Building Database Applications with JDBC
- •Chapter 11: Exceptions and Assertions
- •Chapter 12: Localization
- •Chapter 13: Threads
- •Chapter 14: Concurrency
- •OCPJP7 Exam (1Z0-804 a.k.a. Java SE 7 Programmer II) Topics
- •OCPJP 7 Exam (1Z0-805, a.k.a. Upgrade to Java SE 7 Programmer) Topics
- •Answers and Explanations
- •Answer Sheet
- •Answers and Explanations
- •Index
Chapter 13 ■Threads
In this chapter, you’ll also be using some threading related methods in the Object class shown in Table 13-2.
Table 13-2. Important Threading-Related Methods in the Object Class
|
|
|
Method |
Method Type |
Short Description |
void wait(), |
Overloaded instance |
The current thread should have acquired a lock on this |
void wait(long), |
methods |
object before calling any of the wait methods. |
void wait(long, int) |
|
If wait() is called, the thread waits infinitely until some |
|
|
|
|
|
other thread notifies (by calling the notify()/notifyAll() |
|
|
method) for this lock. |
|
|
The method wait(long) takes milliseconds as an argument. |
|
|
The thread waits till it is notified or the timeout happens. |
|
|
The wait(long, int) method is similar to wait(long) and |
|
|
additionally takes nanoseconds as an argument. |
void notify() |
Instance method |
The current thread should have acquired a lock on this |
|
|
object before calling notify(). The JVM chooses a single |
|
|
thread that is waiting on the lock and wakes it up. |
void notifyAll() |
Instance method |
The current thread should have acquired a lock before |
|
|
calling notifyAll(). The JVM wakes up all the threads |
|
|
waiting on a lock. |
|
|
|
Creating Threads
A Java thread can be created in two ways: by extending the Thread class or by implementing the Runnable interface. Both of them have a method named run(). The JVM will call this method when a thread starts executing. You can think of the run() method as a starting point for the execution of a thread, just like the main() method, which is the starting point for the execution of a program. You’ll first see two examples for creating threads—extend Thread and implement Runnable—before learning the differences between them.
Extending the Thread Class
You’ll first consider how to extend the Thread class. You need to override the run() method when you want to extend the Thread class. If you don’t override the run() method, the default run() method from the Thread class will be called, which does nothing.
To override the run() method, you need to declare it as public; it takes no arguments and has a void return type—in other words, it should be declared as public void run().
A thread can be created by invoking the start() method on the object of the Thread class (or its derived class). When the JVM schedules the thread, it will move the thread to a runnable state and then execute the run() method. (We’ll discuss thread states later in this chapter). When the run() method completes its execution and returns, the thread will terminate. Listing 13-1 is the first example of multi-threading.
395
Chapter 13 ■Threads
Listing 13-1. MyThread1.java
class MyThread1 extends Thread { public void run() {
try {
sleep(1000);
}
catch (InterruptedException ex) { ex.printStackTrace();
//ignore the InterruptedException - this is perhaps the one of the
//very few of the exceptions in Java which is acceptable to ignore
}
System.out.println("In run method; thread name is: " + getName());
}
public static void main(String args[]) { Thread myThread = new MyThread1(); myThread.start();
System.out.println("In main method; thread name is: " + Thread.currentThread().getName());
}
}
This program prints the following:
In main method; thread name is: main In run method; thread name is: Thread-0
In this example, the MyThread1 class extends the Thread class. You have overridden the run() method in this class. This run() method will be called when the thread runs. In the main() function, you create a new thread and start it using the start() method. An important note: you do not invoke the run() method directly. Instead you start the thread using the start() method; the run() method is invoked automatically by the JVM. We’ll revisit this
topic later.
For printing the name of the thread, you can use the instance method getName(), which returns a String. Since main() is a static method, you don’t have access to this reference. So you get the current thread name using the static method currentThread() in the Thread class (which returns a Thread object). Now you can call getName on that returned object. As you’ll see later, the main() method is also executed as a thread! However, inside the run() method, you can directly call the getName() method: MyThread1 extends Thread, so all base class members are available in
MyThread1 also.
The program prints messages from both the main thread and myThread (that you created in main). The name of the thread printed is Thread-0. You’ll see the default naming conventions for threads a little later.
Figure 13-1 shows how this program executes and prints the output. Note that the main thread and the myThread1 thread execute at the same time (i.e., concurrently), as shown in the diagram. If you try this program a couple of times, you’ll either get the output shown above, or the order of these two statements might be reversed (depending on which thread is scheduled first for executing this statement). You’ll study this non-deterministic behavior a little later in this chapter.
396

Chapter 13 ■Threads
Main thread starts.
Thread myThread = new MyThread1();
|
myThread.start(); |
|
JVM spawns a new thread and invokes the |
Main thread continues |
run() method. |
|
|
execution |
System.out.printIn("In run method; |
|
thread name is: " + getName()); |
System.out.printIn("In main method;thread name is: " +
Thread.currentThread().getName());
Figure 13-1. Spawning a new thread from the main method
Implementing the Runnable Interface
The Thread class itself implements the Runnable interface. Instead of extending the Thread class, you can implement the Runnable interface. The Runnable interface declares a sole method, run().
// in java.lang package public interface Runnable {
public void run();
}
When you implement the Runnable interface, you need to define the run() method. Remember Runnable does not declare the start() method. So, how do you create a thread if you implement the Runnable interface? Thread has an overloaded constructor, which takes a Runnable object as an argument.
Thread(Runnable target)
You can use this overloaded constructor to create a thread from a class that implements the Runnable interface. First, let’s change the previous program by implementing the Runnable interface. If you change “class
MyThread1 extends Thread” to “class MyThread1 implements Runnable” and compile the code, you get two compiler errors:
MyThread1.java:3: cannot find symbol symbol : method getName() location: class MyThread1
System.out.println("In run method; thread name is: " + this.getName());
MyThread1.java:7: incompatible types found : MyThread1
required: java.lang.Thread
Thread myThread = new MyThread1();
397
i

Chapter 13 ■Threads
The getName() method is available in the Thread class, but the MyThread1 class does not extend Thread any more, so it results in a compiler error. Similarly, the start() method is available in the Thread class, and you don’t have that method any more since you directly implement Runnable.
Listing 13-2 contains the improved version of the program implementing the Runnable interface after fixing these two compiler errors.
Listing 13-2. MyThread2.java
class MyThread2 implements Runnable { public void run() {
System.out.println("In run method; thread name is: " + Thread.currentThread().getName());
}
public static void main(String args[]) throws Exception { Thread myThread = new Thread(new MyThread2()); myThread.start();
System.out.println("In main method; thread name is: " + Thread.currentThread().getName());
}
}
It prints the same output as the previous program:
In main method; thread name is: main In run method; thread name is: Thread-0
You are implementing the run() method like the previous program. However, to get the name of the string, you must follow a round-about route and get the thread name with Thread.currentThread().getName(), as you did in the case of getting the thread name in the main() method. Similarly, in the main() method, to create a thread you must pass the object of the class to the Thread constructor. It was easy and convenient to just create the MyThread1 object and call the start() method on that while extending the Thread class.
Should you extend the Thread or implement the Runnable?
You can either extend the Thread class or implement the Runnable interface to create a thread. So, which one do you choose?
The Thread class has the default implementation of the run() method, so if you don’t provide a definition of the run() method while extending the Thread class, the compiler will not complain. However, the default
implementation in the Thread class does nothing, so if you want your thread to do some meaningful work, you need to still define it. The Runnable interface declares the run() method, so you must define the run() method in your class if you implement the Runnable interface. So it doesn’t matter if you implement Runnable or extend Thread. You have to define the run() method for all practical reasons. In summary, that is not a major difference between extending a Thread and implementing Runnable. How about an inheritance relationship?
Since Java supports only single inheritance, if you extend from Thread, you cannot extend from any other class. Since inheritance is an is-a relationship, you will rarely need the class to have an is-a relationship with the Thread class. So OOP purists argue that you should not extend the Thread class. On the other hand, if you
398