[READ: Why-JAVA][Start-Learning-JAVA][Why-Java's-Hot][Start-Using-LINUX][Java-Q-&-A][Question][Java-SE-6-Doc][Struts-Doc][Java-Tutorial-Index] [Java-Certification][Tech.][Struts.][Servlet.][JSP.][EJB.][JNDI-JMS][SQL.][JDBC.]
CORE-JAVA: [OOP][CLASS][ABSTRACT][EXCEPTIONS][THREADS][UTILS][PACKAGES][JVM][CASTING][NETWORKING][RMI-XML]
What is a task’s priority and how is it used in scheduling?
A task’s priority is an integer value that identifies the relative order in which it should be executed with respect to other tasks. The scheduler attempts to schedule higher priority tasks before lower priority tasks. The JVM defines a range of ten logical priorities for Java threads, including:
java.lang.Thread.MIN_PRIORITY = 1
java.lang.Thread.NORM_PRIORITY = 5
java.lang.Thread.MAX_PRIORITY = 10
These values 1 to 10 are passed into Thread.setPriority(int) to assign priorities to Java threads. The default priority of a Java thread is NORM_PRIORITY.
In concurrent programming, there are two basic units of execution: processes and threads. When programming with threads we have one thread actually executing at any given moment.
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. Most implementations of the Java virtual machine run as a single process. A Java application can create additional processes using a ProcessBuilder object. Multiprocess applications are beyond the scope.
Threads are lightweight processes. 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. From the application programmer's point of view, you start with just one thread, called the main thread. This thread has the ability to create additional threads, as we'll.
What are the disadvantages of using threads?
Deadlock describes a situation where two or more threads are blocked forever, waiting for each other. Its a rare case scenario. It does not happen all the time.
Happens when two threads are invoked on the same class synchronized method and are both waiting to enter another synchronized method. Both are waiting over other to exit the entered method block. (See Example) (compile online)
Can a lock be acquired on a class? (thread)
Yes, a lock can be acquired on a class. This lock is acquired on the class’s Class object. To synchronize threads, the Java programming language uses monitors, which are a high-level mechanism for allowing only one thread at a time to execute a region of code protected by the monitor. The behavior of monitors is explained in terms of locks; there is a lock associated with each object.
Thread Locks: A synchronized method automatically performs a lock action when it is invoked; its body is not executed until the lock action has successfully completed. If execution of the method's body is ever completed, either normally or abruptly, an unlock action is automatically performed on that same lock.
What is the difference between YIELD and SLEEP?
* The Thread.yield() method, causes the currently executing thread object to temporarily pause and allow other threads to execute. YIELD will make a thread to pause until an unless there are no more threads waiting in the Ready-to-run state. If there are other threads in the Ready-to-run state, their priorities determine which thread gets to execute. The YIELD() method gives other threads of the same priority a chance to run. If there are no equal priority threads in the "Runnable" state, then the YIELD is ignored and the thread continues its execution.
* The Thread.sleep(long millis) method, causes the thread to pause its execution and transit to the Sleeping state. The thread will sleep for at least the time specified in its argument. SLEEP thread cannot be made to run until and unless the specified time is completed. SLEEP will throw an InterruptedException if interrupted to run before the specified time.
Difference between the methods Thread.sleep() and Object.wait():
The code sleep(1000); puts thread aside for exactly one second. It cannot be interrupted to start before the specified time.
The code wait(1000), causes a wait of up to one second. A thread can stop waiting and start running before the specified time, if it receives the Object.notify() or Object.notifyAll() call. The method wait() is defined in the class Object and the method Thread.sleep() is defined in the class Thread. Object.notify()
Object.wait(long timeout)
A thread may be blocked because:
1) It has been put to sleep for a set amount of time
2) It is suspended with a call to suspend() and will be blocked until a resume() message
3) The thread is suspended by call to wait(), and will become runnable on a notify or notifyAll message.
What is the purpose of the wait(), notify(), and notifyAll() methods?
IMP: These methods can be invoked only from within a synchronized context (synchronized method or synchronized block), otherwise, the call will result in an IllegalMonitorStateException.
These methods are used on the "shared object" of thread inter-communication that synchronizes on the same object. Object.NOTIFY() method on an object wakes up a single thread. Object.NOTIFYALL() wakes up all the threads. All the awakened threads compete for the resource, but only one thread gets the resource and the others go back to waiting.
Object.wait() method must be enclosed within a try catch block (Checked Exception). The releasing of the lock of the shared object by the thread allows other threads to run and execute synchronized code on the same object after acquiring its lock. The Object.wait() method causes the current thread to wait until another thread notifies it of a changed condition. The wait(),notify(), and notifyAll() methods are used to provide an efficient way for threads to wait for a "shared resource". When a thread executes an object's wait() method, it enters the waiting state. It only enters the ready state after another thread invokes the object's notify() or notifyAll() methods.
Whats the difference between notify() and notifyAll()?
Object.notify() is used to unblock one waiting thread; notifyAll() is used to unblock all of them. Using notify() is preferable (for efficiency) when only one blocked thread can benefit from the change (for example, when freeing a buffer back into a pool). notifyAll() is necessary (for correctness) if multiple threads should resume (for example, when releasing a "writer" lock on a file might permit all "readers" to resume).
/* Below example shows three threads, manipulating the same stack. All of them are PUSHING elements on the stack. Note: All the threads are using the same Object's synchronized method, within which the wait() and notify() are called. Runtime exception occurs if not called within a synchronized block. */
public class WaitAndNotify { (compile online)
-public static void main(String[] args) { StackClass stack = new StackClass(5);
--new StackPusher("One", stack); new StackPusher("Two", stack); new StackPusher("Three", stack);
--try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } } /*end main*/ } /*end class*/
class StackPusher extends Thread { StackClass stack;
-StackPusher(String threadName, StackClass stack) {
--super(threadName); this.stack = stack; setDaemon(true); start(); }
---public void run() { while (true) { stack.push(new Integer(3)); } } /*end run*/} /*end thread*/
class StackClass { private Object[] stackArray; private volatile int topOfStack;
-StackClass (int capacity) { stackArray = new Object[capacity]; topOfStack = 0; }
--public synchronized void push(Object element) { // IMPORTANT: synchronized method is a must.
---while (topOfStack <= 4 ) { ---if (topOfStack >=0 && topOfStack <= 4) { stackArray[topOfStack] = element; } ---if (topOfStack >= 4) {
------try { topOfStack=0; wait(); }
------catch (InterruptedException e) { e.printStackTrace(); } }
---topOfStack = topOfStack + 1; notify(); } /*end while*/} /*end push*/} /*end class*/
When a thread blocks on I/O, what state does it enter?
A thread enters the waiting state when it blocks on I/O.
What are the high-level thread states?
The high-level thread states are READY, RUNNING, WAITING, and DEAD. When a thread is created and started, it is in the "Ready state".
What state is a thread in when it is executing?
An executing thread is in the "running state".
How can a dead thread be restarted? (THREAD)
A dead thread cannot be restarted.
What state does a thread enter when it terminates its processing?
When a thread terminates its processing, it enters the DEAD state.
What invokes a thread's run() method?
After a thread is started, with its start() method or that of the Thread class, the JVM invokes the thread's run() method when the thread is initially executed.
What method is invoked to cause an object to begin executing as a separate thread?
The START() method of the Thread class is invoked to cause an object to begin executing as a separate thread.
What happens when a thread cannot acquire a LOCK on an object?
If a thread attempts to execute a synchronized method or statement and if it's unable to acquire an object's lock, it enters the WAITING state until the lock becomes available.
How does multi-threading take place on a computer with a single CPU?
The operating system's Task Scheduler/Processor allocates execution time to multiple tasks. By quickly switching between executing tasks, it creates the impression as if tasks are executed sequentially.
What happens when you invoke a thread's INTERRUPT method while it is sleeping or waiting?
When a task's interrupt() method is executed, the task enters the READY state and will throw an InterruptedException when it enters the running state. A thread can be awakened abruptly by invoking the interrupt() method on the SLEEPing thread object. Note that this method is not static, thus can be used only when inherited.
What are three ways in which a thread can enter the WAITING state?
A thread can enter the waiting state by invoking its SLEEP() method.
When blocked by I/O, and by unsuccessfully attempting to acquire an object's LOCK. By invoking an object's WAIT() method.
It can also enter the waiting state by invoking its (deprecated) SUSPEND() method.
What are the two basic ways in which classes that can be run as threads may be defined?
A thread class may be declared as a subclass of THREAD, or it may implement the RUNNABLE interface. Implementing interface encourages multiple inheritance.
What method must be implemented by all threads?
All tasks must implement the run() method, whether they are a subclass of THREAD or implement the RUNNABLE interface. (Ex.)
class RunnableThread implements Runnable {
---Thread runner; // instance of Thread
---public RunnableThread() { } // 1st Constructor
---public RunnableThread(String threadName) { // 2nd Constructor
-----runner = new Thread(this, threadName); // (1) Create a new thread.
-----System.out.println(runner.getName());
-----runner.start(); } // (2) Start the thread.
---public void run() { System.out.println(Thread.currentThread()); } }
public class RunnableExample {
---public static void main(String[] args) {
-----Thread thread1 = new Thread(new RunnableThread(), "thread1");
-----Thread thread2 = new Thread(new RunnableThread(), "thread2");
-----RunnableThread thread3 = new RunnableThread("thread3");
---//Start the threads
---thread1.start();
---thread2.start();
try { //delay for one second
---Thread.currentThread().sleep(1000); }
---catch (InterruptedException e) { }
---System.out.println(Thread.currentThread()); } } (compile online)
* What is daemon thread and which method is used to create the daemon thread?
A: Daemon thread is a LOW priority thread which runs intermittently in the BACK-GROUND for the benefit of other threads. An example of a daemon thread is the garbage collector. setDaemon() method is used to create a daemon thread. The Java Virtual Machine exits when the only threads running are all daemon threads. This method must be called before the thread is started. Using setDaemon(true) will stop the thread execution when main() completes. Daemon threads mean that they end when there are no more non-daemon threads running.
Why do threads block on I/O?
Threads block on i/o (that is enters the waiting state) so that other threads may execute while the i/o Operation is performed.
What is the difference between preemptive scheduling and time slicing? (threads)
Under preemptive scheduling, the highest priority task executes until it enters the waiting or dead states or a higher priority task comes into existence. Under time slicing, a task executes for a predefined slice of time and then reenters the pool of ready tasks. The scheduler then determines which task should execute next, based on priority and other factors.
What are the different identifier states of a Thread?
The different identifiers of a Thread are:
R - RUNNING or runnable thread
S - SUSPENDED thread
CW - CONDITIONAL WAITING - Thread waiting on a condition variable
MW - MONITOR WAITING - Thread waiting on a monitor lock
MS - MONITOR SUSPENDED - Thread suspended waiting on a monitor lock
* Describe synchronization in respect to multi-threading. (synchronize)
A: With respect to multi-threading, synchronization is the capability to control the access of multiple threads to shared resources. Without synchronization, it is possible for one thread to modify a shared variable while another thread is in the process of using or modifying the same shared variable. This usually leads to significant errors.
What are synchronized methods and synchronized statements? (synchronize)
A: Synchronized METHODS are methods that are used to control access to an object. A thread only executes a synchronized method after it has acquired the LOCK for the method's object or class. (Ex.)
--public class SynchronizedCounter {
----private int c = 0;
----public synchronized void increment() { c++; } }
Synchronized STATEMENTS are similar to synchronized methods. But they can be used within non-synchronized methods (Ex:). Synchronized statements must specify the object that provides the intrinsic lock. A synchronized statement can only be executed after a thread has acquired the LOCK for the object or class referenced in the synchronized statement.
public class MsLunch {
--private long c1 = 0; private long c2 = 0;
--private Object lock1 = new Object(); private Object lock2 = new Object();
public void inc1() { --synchronized(lock1) { c1++; } }
public void inc2() { --synchronized(lock2) { c2++; } } }
What is an object's LOCK and which object's have locks? (synchronize)
An object's lock is a mechanism that is used by multiple threads to obtain synchronized access to the object. Synchronization is built around an internal entity known as the monitor lock. A thread may execute a synchronized method of an object only after it has acquired the object's lock. All objects and classes have locks. A class's lock is acquired on the class's Class object.
*[ How long can we wait?] *[ An attempt for definition.]
Life is Beautiful.
Creating successful constructive personality. Why God Gave Us Friends? Way to Paradise. Creating the Beautiful World. Doing the job of goodness. Life is Meaningful. The A to Z for Goodness. Life is full of Tests. History Proves That. Love in different forms. True to the heart.
No comments:
Post a Comment