Java Thread & Multithreading

• In computer science, a thread of execution is
the smallest sequence of programmed
instructions that can be managed
independently by a scheduler (typically as part
of an operating system).

• multithreaded programming language which
means we can develop multithreaded
program using Java. A multithreaded program
contains two or more parts that can run
concurrently and each part can handle
different task at the same time making
optimal use of the available resources
specially when your computer has multiple
CPUs.

• Multithreading is the ability of a program or
an operating system process to manage its use
by more than one user at a time and to even
manage multiple requests by the same user
without having to have multiple copies of the
programming running in the computer. 235

Multi-threaded applications
• Responsiveness: Multi-threading has the ability for an
application to remain responsive to input. In a single-
threaded program, if the main execution thread blocks
on a long-running task, the entire application can
appear to freeze. By moving such long-running tasks to
a worker thread that runs concurrently with the main
execution thread, it is possible for the application to
remain responsive to user input while executing tasks
in the background. On the other hand, in most cases
multithreading is not the only way to keep a program
responsive, with non-blocking I/O and/or Unix signals
being available for gaining similar results

• Faster Execution: This advantage of a
multithreaded program allows it to operate
faster on computer systems that have multiple
or multi-core CPUs, or across a cluster of
machines, because the threads of the program
naturally lend themselves to truly concurrent
execution.

• Less Resource Intensive: Using threads, an
application can serve multiple clients
concurrently using less resource than it would
need when using multiple process copies of
itself. For example, the Apache HTTP server,
which uses a pool of listener and server
threads for listening to incoming requests and
processing these

• . Better System Utilization: Multi-threaded
applications can also utilize the system better.
For example, a file-system using multiple
threads can achieve higher throughput and
lower latency since data in faster mediums like
the cache can be delivered earlier while
waiting for a slower medium to retrieve the
data.

• Simplified Sharing and Communication:
Unlike processes, which require message
passing or shared memory to perform inter-
process communication, communication
between threads is very simple. Threads
automatically share the data, code and files
and so, communication is vastly simplified.

• Parallelization: Applications looking to utilize
multi-core and multi-CPU systems can use multi-
threading to split data and tasks into parallel sub-
tasks and let the underlying architecture manage
how the threads run, either concurrently on a
single core or in parallel on multiple cores. GPU
computing environments like CUDA and OpenCL
use the multi-threading model where dozens to
hundreds of threads run in parallel on a large
number of cores.

• Multi-threading has the following drawbacks:
• Synchronization: Since threads share the same address space, the
programmer must be careful to avoid race conditions and other
non-intuitive behaviors. In order for data to be correctly
manipulated, threads will often need to rendezvous in time in order
to process the data in the correct order. Threads may also require
mutually exclusive operations (often implemented using
semaphores) in order to prevent common data from being
simultaneously modified or read while in the process of being
modified. Careless use of such primitives can lead to deadlocks.
• Thread crashes Process: An illegal operation performed by a thread
crashes the entire process and so, one misbehaving thread can
disrupt the processing of all the other threads in the application.

Java library for threading
• import java.util.Random;

Implementing thread using Runnable
interface
• public class thread1 implements Runnable{
• @Override
• public void run()
• {
• System.out.println("hello world");
• }
• public static void main(String args[]) {
• //(new Thread(new hello_thread())).start();
• Thread t=new Thread(new thread1());
• t.start();
•
• }
• }

Creating thread using Extending
Thread class
• public class thread2 extends Thread{
• {
• System.out.println("helloworld");
• }
• public static void main(String[] args)
• {
• thread2 t=new thread2();
• t.start();
• }
•
• }

• Can we start a thread twice?
• No. After staring a thread, it can never be
started again. If you does so, an
IllegalThreadStateException is thrown.

Multithreaded Program for calculator
• public class calc_add extends Thread
• {
• @Override
• {
•
• try
• {
• int sum;
• int a=2;
• int b=4;
• sum=a+b;
• System.out.println(sum);
• Thread.sleep(8000);
• }
• catch(Exception e)
• {
• System.out.println(e);
• }
• }
• }

• public class calc_mul extends Thread {
• {
•
• try
• {
• int mul;
• int a=2;
• int b=4;
• mul=a*b;
• System.out.print(mul);
• }
• {
• }
•
• }}

• public class calc_min extends Thread{
• {
•
• try
• {
• int minus;
• int a=2;
• int b=4;
• minus=a-b;
• System.out.print(minus);
• }
• {
• }
•
• }}

• public class calc_main {
•
• public static void main(String[] args)
• {
• calc_add t1=new calc_add();
• calc_mul t2=new calc_mul();
• calc_min t3=new calc_min();
• t1.start();
• t2.start();
• t3.start();
• }
• }

Java Thread & Multithreading

Recommended

More Related Content

What's hot (20)

Viewers also liked (19)

Similar to Java Thread & Multithreading (20)

More from jehan1987 (7)

Recently uploaded (20)

Java Thread & Multithreading