|
Java Threads Interview Questions - 2
A: To introduce a Runnable type to an existing class
hierarchy, you need to create a sub-class that declares that it implements the
Runnable interface, and provide a run method to fulfil the interface. This
combination of interface and inheritance means that runnable implementations
can be very minor extensions of existing classes, as in the example below...
A: The static utility method invokeLater(Runnable) is intended to
execute a new runnable thread from a Swing application without disturbing the
normal sequence of event dispatching from the Graphical User Interface (GUI).
The method places the runnable object in the queue of Abstract Windowing
Toolkit (AWT) events that are due to be processed and returns immediately. The
runnable object's run() method is only called when it reaches the front of the
queue.
The deferred effect of the invokeLater(Runnable) method ensures that any necessary updates to
the user interface can occur immediately, and the runnable work will begin as
soon as those high priority events are dealt with. The invoke later method
might be used to start work in response to a button click that also requires a
significant change to the user interface, perhaps to restrict other
activities, while the runnable thread executes.
A: The volatile modifier is used to identify variables
whose values should not be optimized by the Java Virtual Machine, by caching
the value for example. The volatile modifier is typically used for variables that
may be accessed or modified by numerous independent threads and signifies that
the value may change without synchronization.
A: The wait() method is defined in the Object class,
which is the ultimate superclass of all others. So the Thread class and any
Runnable implementation inherit this method from Object. The wait() method is
normally called on an object in a multi-threaded program to allow other
threads to run. The method should should only be called by a thread that has
ownership of the object's monitor, which usually means it is in a synchronized method
or statement block.
A: A green thread refers to a mode of operation for the
Java Virtual Machine (JVM) in which all code is executed in a single operating
system thread. If the Java program has any concurrent threads, the JVM manages
multi-threading internally rather than using other operating system threads.
There is a significant processing overhead for the JVM to keep track of thread
states and swap between them, so green thread mode has been deprecated and
removed from more recent Java implementations. Current JVM implementations
make more efficient use of native operating system threads.
A: A working thread, more commonly known as a worker
thread is the key part of a design pattern that allocates one thread to
execute one task. When the task is complete, the thread may return to a thread
pool for later use. In this scheme a thread may execute arbitrary tasks, which
are passed in the form of a Runnable method argument, typically execute(Runnable). The
runnable tasks are usually stored in a queue until a thread host is available
to run them.
The worker thread design pattern is usually used to handle many concurrent
tasks where it is not important which finishes first and no single task needs
to be coordinated with another. The task queue controls how many threads run
concurrently to improve the overall performance of the system. However, a
worker thread framework requires relatively complex programming to set up, so
should not be used where simpler threading techniques can achieve similar
results.
|