Multi Threading
A thread is a light-weight
smallest process that can run concurrently with the other threads of the same
process and has its own call stack. Threads are independent because they all
have separate path of execution that’s the reason if an exception occurs in one
thread, it doesn’t affect the execution of other threads. All threads of a
process share the common memory. The
process of executing multiple threads simultaneously is known as
multithreading.
In Java there is one thread per
call Stack , Even if we don’t create threads in our program, threads are
running in background.
Since we know that the whole execution starts from main()
method, so that main() method run in one thread known as main thread, If we
look main call stack trace, we can see that main() is the first method on the
stack , but as soon as we create a new thread , a new stack created and method
called from that thread run in a call stack that is different from main() call
stack.
A very nice quote about thread :
When it comes to threads , a very
little is guaranteed
---
Kathy Sierra
Difference
between Multitasking – Multithreading - Multiprocessing
- Parallel Processing.
I have seen people are often confused between below mentioned
terms.
Multitasking: Ability
to execute more than one task at the same time is known as multitasking.
Multithreading: We already discussed
about it. It is a process of executing multiple threads simultaneously.
Multithreading is also known as Thread-based Multitasking.
Multiprocessing: It is same as multitasking, however
in multiprocessing more than one CPUs are involved. On the other hand one CPU
is involved in multitasking.
Parallel Processing: It refers to the utilization of
multiple CPUs in a single computer system.
Creation of a Thread
A
thread in java begins as an instance of java.lang.Thread. Lets have a look at
these methods of Thread class.
- start() –
Start a thread by calling its run method.
- run() –
Entry point of thread i.e the action happens in the run() methods, you always
write the code that needs to be run in a separate thread in a run() method. The
run method will call other methods
- getName():
It is used for Obtaining a thread’s name
- SetName(): It is used set a thread’s name.
- getPriority(): Obtain a thread’s priority.
- isAlive():
Determine if a thread is still running
- join(): One Thread join into the end of another thread and it will wait
for a current dependent thread to terminate
- Sleep(): suspend a thread for a period of time
- Yield() : Cause a thread to
go from running to runnable
- getId(): This Method return a
positive, unique, long number and that number will be thread’s only number for
the thread’s entire life.
There are two ways to create a thread in java
Ø Extending
Thread class
Ø Implementing
Runnable Interface
Please Note: Every thread of execution begins as an instance
of Thread class.
Regardless of whether you run() method in a Thread subclass
or a Runnable implementation class
n A new
thread of execution starts(with a new call stack)
n The thread
moves from the new state to the runnable state.
n When a
thread gets a chance to execute , it targets run() menthod
Example : -
Extending Thread class
Example 1 :
package multithreadingtc;
/**
*
* @author shashank
*/
public class MultithreadingTC extends Thread{
public void run()
{
System.out.println("Execution starts here");
}
public static void
main(String[] args) {
// TODO code
application logic here
MultithreadingTC th = new MultithreadingTC();
th.start();
}
}
Example 2 :
package multithreadingtc;
/**
*
* @author shashank
*/
class Multithreading extends Thread
{
public void run()
{
System.out.println("Execution
starts here");
}
}
public class MultithreadingTC{
public static void main(String[] args) {
// TODO code application logic here
Multithreading th = new
Multithreading();
th.start();
}
}
Example
implementing Runnable Interface
Example 1:
package multithreadingrunnable;
/**
*
* @author shashank
*/
class Multithreading implements Runnable
{
public void run()
{
System.out.println("Execution starts here");
}
}
public class MultithreadingTC{
public static void
main(String[] args) {
Multithreading
th = new Multithreading();// Instantiate Runnable class
Thread t = new
Thread(th);// Pass your runnable instance to the Thread
t.start();
}
}
Example :
Running multiple threads
package multithreadingtc;
/**
*
* @author shashank
*/
class Multithreading implements Runnable
{
public void run()
{
for(int
i=1;i<=3;i++)
{
System.out.println("run by" + Thread.currentThread().getName()
+ " value of i is " +i);
}
}
}
public class MultithreadingTC{
public static void
main(String[] args) {
// TODO code
application logic here
Multithreading
th = new Multithreading();
Thread t = new
Thread(th);
t.setName(" first");
t.start();
Thread t1 = new
Thread(th);
t1.setName(" second");
t1.start();
Thread t2 = new
Thread(th);
t2.setName(" third");
t2.start();
}
}
Please follow my next article over Thread States/Transitions/Scheduling and Synchronization.
