IMP - How do you ensure that N threads can access N resources without deadlock ?

A very simple way to avoid deadlock while using N threads is to impose an ordering on the locks and force each thread to follow that ordering. Thus, if all threads lock and unlock the mutexes in the same order, no deadlocks can arise.

IMP - Producer Consumer Problem with Wait and Notify Example

Link One

IMP - Difference between Callable and Runnable in Java - Interview question

The major difference between Callable and Runnable interface is that Callable can return the result of an operation performed inside call() method, which was one of the limitations with Runnable interface.

The Callable interface can throw checked exception because it's call method throws Exception.

Link One

Generic can allow you to write Template

Link One

What is blocking method in future ?

Future provides get() method to get result, which is blocking method and blocks until result is available to Future


Link One

IMP - How you make sure that the task you assigned to a worker thread, has been completed or not ?

we check whether task is completed or not using isDone() method

Link One

Link Two

Why to use anonymous object ?

IMP - Between Executor.submit() and Executer.execute() method ?

Link One

Line Two

How to use Future and FutureTask in Java Concurrency with ...
javarevisited.blogspot.in

Future and FutureTask in Java allows you to write asynchronous code. Future is a general concurrency abstraction, also known as a promise, which promises to return a ...

What is a semaphore?

A semaphore is a data structure that maintains a set of permits that have to be acquired by competing threads. Semaphores can therefore be used to control how many threads access a critical section or resource simultaneously. Hence the constructor of java.util.concurrent.Semaphore takes as first parameter the number of permits the threads compete about. Each invocation of its acquire() methods tries to obtain one of the available permits. The method acquire()without any parameter blocks until the next permit gets available. Later on, when the thread has finished its work on the critical resource, it can release the permit by invoking the method release() on an instance of Semaphore.

Which rules do you have to follow in order to implement an immutable class?

• All fields should be final and private.
• There should be not setter methods.
• The class itself should be declared final in order to prevent subclasses to violate the principle of immutability.
• If fields are not of a primitive type but a reference to another object:
  • There should not be a getter method that exposes the reference directly to the caller.
  • Don’t change the referenced objects (or at least changing these references is not visisble to clients of the object).

What do you have to consider when passing object instances from one thread to another?

When passing objects between threads, you will have to pay attention that these objects are not manipulated by two threads at the same time. An example would be a Map implementation whose key/value pairs are modified by two concurrent threads. In order to avoid problems with concurrent modifications you can design an object to be immutable.

What does the method Thread.yield() do?

An invocation of the static method Thread.yield() gives the scheduler a hint that the current thread is willing to free the processor. The scheduler is free to ignore this hint. As it is not defined which thread will get the processor after the invocation of Thread.yield(), it may even happen that the current thread becomes the “next” thread to be executed.

What do we understand by thread starvation?

Threads with lower priority get less time for execution than threads with higher priority. When the threads with lower priority performs a long enduring computations, it may happen that these threads do not get enough time to finish their computations just in time. They seem to “starve” away as threads with higher priority steal them their computation time.

Is it possible to implement a deadlock detection?

When all exclusive locks are monitored and modelled as a directed graph, a deadlock detection system can search for two threads that are each waiting on the other thread to free a resource that it has locked. The waiting threads can then be forced by some kind of exception to release the lock the other thread is waiting on.

Is it possible to prevent deadlocks at all?

In order to prevent deadlocks one (or more) of the requirements for a deadlock has to be eliminated:

• Mutual exclusion: In some situation it is possible to prevent mutual exclusion by using optimistic locking.
• Resource holding: A thread may release all its exclusive locks, when it does not succeed in obtaining all exclusive locks.
• No preemption: Using a timeout for an exclusive lock frees the lock after a given amount of time.
• Circular wait: When all exclusive locks are obtained by all threads in the same sequence, no circular wait occurs.

What are the requirements for a deadlock situation?

In general the following requirements for a deadlock can be identified:

• Mutual exclusion: There is a resource which can be accessed only by one thread at any point in time.
• Resource holding: While having locked one resource, the thread tries to acquire another lock on some other exclusive resource.
• No preemption: There is no mechanism, which frees the resource if one thread holds the lock for a specific period of time.
• Circular wait: During runtime a constellation occurs in which two (or more) threads are each waiting on the other thread to free a resource that it has locked.

What do we understand by a deadlock?

A deadlock is a situation in which two (or more) threads are each waiting on the other thread to free a resource that it has locked, while the thread itself has locked a resource the other thread is waiting on:
Thread 1: locks resource A, waits for resource B
Thread 2: locks resource B, waits for resource A

What do we understand by an atomic operation?

An atomic operation is an operation that is either executed completely or not at all.

After having started a child thread, how do we wait in the parent thread for the termination of the child thread?

Waiting for a thread’s termination is done by invoking the method join() on the thread’s instance variable: --

How should an InterruptedException be handled?

Methods like sleep() and join() throw an InterruptedException to tell the caller that another thread has interrupted this thread. In most cases this is done in order to tell the current thread to stop its current computations and to finish them unexpectedly. Hence ignoring the exception by catching it and only logging it to the console or some log file is often not the appropriate way to handle this kind of exception. The problem with this exception is, that the method run() of the Runnable interface does not allow that run() throws any exceptions. So just rethrowing it does not help. This means the implementation of run() has to handle this checked exception itself and this often leads to the fact that it its caught and ignored.