Threads

Question 1

What does thread mean in Java?

Answer 1

Means two different things:

• An instance of class java.lang.Thread
• A thread of execution

Question 2

How threads work in terms of memory?

Answer 2

Each thread has a separate call stack. main( ) has the main thread.

Question 3

How does different JVM’s work for giving turns to threads?

Answer 3

Different JVM’s work in different ways. One might use round-robin fashion the other might not give turn to others until one finishes.

Question 4

How does a thread begin in Java?

Answer 4

It begins as an instance of java.lang.Thread

Question 5

Explain run( ) method

Answer 5

The job that needs to be done in the separate thread goes into run. It is either in java.lang.Thread or in the implementation of Runnable interface.

Question 6

How does extending Thread class works?

Answer 6

You have to override run method i.e. public void run()
You can overload it but it will be ignored and even if you call it yourself it won’t have a separate call stack. But it is not a good design choice. And on a separate note - Thread itself extends Runnable.

Question 7

How does implementing Runnable works?

Answer 7

You implement Runnable and override run i.e. public void run()

Question 8

How do we instantiate a thread that extends Thread?

Answer 8

It is simple. Just;
MyThread t = new MyThread();

Question 9

How do we instantiate a thread that implements Runnable?

Answer 9

This time we need worker and job classes. Thread is the worker that runs the thread-specific code and Runnable is the job class that runs the job that needs to be done.
First instantiate;
MyRunnable r = new MyRunnable();
Next get instance of Thread and give your runnable;
Thread t = new Thread(r);
The Runnable you pass to the Thread constructor is called the target or the target Runnable.

Question 10

What happens when no args are passed to Thread()?

Answer 10

Thread calls its own run( ) method.

Question 11

What happens when same target is passed to multiple Threads?

Answer 11

You can pass a single Runnable instance to multiple Thread objects so that the same Runnable becomes the target of multiple threads.Giving the same target to multiple threads means that several threads of execution will be running the very same job (and that the same job will be done multiple times)

Question 12

What are some thread constructors?

Answer 12

• Thread()
• Thread(Runnable target)
• Thread(Runnable target, String name)
• Thread(String name)

Question 13

How do we start a thread?

Answer 13

t.start();

before start is called the thread is said to be in new state. We start a Thread not a Runnable.

Question 14

What happens when start is called?

Answer 14

• A new thread of execution starts (with a new call stack).
• The thread moves from the new state to the runnable state.
• When the thread gets a chance to execute, its target run() method will run.

Question 15

Does this code start a new call stack?
Thread t = new Thread();
t.run();

Answer 15

No. Calling run in Runnable does not start a new call stack.

Question 16

How can we print name of a Thread?

Answer 16

We can call getName() method of the thread that executes the that Runnable’s run() method. But we do not have a reference to current thread, so that’s how it is done:
Thread.currentThread().getName()

Question 17

Does a thread still has a name even if we do not name it?

Answer 17

Yes. For main thread its “main” and for other threads its like “Thread-0”

Question 18

What happens when a thread completes its run() method?

Answer 18

The stack for that thread dissolves and the thread is considered dead. It’s still a thread object and methods on that object can be invoked as any other Java object. But it’s not a thread of execution any more. And we can not call start() on that object again.

Question 19

What happens when we try to start a Thread second time?

Answer 19

It can not be started and IllegalThreadStateException is thrown.

Question 20

What does getId() method returns when invoked on a thread?

Answer 20

It returns the id of thread. It’s positive, unique, long and a thread’s only id for the thread’s entire life.

Question 21

What is thread scheduler?

Answer 21

It’s part of JVM and decides which thread is going to actually run from all of the eligible ones i.e. in runnable state. And also decides which will be out of the run state.

Question 22

In which order threads are chosen by thread scheduler?

Answer 22

The order in which runnable threads are chosen to run is not guaranteed.

Question 23

What are thread states?

Answer 23

• New
• Runnable
• Running
• Waiting/blocked/sleeping
• Dead

Question 24

Define “New” thread state

Answer 24

The state after Thread is instantiated. It’s a thread object but not a thread of execution yet. start() method has not been invoked yet. It is not alive.

Question 25

Define “Runnable” thread state

Answer 25

The thread is eligible to run but not selected by scheduler yet. It can be after start() is called or returned back from a blocked, waiting or sleeping state. It’s considered alive.

Question 26

Define “Running” thread state

Answer 26

When a runnable is selected by scheduler from thread pool. That’s the only way to be in running state.

Question 27

Define “Waiting/blocked/sleeping” thread state

Answer 27

The thread is alive but not eligible to run in this state. It can blocked waiting for a resource or it might be sleeping by the code.

Question 28

Define “Dead” thread state

Answer 28

When a thread completes the thread’s state is dead and can not be brought back to life. If start() is invoked on this thread. runtime exception is thrown.

Question 29

Define “Sleeping” state details

Answer 29

sleep() is a static method and can be called from code

Thread.sleep(). sleep can throw checked InterruptedException

Question 30

How does timer is Thread.sleep() works?

Answer 30

It makes the current thread sleep “at least” for the specified time. It returns back to runnable after time finishes but it might not be returned back to running by scheduler. It’s a static method and one thread can not put another one into sleeping.

Question 31

Do threads have any priorities?

Answer 31

Threads always run with some priority, usually represented as a number between 1 and 10 (although in some cases, the range is less than 10). The scheduler in most JVMs uses preemptive, priority-based scheduling (which implies some sort of time slicing). This does not mean that all JVMs use time slicing. In most cases, the running thread will be of equal or greater priority than the highest-priority threads in the pool. But never rely on thread priorities since it is not guaranteed.

Question 32

How is thread priority set?

Answer 32

By default a thread gets the priority of the thread that creates it. Or it can be set by calling setPriority() on the thread object. JVM will never change a priority. And 1-10 is not guaranteed since some JVM’s have range 1-5.In that case different priorities might be mapped to same one.

Question 33

How does yield() work?

Answer 33

When a thread calls yield, it goes from running to runnable to give turn to other same priority threads. But the behaviour is not guaranteed!

Question 34

How does join() work?

Answer 34

A thread is joined to end of another thread. If you join B to A, B is executed when run() of A completes and A becomes dead.

Question 35

What does the code below mean?
Thread t = new Thread();
t.start();
t.join();

Answer 35

“Join me (the current thread) to the end of t, so that t must finish before I (the current thread) can run again.”

You can also call one of the overloaded versions of join() that takes a timeout duration so that you’re saying, “wait until thread t is done, but if it takes longer than 5,000 milliseconds, then stop waiting and become runnable anyway.”

Question 36

Define other ways where a thread can leave running state?

Answer 36

• The thread’s run() method completes.
• A call to wait() on an object (we don’t call wait() on a thread).
• A thread can’t acquire the lock on the object whose method code it’s attempting to run.
• The thread scheduler can decide to move the current thread from running to runnable in order to give another thread a chance to run. No reason is needed—the thread scheduler can trade threads in and out whenever it likes.

Question 37

What is a race condition?

Answer 37

Multiple threads can access the same resource (typically an object’s instance variables) and can produce corrupted data if one thread “races in” too quickly before an operation that should be “atomic” has completed.

Question 38

How to protect data from race conditions?

Answer 38

• Mark the variables private

* Synchronize the code that modifies the variables

Question 39

How does synchronized keyword works?

Answer 39

Once a thread starts the sync block another thread cannot enter the method until the first one completes the process by exiting the method.

Question 40

Tell about object locks in java

Answer 40

Every object in Java has a built-in lock that comes into play when the object has sync method code.

Question 41

What happens when we enter a sync code block?

Answer 41

When we enter a synchronized non-static method, we automatically acquire the lock associated with the current instance of the class whose code we’re executing (the this instance). Acquiring a lock for an object is also known as getting the lock, or locking the object, locking on the object, or synchronizing on the object.

Question 42

Can a thread get the lock of an object when another thread is holding the lock?

Answer 42

No

Question 43

How the lock on an object is released?

Answer 43

When the thread holding the lock exits the sync block.

Question 44

Can variables or classes be synchronized?

Answer 44

No. Only methods (or blocks) can be synchronized, not variables or classes.

Question 45

How many locks each object has?

Answer 45

Each object has just one lock.

Question 46

Can a class have both sync and non-sync methods?

Answer 46

Yes. Not all methods in a class need to be synchronized. A class can have both synchronized and non-synchronized methods.

Question 47

Can two separate threads execute sync methods of a class at the same time?

Answer 47

No. Once a thread acquires the lock on an object, no other thread can enter any of the synchronized methods in that class (for that object).

Question 48

Can multiple threads access an object’s non-sync methods?

Answer 48

If a class has both synchronized and non-synchronized methods, multiple threads can still access the class’s non-synchronized methods!

Question 49

When a thread goes to sleep does it release the locks?

Answer 49

No. If a thread goes to sleep, it holds any locks it has—it doesn’t release them.
And its locks will be unavailable to other threads.

Question 50

Can a thread acquire more than one lock?

Answer 50

Yes. Also, if a thread acquires a lock and then attempts to call a synchronized method on that same object, no problem. The JVM knows that this thread already has the lock for this object, so the thread is free to call other synchronized methods on the same object, using the lock the thread already has.

Question 51

Can you sync a block of code?

Answer 51

You can synchronize a block of code rather than a method.

Question 52

Which object’s lock you acquire in sync block?

Answer 52

When you synchronize a block of code, you specify which object’s lock you want to use as the lock, so you could, for example, use some third-party object as the lock for this piece of code.

Question 53

What’s the difference between these two code blocks?
public synchronized void doStuff() {
System.out.println(“synchronized”);
}

public void doStuff() {
synchronized(this) {
System.out.println("synchronized");
}
}

Answer 53

They both get the lock on the object that owns the method.

Question 54

Can static methods be sync.ed?

Answer 54

Yes. In that case you acquire the lock for the class.

Question 55

What does that code block do?
public static int getCount() {
synchronized(MyClass.class) {
return count;
}
}

Answer 55

MyClass.class is called a class literal.It's a special feature in the Java language that tells the compiler (who tells the JVM): Go and find me the instance of Class that represents the class called MyClass. You can also do this with the following code:
public static void classMethod() throws ClassNotFoundException {
Class cl = Class.forName("MyClass");
synchronized (cl) {
// do stuff
}
}

Question 56

What happens if a thread can’t get the lock - i.e. gets blocked on the object’s lock?

Answer 56

Essentially, the thread goes into a kind of pool for that particular object and has to sit there until the lock is released and the thread can again become runnable/running.

Question 57

Can a static and non-static sync method block each other?

Answer 57

No. The static method locks on a Class instance, while the non-static method locks on the this instance— these actions do not interfere with each other at all.

Question 58

What’s the lock behavior of Thread methods?

Answer 58

wait() gives up locks whereas notify(), join(), sleep(), and yield() keep the locks.

Question 59

What is a thread-safe class?

Answer 59

When a thread protects its data we say the class is thread safe.

Question 60

If a class is Thread-safe does that mean that it is always thread safe?

Answer 60

No. In a “thread-safe” class like the one returned by synchronizedList(), each individual method is synchronized. So names.size() is synchronized, and names.remove(0) is synchronized. But nothing prevents another thread from doing something else to the list in between those two calls. And that’s where problems can happen.

Question 61

What is a thread deadlock?

Answer 61

Deadlock occurs when two threads are blocked, with each waiting for the other’s lock. Neither can run until the other gives up its lock, so they’ll sit there forever.

Question 62

Give an example to thread lock.

Answer 62

public class DeadlockRisk {
private static class Resource {
public int value;
}
private Resource resourceA = new Resource();
private Resource resourceB = new Resource();
public int read() {
synchronized(resourceA) { // May deadlock here
synchronized(resourceB) {
return resourceB.value + resourceA.value;
}
}
}
public void write(int a, int b) {
synchronized(resourceB) { // May deadlock here
synchronized(resourceA) {
resourceA.value = a;
resourceB.value = b;
}
}
}
}

Question 63

What can be a way to prevent deadlocks?

Answer 63

There are design approaches that can help avoid deadlock, including strategies for always acquiring locks in a predetermined order.

Question 64

Can wait() and notify() be called from any context?

Answer 64

wait(), notify(), and notifyAll() must be called from within a synchronized context! A thread can’t invoke a wait or notify method on an object unless it owns that object’s lock.

Question 65

How wait() method on Object works?

Answer 65

A thread gets on an object’s waiting list by executing the wait() method of the target object.

Question 66

What happens when notify() method of the target object is called?

Answer 66

If many threads are waiting on the same object, only one will be chosen (in no guaranteed order) to proceed with its execution. If there are no threads waiting, then no particular action is taken.

Question 67

What does the below code do?
synchronized(anotherObject) { 
	try {
		anotherObject.wait();
	} catch(InterruptedException e){}
}

Answer 67

synchronized(anotherObject) { // this has the lock on anotherObject
	try {
		anotherObject.wait();
		// the thread releases the lock and waits
		// To continue, the thread needs the lock,
		// so it may be blocked until it gets it.
	} catch(InterruptedException e){}
}
For a thread to call wait() or notify(), the thread has to be the owner of the lock for that object. When the thread waits, it temporarily releases the lock for other threads to use, but it will need it again to continue execution.

Question 68

When the lock on the object is released after wait is called?

Answer 68

When the wait() method is invoked on an object, the thread executing that code gives up its lock on the object immediately.

Question 69

When the lock on the object is released after notify is called?

Answer 69

When notify() is called, that doesn’t mean the thread gives up its lock at that moment. If the thread is still completing synchronized code, the lock is not released until the thread moves out of synchronized code. So just because notify() is called, this doesn’t mean the lock becomes available at that moment.

Question 70

When notifyAll is called how do the objects waitin for that lock behave?

Answer 70

All of the threads will be notified and start competing to get the lock. As the lock is used and released by each thread, all of them will get into action without a need for further notification.

Question 71

What is a spontaneous wakeup?

Answer 71

A thread may wake up even though no code has called notify() or notifyAll(). (At least, no code you know about has called these methods. Sometimes, the JVM may call notify() for reasons of its own, or code in some other class calls it for reasons you just don’t know.) What this means is that when your thread wakes up from a wait(), you don’t know for sure why it was awakened. By putting the wait() method in a while loop and rechecking the condition that represents what we were waiting for, we ensure that whatever the reason we woke up, we will re-enter the wait() if (and only if) the thing we were waiting for has not happened yet.

Question 72

What is an IllegalMonitorStateException?

Answer 72

Thrown to indicate that a thread has attempted to wait on an object’s monitor or to notify other threads waiting on an object’s monitor without owning the specified monitor. It’s an unchecked exception.

Question 73

What should be done in sync. calls to protect shared data?

Answer 73

You should also make use of the required synchronization for the wait() and notify() calls to also protect whatever other data you’re sharing between threads.

Question 74

What should be done in sync. calls to protect shared data?

Answer 74

You should also make use of the required synchronization for the wait() and notify() calls to also protect whatever other data you’re sharing between threads.

Question 75

To which classes do those methods belong?

wait () 
notify() 
notifyAll() 
start() 
yield()
sleep()
join()
run()

Answer 75

Object:
wait ()
notify()
notifyAll()

Thread:
start() 
yield() // static
sleep() // static
join()

Runnable:
run()

Question 76

What happens if you call start() on Thread object more than once?

Answer 76

It will throw IllegalThreadStateException.

Question 77

What is a process?

Answer 77

A process has a self-contained execution environment. A process generally has a complete, private set of basic run-time resources; in particular, each process has its own memory space.

Question 78

How do processes communicate?

Answer 78

To facilitate communication between processes, most operating systems support Inter Process Communication (IPC) resources, such as pipes and sockets. IPC is used not just for communication between processes on the same system, but processes on different systems.

Question 79

What is the relation between processes and threads?

Answer 79

Both processes and threads provide an execution environment, but creating a new thread requires fewer resources than creating a new process.
Threads exist within a process — every process has at least one. Threads share the process’s resources, including memory and open files.

Question 80

What is an interrupt?

Answer 80

An indicator that states a thread should stop what it does and do smth. else.

Question 81

How can a thread send an interrupt to another one?

Answer 81

By invoking interrupt on Thread object.For the interrupt mechanism to work correctly, the interrupted thread must support its own interruption.

Question 82

How can an interrup be supported?

Answer 82

In the first method methods like sleep throws InterruptedException. We can handle by catching that. But if no method throwing that exc. is called then we can check Thread.interrupted() as a second method.

Question 83

How is interrupt mechanism implemented?

Answer 83

By using an internal flag known as interrupt status.

Question 84

How is interrupt status flag is set?

Answer 84

By calling Thread.interrupt

Question 85

How is interrupt status flag is cleared?

Answer 85

By calling Thread.interrupted or after InterruptedException is thrown.

Question 86

Does isInterrupted change interrupt status flag?

Answer 86

It is used by one thread to query the interrupt status of another, does not change the interrupt status flag.

Question 87

How does sleep and join respond to an interrupt?

Answer 87

By exiting with an InterruptedException.

Question 88

What are the possible problems when two or more threads communicate?

Answer 88

Thread interference and memory consistency.

Question 89

What are the forms of Thread Contention?

Answer 89

Starvation and livelock.

Question 90

What is a thread interference?

Answer 90

Interference happens when two operations, running in different threads, but acting on the same data, interleave. This means that the two operations consist of multiple steps, and the sequences of steps overlap.

Question 91

What is a happens-before relationship?

Answer 91

• Reads from and writes to other variables cannot be reordered to occur after a write to a volatile variable, if the reads / writes originally occurred before the write to the volatile variable. The reads / writes before a write to a volatile variable are guaranteed to “happen before” the write to the volatile variable. Notice that it is still possible for e.g. reads / writes of other variables located after a write to a volatile to be reordered to occur before that write to the volatile. Just not the other way around. From after to before is allowed, but from before to after is not allowed.
• Reads from and writes to other variables cannot be reordered to occur before a read of a volatile variable, if the reads / writes originally occurred after the read of the volatile variable. Notice that it is possible for reads of other variables that occur before the read of a volatile variable can be reordered to occur after the read of the volatile. Just not the other way around. From before to after is allowed, but from after to before is not allowed.

Question 92

What can form a happens-before relationship?

Answer 92

• The synchronized and volatile constructs, as well as the Thread.start() and Thread.join() methods
• Each action in a thread happens-before every action in that thread that comes later in the program’s order.
• An unlock (synchronized block or method exit) of a monitor happens-before every subsequent lock (synchronized block or method entry) of that same monitor. And because the happens-before relation is transitive, all actions of a thread prior to unlocking happen-before all actions subsequent to any thread locking that monitor.
• A write to a volatile field happens-before every subsequent read of that same field. Writes and reads of volatile fields have similar memory consistency effects as entering and exiting monitors, but do not entail mutual exclusion locking.
• A call to start on a thread happens-before any action in the started thread.
• All actions in a thread happen-before any other thread successfully returns from a join on that thread.

Question 93

Can constructors be synchronized?

Answer 93

No.

Question 94

(An important exception: final fields, which cannot be modified after the object is constructed, can be safely read through non-synchronized methods, once the object is constructed) This strategy is effective, but can present problems with liveness, as we’ll see later in this lesson.

Answer 94

TODO

Question 95

When does Thread Contention occur?

Answer 95

When two or more threads try to access the same resource simultaneously and cause the Java runtime to execute one or more threads more slowly, or even suspend their execution.

Question 96

What is volatile visibility guarantee?

Answer 96

• If Thread A writes to a volatile variable and Thread B subsequently reads the same volatile variable, then all variables visible to Thread A before writing the volatile variable, will also be visible to Thread B after it has read the volatile variable.
• If Thread A reads a volatile variable, then all all variables visible to Thread A when reading the volatile variable will also be re-read from main memory.