Thread model in java

Powerpoint Presentation

1. 1

2. THREADS
A Process is a program in execution.
Two or more processes are running
concurrently in a computer is called
multitasking.
Java provides support for multithreading.
Multithreading threading environment , tasks
are known as threads.
Threads share the same address space and
cooperatively share the same heavy weight
process.
2

3. THREADS
A Process is a program in execution.
Two or more processes are running
concurrently in a computer is called
multitasking.
Java provides support for multithreading.
Multithreading threading environment , tasks
are known as threads.
Threads share the same address space and
cooperatively share the same heavy weight
process.
3

4. Definition:
 A thread is a line of execution. It is the
smallest unit of code that is dispatched by
the scheduler. Thus a process can contain
multiple threads to execute its different
sections. This is called multithreading.
Single threaded process: A process is made
up of one thread is known as single threaded
process.
Multithreaded Process: A process that
creates two or more threadsis called a
multithreaded process.
4

5. A multithreaded program contains two or
more parts that can run concurrently.
Each part of such a program is called a
thread, and each thread defines a separate
path of execution.
Multithreading is a specialized form of
multitasking.
Many problems solved concurrently.
5

6. Improved performance
Minimized system resource usage
Simultaneous access to multiple applications
Program structure simplification
Types of multitasking:
Multitasking is theability to execute
more than one task at the same. It can
be divided into two categories:
process-based
thread-based
6

7. 7

8. Threads exist in several states. They
are:
Newborn state
Runnable state
Running state
Blocked state
Dead state
A Thread is always in one of these five
states.
8

9.  Whenwecreateathreadobject,the
threadisbornandissaidtobeinnewborn
state.Atthisstate,wecandoonlyoneof
thefollowingthings:
(i) Schedule it for running using start() method
(ii) Kill it using stop() method
9

10. 10

11.  Itmeansthethreadisreadyfor
executionandiswaitingfortheavailability
oftheprocessor.
 Thethreadhasjoinedthequeueof
threadsthatarewaitingforexecution.
 Ifallthreadshaveequalpriority,then
theyaregiventimeslotsforexecutionin
roundrobinfashion.
 Thethreadthatrelinquishescontrol
(yield)joinsthequeueattheendandagain
waitsforitsturn.Thisprocessofassigning
timetothreadsisknownastime-slicing.
11

12. 12

13. Runningmeansthattheprocessorhasgiven
itstimetothethreadforitsexecution.
Thethreadrunsuntilitrelinquishescontrol
onitsownoritispreemptedbyahigher
prioritythread.
Arunningthreadmayrelinquishitscontrol
inoneofthefollowingsituations:
13

14. 14

15.  Athreadissaidtobeblockedwhenitis
preventedfromenteringintotherunnable
stateandsubsequentlytherunningstate.
 Thishappenswhenthethreadis
suspended,sleeping,orwaitinginorderto
satisfycertainrequirements.
15

16. Arunningthreadendsitslifewhenithas
completedexecutingitsrun()methodorwe
cankillitbysendingthestopmessage.
16

17. Start()-Thestartmethodstartsexecution
oftheinvokingobject.Itcanthrowan
IllegalThreadStateExceptionifthethread
wasalreadystarted.
Stop()–Thismethodterminatestheinvoking
object.
Suspend()–Themethodsuspendsthe
invokingobject.Thethreadwillbecome
runnableagainifitgetstheresume()
method.
Sleep()–Thismethodsuspendsexecutionof
theexecutingthreadforthespecified
numberofmilliseconds.Itcanthrowan
InterruptedException. 17
A running thread ends its life when it has completed executing its run() method or we can kill it by sending the stop message.

18. Thesyntax
Publicstaticvoidsleep(longms)
Thefollowingstatementcansuspend
executionoftheexecutingthreadforthe
specifiednumberofmillisecondsplus
nanoseconds.
Publicstaticvoidsleep(longms,intns)
Resume()–Theresume()methodrestartsthe
suspendedthreadatthepointatwhichit
washalted.Theresume()methodiscalledby
somethreadoutsidethesuspendedone,
thereisaseparateclasscalledResumed
whichdoesjustthat.
18

19. 19

20. WhenaJavaprogramstartsup,onethread
beginsrunningimmediatelycalledthemain
threadoftheprogram.
ItcanbecontrolledthroughaThreadobject,
currentThread(),whichisapublicstatic
memberofThread.Itsgeneralformis:
staticThreadcurrentThread()
Itreturnsareferencetothethreadinwhichit
iscalled.
20

21. class CurrentThreadDemo {
public static void main(String args[ ])
{
Thread t = Thread.currentThread();
System.out.println("Current thread: " + t);
// change the name of the thread
t.setName("My Thread");
System.out.println("After name change: " + t);
21

22. try {
for(int n = 5; n > 0; n--) {
System.out.println(n);
Thread.sleep(1000);
}
}
catch (InterruptedException e)
{
System.out.println("Main thread interrupted");
}
} }
22

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

24. Itisusedasanargumenttoprintln().This
displays,inorder:
thenameofthethread,
itspriority,and
thenameofitsgroup.
Bydefault,thenameofthemainthread
ismain.Itspriorityis5,whichisthe
defaultvalue,andmainisalsothename
ofthegroupofthreadstowhichthis
threadbelongs.
24

25. 1. sleep( ) :
It causes the thread from which it is called
to suspend execution for the specified period
of milliseconds and also in nanoseconds.
static void sleep(long milliseconds) throws
InterruptedException
static void sleep(long milliseconds, int
nanoseconds) throws InterruptedException
2. setName( ):
To set the name of a thread.
final void setName(String threadName)
25

26. 3. getName( ):
To obtain the name of a thread
final String getName( )
threadNamespecifiesthenameofthe
thread.
TheThreadclassdefinesseveralmethods
thathelpmanagethreads.
26

27. Method Meaning
getName() Obtain a thread’s
name.
setName(String) Sets the thread name
getPriority() Obtain a thread’s
priority.
isAlive() Determine if a thread
is still running.
27

28. Join() -Wait for a thread to
terminate.
run -Entry point for the thread.
sleep -Suspend a thread for a
period of time (ms).
start -Start a thread by calling its
run method.
28

29. activeCount()-Returnsthecurrentnumber
ofactiveThreadsinthisThreadGroup.
ToString() -Returns the string
representationoftheThread,includingthe
thread’sname,priorityandthreadgroup.
currentThread()-Returnsareferencetothe
currentlyexecutingThreadobject&isa
staticmethod.
29

30. A thread can be created in two ways;
Runnable interface.
Extend the Thread class, itself.
30

31. ToimplementRunnable,aclassneedonly
implementasinglemethodcalledrun(),
whichisdeclaredas:
publicvoidrun()
Then,instantiateanobjectoftypeThread
fromwithinthatclassusingconstructors.
Thread(Runnable threadOb, String
threadName)
Afterthenewthreadiscreated,itwillnot
startrunninguntilyoucallitsstart()
method,whichisdeclaredwithinThread.
voidstart()
31

32. class CreateThreadDemo
{
public static void main(String args[ ])
{
new NewThread(); // create a new thread
try
{
for(int k = 10; k > 6; k--){
System.out.println("Parent Thread: " + k);
Thread.sleep(1000);
}
}
32

33. catch (InterruptedException e)
{
System.out.println("Parent
Interrupted.");
}
System.out.println("Exiting Parent.");
}
}
33

34. class NewThread implements Runnable
{
Thread T;
NewThread() //a new, second thread
{
T = new Thread(this, "Creating Thread");
System.out.println("Thread of child: " +
T);
T.start(); // Start the thread
}
34

35. public void run() // Point of entry for the
second thread.
{
try
{
for(int j = 10; j > 6; j--){
System.out.println("Child Thread: " + j);
Thread.sleep(500);}
}
catch (InterruptedException e){
System.out.println("Child interrupted.");
}
System.out.println("Exiting Child.");
} }
35

36. Thread of child: Thread [Creating
Thread,5,main]
Parent Thread: 10
Child Thread: 10
Child Thread: 9
Parent Thread: 9
Child Thread: 8
Child Thread: 7
Parent Thread: 8
Exiting Child.
Parent Thread: 7
Exiting Parent.
36

37. class CreateThreadDemo
{
public static void main(String args[ ]){
new NewThread(); // create a new
thread
try
{
for(int k = 10; k > 6; k--) {
System.out.println("Parent Thread: " +k);
Thread.sleep(1000);
} }
37

38. catch (InterruptedException e)
{
System.out.println("Parent
Interrupted.");
}
System.out.println("Exiting Parent.");
}
}
38

39. class NewThread extends Thread
{
NewThread() //a new, second thread
{
super(“Demo Thread”);
System.out.println("Thread of child: “+this);
start(); // Start the thread
}
39

40. public void run() // Point of entry for the
second thread.
{
try
{
for(int j = 10; j > 6; j--)
{
System.out.println("Child Thread: " + j);
Thread.sleep(500);
}
}
40

41. catch (InterruptedException e)
{
System.out.println("Child interrupted.");
}
System.out.println("Exiting Child.");
}
}
41

42. To determine whether a thread has finished.
final boolean isAlive( )
It returns true if the thread upon which it is
called is still running, otherwise returns
false.
The method used to wait for a thread to
finish is called join( ),
final void join( ) throws
InterruptedException
This method waits until the thread on which
it is called terminates.
42

43. class NewThread implements Runnable
{
String name; // name of thread
Thread t;
NewThread(String threadname)
{
name = threadname;
t = new Thread(this, name);
System.out.println("New thread: " + t);
t.start(); // Start the thread
}
43

44. public void run()
{
try {
for(int i = 3; i > 0; i--)
{
System.out.println(name + ": " + i)
Thread.sleep(1000);
}
}
44

45. catch (InterruptedException e)
{
System.out.println(name +
"Interrupted"); }
System.out.println(name + "exiting.");
}
}
class MultiThreadDemojoin {
public static void main(String args[])
{
NewThread ob1=new NewThread("One");
NewThread ob2=new NewThread("Two");
NewThread ob3=new NewThread("Three");
45

46. System.out.println("Thread 1 is
alive:"+ob1.t.isAlive());
System.out.println("Thread 2 is
alive:"+ob2.t.isAlive());
System.out.println("Thread 3 is
alive:"+ob3.t.isAlive());
try
{
ob1.t.join();
ob2.t.join();
ob3.t.join();
}
46

47. catch (InterruptedExceptione)
{
System.out.println("Main thread
Interrupted"); }
System.out.println("Thread 1 is
alive:"+ob1.t.isAlive());
System.out.println("Thread 2 is
alive:"+ob2.t.isAlive());
System.out.println("Thread 3 is
alive:"+ob3.t.isAlive());
System.out.println("Main thread
Exiting");
}
}

47

48. New thread: Thread[One,5,main]
New thread: Thread[Two,5,main]
New thread: Thread[Three,5,main]
One: 3
Two: 3
Thread 1 is alive:true
Thread 2 is alive:true
Thread 3 is alive:true
Three: 3
One: 2
Two: 2
Three: 2
48

49. Three: 1
One: 1
Two: 1
Three exiting.
One exiting.
Two exiting.
Thread 1 is alive: false
Thread 2 is alive: false
Thread 3 is alive: false
Main thread Exiting
49

50. Threadprioritiesareusedbythethread
schedulertodecidewheneachthreadshould
beallowedtorun.
Intheory,higher-prioritythreadsgetmore
CPUtimethanlowerprioritythreads.
Inpractice,theamountofCPUtimethata
threadgetsoftendependsonseveralfactors
besidesitspriority.
Tosetathread’spriority,usethesetPriority(
)method,whichisamemberofThread.This
isitsgeneralform:
 final void setPriority(int level)
50

51. Here, level specifies the new priority setting
for the calling thread.
The value of level must be within the range
MIN_PRIORITY and MAX_PRIORITY.
• MIN_PRIORITY =1
• MAX_PRIORITY = 10
• NORM_PRIORITY = 5 (default priority)
51

52. class Counter implements Runnable
{
Thread thread;
intcounter = 0;
volatile booleangoflag; // volatile –its value
can be changed by another thread
public Counter(intp)
{
thread = new Thread(this);
thread.setPriority(p);
}
52

53. public void start()
{ goflag= true;
thread.start();
}
public void run()
{ while (goflag)
counter++;
}
public void end()
{ goflag= false;
}
}
53

54. class PriorityDemo{
public static void main(String args[])
{
Counter thread1= new Counter
(Thread.NORM_PRIORITY+ 2);
Counter thread2 = new Counter
(Thread.NORM_PRIORITY+ 1);
Counter thread3 = new Counter
(Thread.NORM_PRIORITY-1);
Counter thread4 = new Counter
(Thread.NORM_PRIORITY-2);
54

55. thread1.start();
thread2.start();
thread3.start();
thread4.start();
try { Thread.sleep(5000); }
catch (InterruptedExceptione) {}
thread1.end();
thread2.end();
thread3.end();
thread4.end();
55

56. System.out.println("Thread 1 counted: " +
thread1.counter);
System.out.println("Thread 2 counted: " +
thread2.counter);
System.out.println("Thread 3 counted: " +
thread3.counter);
System.out.println("Thread 4 counted: " +
thread4.counter);
} }
Output:
Thread 1 counted: 145565315
Thread 2 counted: 123477095
Thread 3 counted: 6936384
Thread 4 counted: 6057269
56

57. Whentwoormorethreadsneedaccesstoa
sharedresource,theyneedsomewayto
ensurethattheresourcewillbeusedbyonly
onethreadatatime.Theprocessbywhich
thisisachievediscalledsynchronization.
Keytosynchronizationistheconceptofthe
monitoralsocalledasemaphore.
Amonitorisanobjectthatisusedasa
mutuallyexclusivelock,ormutex.
57

58. Onlyonethreadcanownamonitorata
giventime.
Whenathreadacquiresalock,itissaidto
haveenteredthemonitor.
Allotherthreadsattemptingtoenterthe
lockedmonitorwillbesuspendeduntilthe
firstthreadexitsthemonitor.Theseother
threadsaresaidtobewaitingforthe
monitor.
58

59. class SynchronizeDemo1
{
public static void main(String args[ ])
{
Shared shared= new Shared();
CustomThreadthread1 = new
CustomThread(shared, "one");
CustomThreadthread2 = new
CustomThread(shared, "two");
CustomThreadthread3 = new
CustomThread(shared, "three");
CustomThreadthread4 = new
CustomThread(shared, "four");
59

60. try
{
thread1.join();
thread2.join();
thread3.join();
thread4.join();
}
catch(InterruptedExceptione) { }
}
}
60

61. class CustomThreadextends Thread {
Shared shared;
public CustomThread(Shared shared, String
string) {
super(string);
this.shared= shared;
start(); }
public void run()
{
synchronized(shared)
{
shared.doWork(Thread.currentThread().getNa
me()); }
} }
61

62. class Shared{
void doWork(String string) {
System.out.println("Starting " + string);
try {
Thread.sleep((long) (Math.random() * 500));
}
catch (InterruptedExceptione) { }
System.out.println("Ending " + string);
}
62

63. Starting one
Ending one
Starting two
Ending two
Starting three
Ending three
Starting four
Ending four deprecate
63