Multithreading in java

1. A multithreaded program contains two or more parts that can run concurrently .
2. Each part of such a program is called a thread, and each thread defines a separate path of
Execution.
3. Multithreading is a specialized form of multitasking.
4. A process is, in essence, a program that is executing. Thus, process-based multitasking is the
feature that allows your computer to run two or more programs concurrently.

For example:-
Process-based multitasking enables you to run the Java compiler at the same time that you are
using a text editor.
In process-based multitasking, a program is the smallest unit of code that can be dispatched by
the scheduler.
Multithreading enables you to write very efficient programs.

Multithreading enables you to write very efficient programs that make maximum use of the
CPU, because idle time can be kept to a minimum.
This is especially important for the interactive, networked environment in which Java operates,
because idle time is common.
For example, the transmission rate of data over a network is much slower than the rate at which
the computer can process it. Even local file system resources are read and written at a much
slower pace than they can be processed by the CPU.

Processes and Threads
In concurrent programming, there are two basic units of execution: processes and threads. In
the Java programming language, concurrent programming is mostly concerned with threads.
However, processes are also important
A computer system normally has many active processes and threads. This is true even in systems
that only have a single execution core, and thus only have one thread actually executing at any
given moment. Processing time for a single core is shared among processes and threads through
an OS feature called time slicing.

Processes
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.
Processes are often seen as synonymous with programs or applications. However, what the user
sees as a single application may in fact be a set of cooperating processes.
To facilitate communication between processes, most operating systems support Inter Process
Communication (IPC) resources, such as pipes and sockets.

Threads
Threads are sometimes called 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. This makes for efficient, but potentially
problematic, communication.
Multithreaded execution is an essential feature of the Java platform. Every application has at
least one thread – or several, if you count "system" threads that do things like memory
management and signal handling.

Defining and Starting a Thread
An application that creates an instance of Thread must provide the code that will run in that
thread. There are two ways to do this:
•Provide a Runnable object. The Runnable interface defines a single method, run, meant to
contain the code executed in the thread. The Runnable object is passed to the Thread
constructor, as in the HelloRunnable example:

Public class HelloRunnable implements Runnable{
◦ Public void run(){
◦ System.out.println(“Hello from a thread!”);
◦ }
◦ Public static void main(Sting args[]){
◦ (new Thread(new HelloRunnable())).start();
◦ }

Subclass Thread:
The Thread class itself implements Runnable, through its run methods does nothing.An
Application can subclass Thread, providing its own implementation of run, as in the
HelloThread example:
Public class HelloThread extends Thread{
◦ System.out.println(“Hello from a thread”);
}
Public static void main(Sting args[]){
(new Hello Thread()).start();
}

The Java Thread Model:
The java run-time system depends on threads for many thing, and all class libraries are
Designed with multithreading in mind. In fact, Java uses threads to enable the entire
Environment to be asynchronous.This helps reduce inefficiency by preventing the waste of CPU
Cycles.

Thread Priorities
Java assigns to each thread a priority that determines how that thread should be treated with
respect to the others.
Thread priorities are integers that specify the relative priority of one thread to another.
As an absolute value, a priority is meaningless; a higher-priority thread doesn't run any faster
than a lower-priority thread if it is the only thread running.
Instead, a thread's priority is used to decide when to switch from one running thread to the
next. This is called a context switch

A thread can voluntarily relinquish control. This is done by explicitly yielding, sleeping, or
blocking on pending I/O. In this scenario, all other threads are examined, and the highest-
priority thread that is ready to run is given the CPU.
A thread can be preempted by a higher-priority thread. In this case, a lower-priority thread that
does not yield the processor is simply preempted – no matter what it is doing – by a higher-
priority thread. Basically, as soon as a higher-priority thread wants to run, it does. This is called
preemptive multitasking.

Synchronization
Because multithreading introduces an asynchronous behavior to your programs, there must be a
way for you to enforce synchronicity when you need it.
The Main Thread
When a Java program starts up, one thread begins running immediately. This is usually called the
main thread of your program, because it is the one that is executed when your program begins.
The main thread is important for two reasons:
1. It is the thread from which other "child" threads will be spawned.
2. It must be the last thread to finish execution. When the main thread stops, your program
terminates.

Although the main thread is created automatically when your program is started, it can be
controlled through a Thread object. To do so, you must obtain a reference to it by calling the
method currentThread( ), which is a public static member of Thread. Its general form is shown
here:
static Thread currentThread( )
This method returns a reference to the thread in which it is called.
Once you have a reference to the main thread, you can control it just like any other thread.
Let's begin by reviewing the following example:

Class CurrentThreadDemo{
◦ Public static void main(String args[])
◦ {
◦ Thread t = Thrad.currentThread();
◦ System.out.println(“Current Thread:”+t);
◦ T.setName(“My Thread”);
◦ Syste,.out.println(“After name chaged:”+t);
◦ Try{
◦ For(int n=5;n>0;n--)
◦ System.out.println(n);
◦ Thread.sleep(1000);
}
}catch(InterruptedException e){
System.out.println(“Main thread interrupted:”);}

In this program, a reference to the current thread (the main thread, in this case) is obtained by
calling currentThread( ), and this reference is stored in the local variable t.Next, the program
displays information about the thread. The program then calls setName( ) to change the internal
name of the thread. Information about the thread is then redisplayed. Next, a loop counts down
from five, pausing one second between each line. The pause is accomplished by the sleep( )
method. The argument to sleep( ) specifies the delay period in milliseconds. Notice the try/catch
block around this loop.
The sleep( ) method in Thread might throw an InterruptedException. This would happen if some
other thread wanted to interrupt this sleeping one. This example just prints a message if it gets
interrupted. In a real program, you would need to handle this differently. Here is the output
generated by this program:

Current thread: Thread[main,5,main]
After name change: Thread[My Thread,5,main]
5
4
3
2
1

Notice the output produced when t is used as an argument to println( ). This displays, in order:
the name of the thread, its priority, and the name of its group. By default, the name of the main
thread is main. Its priority is 5, which is the default value, and main is also the name of the
group of threads to which this thread belongs. A thread group is a data structure that controls
the state of a collection of threads as a whole. This process is managed by the particular run-
time environment and is not discussed in detail here. After the name of the thread is changed, t
is again output. This time, the new name of the thread is displayed

Let's look more closely at the methods defined by Thread that are used in the program.
The sleep( ) method causes the thread from which it is called to suspend execution for the
specified period of milliseconds. Its general form is shown here:
static void sleep(long milliseconds) throws InterruptedException
The number of milliseconds to suspend is specified in milliseconds. This method may throw an
InterruptedException. The sleep( ) method has a second form, shown next, which allows you to
specify the period in terms of milliseconds and nanoseconds:
static void sleep(long milliseconds, int nanoseconds) throws InterruptedException

This second form is useful only in environments that allow timing periods as short as
nanoseconds. As the preceding program shows, you can set the name of a thread by using
setName( ). You can obtain the name of a thread by calling getName( ) (but note that this
procedure is not shown in the program). These methods are members of the Thread class and
are declared like this:
final void setName(String threadName)
final String getName( )
Here, threadName specifies the name of the thread.

Creating a Thread
In the most general sense, you create a thread by instantiating an object of type Thread.
Java defines two ways in which this can be accomplished:
• You can implement the Runnable interface.
• You can extend the Thread class, itself.
The following two sections look at each method, in turn.
Implementing Runnable
The easiest way to create a thread is to create a class that implements the Runnable interface.
Runnable abstracts a unit of executable code. You can construct a thread on any object that
implements Runnable. To implement Runnable, a class need only implement a single method
called run( ), which is declared like this:

public void run( )
Inside run( ), you will define the code that constitutes the new thread. It is important to understand that run( )
can call other methods, use other
classes, and declare variables, just like the main thread can. The only difference is that run( ) establishes the entry
point for another, concurrent thread of execution within your program. This thread will end when run( ) returns.
After you create a class that implements Runnable, you will instantiate an object of type Thread from within that
class. Thread defines several constructors. The one that we willuse is shown here:
Thread(Runnable threadOb, String threadName)
In this constructor, threadOb is an instance of a class that implements the Runnable interface. This defines where
execution of the thread will begin. The name of the new thread is specified by threadName. After the new thread
is created, it will not start running until you call its start( ) method, which is declared within Thread. In essence,
start( ) executes a call to run( ). The start() method is shown here:
void start( )
Here is an example that creates a new thread and starts it running:

Inside NewThread's constructor, a new Thread object is created by the following statement:
t = new Thread(this, "Demo Thread");
Passing this as the first argument indicates that you want the new thread to call the run()
method on this object. Next, start( ) is called, which starts the thread of execution beginning at
the run( ) method. This causes the child thread's for loop to begin. After calling start( ),
NewThread's constructor returns to main( ). When the main thread resumes, it enters its for
loop. Both threads continue running, sharing the CPU, until their loops finish. The output
produced by this program is as follows:

Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread.
Main Thread: 2
Main Thread: 1
Main thread exiting.

Extending Thread
The second way to create a thread is to create a new class that extends Thread, and then to
create an instance of that class. The extending class must override the run( ) method, which is
the entry point for the new thread. It must also call start( ) to begin execution of the new
thread. Here is the preceding program rewritten to extend Thread:

Creating Multiple Threads
So far, you have been using only two threads: the main thread and one child thread. However,
your program can spawn as many threads as it needs. For example, the following program
creates three child threads:

Interthread Communication
The preceding examples unconditionally blocked other threads from asynchronous access to
certain methods. This use of the implicit monitors in Java objects is powerful, but you can
achieve a more subtle level of control through interprocess communication.
Polling is usually implemented by a loop that is used to check some condition repeatedly. Once
the condition is true, appropriate action is taken. This wastes CPU time.
For example, consider the classic queuing problem, where one thread is producing some data
and another is consuming it. To make the problem more interesting, suppose that the producer
has to wait until the consumer is finished before it generates more data

In a polling system, the consumer would waste many CPU cycles while it waited for the producer
to produce. Once the producer was finished, it would start polling, wasting more CPU cycles
waiting for the consumer to finish, and so on. Clearly, this situation is undesirable.

To avoid polling, Java includes an elegant interprocess communication mechanism via the wait(
), notify( ), and notifyAll( ) methods. These methods are implemented as final methods in
Object, so all classes have them. All three methods can be called only from within a
synchronized method. Although conceptually advanced from a computer science perspective,
the rules for using these methods are actually quite simple:
• wait( ) tells the calling thread to give up the monitor and go to sleep until some other thread
enters the same monitor and calls notify( ).
• notify( ) wakes up the first thread that called wait( ) on the same object.
• notifyAll( ) wakes up all the threads that called wait( ) on the same object. The highest priority
thread will run first.

These methods are declared within Object, as shown here:
final void wait( ) throws InterruptedException
final void notify( )
final void notifyAll( )
Additional forms of wait( ) exist that allow you to specify a period of time to wait.
The following sample program incorrectly implements a simple form of the
producer/consumer problem. It consists of four classes: Q, the queue that you're
trying to synchronize; Producer, the threaded object that is producing queue entries;
Consumer, the threaded object that is consuming queue entries; and PC, the tiny
class that creates the single Q, Producer, and Consumer.

Multithreading in java

More Related Content

What's hot

Viewers also liked

Similar to Multithreading in java

More from Raghu nath

Multithreading in java