Chapter 9: Threads

Question 1

What are the important thread methods?

Answer 1

• start (start a new thread)
• run (descirbes the thread job)
• sleep (pauses the thread)
• yield (return to the runnable pool, so other threads can run)

Question 2

What are the two ways to define a threads behaviour?

Answer 2

Extend the Thread class
Implement the Runnable interface

Question 3

Considering MyThread contains the Threads behaviour (and extends Thread), what is the result of the following?

Thread t = new Thread(new MyThread());
t.start();

Answer 3

Compiles and runs fine.

Thread implements the Runnable interface by default, so a sub-class of Thread can be passed as the runnable to the new Thread object.

Question 4

What are the four constructors for the Thread class?

Answer 4

new Thread();
new Thread(String name);
new Thread(Runnable runnable);
new Thread(Runnable runnable, String name);

Question 5

How to get the currents Thread name?

Answer 5

Thread t = Thread.currentThread();

t.getName();

Question 6

What is the result of the following:

Thread t1 = new Thread();
Thread t2 = new Thread();
t1.start();
t2.start();
t1.start();

Answer 6

Throws an IllegalThreadStateException

A Thread object can only be started once.

Question 7

Describe the Thread lifecycle

Answer 7

Waiting/Blocked

New -> Runnable Running -> Dead

Question 8

When can a thread go into the runnable state?

Answer 8

• When the start method has been called on the Thread object.
• When returing from a blocked, waiting, sleeping state.

Question 9

When can a thread go into the running state?

Answer 9

When the thread scheduler choses the thread from the runnable thread as the currently executing proces.

Question 10

What is the result?

public static void main(String... args) {
System.out.println("start");
Thread.sleep(5*60*1000);
System.out.println("end");
}

Answer 10

Compile error.

Missing try-catch or throws clause.

Question 11

What is the result?

public static void main(String... args) {
Thread t1 = new Thread();
Thread t2 = new Thread();
t1.sleep(1000);
t1.start();
t2.start();
t2.sleep(1000);
}

Answer 11

The current thread (not t1 or t2) will sleep for 1000 ms starts both the threads and then will sleep again for 1000 ms.

sleep() is a static method on the Thread class. So it will let the currently executing thread sleep.

Question 12

How to set a Threads priority?

Answer 12

thread.setPriority(5);

For min, max and norm values use:
Thread.MIN_PRIORITY;
Thread.MAX_PRIORITY;
Thread.NORM_PRIORITY;

Question 13

What does Thread.yield(); do?

Answer 13

Returnt he current thread to the runnable pool to give other threads with equal priorities a chance to run. No guarantees, the Thread scheduler may choose the same thread as the new running thread.

Question 14

What does thread.join(); do?

Answer 14

The current thread stops executing and waits till the “joining” thread is finished.

Question 15

What does the synchronized keyword do?

Answer 15

• Can be used on methods and code-blocks
• Only one thread can run a synchronized method from a particular instance at the same time.
• When a thread has a lock (meaning it is inside a synchronized method or block) No other thread can lock the object (enter a synchronized method or block).
• When a thread goes to sleep, it keeps the lock on a object.

Question 16

True or False:

Static methods can’t be synchronized.

Answer 16

False

Static methods can be synchronized, the lock will be put on the Class instance (f.e. MyClass.class).

Question 17

What does the object.wait() method do?

Answer 17

Puts the current thread on the waiting list for that instance. Once the object calls notify() one random waiting thread will continue to execute. Once the object calls notifyAll() all waiting threads will continue to execute.

Question 18

What is the result of the following code?

synchronized(anotherObject) {
anotherObject.wait();
}

Answer 18

wait call should be enclosed in both a synchronized block (or method) and a try-catch clause.

Question 19

What is the result of the following code?
synchronized(anotherObject) {
    try {
    anotherObject2.wait();
    } catch(InterruptedException e) {}
}

Answer 19

wait call can only be called on the object that is locked by the current thread.