Debre Derhan University

Debre Berhan university

name

name Biruk tewoderos

ID DBUR1790/13

COURSENAME JAVA PROGRAMMING

COURSECODE COSC3053

Contents Summited to Mr erku.k

1 What is a thread ?
Summited date 10/06/2023

Table of Contents
1 What is Thread? 2

2 Multithreading, Multitasking, Multiprocessing 3

3 Process vs thread 5

4 Thread-based multitasking and multithreading 8

5 Multi-thread and Thread synchronization, and priorities 9

6 Types of synchronization (process and thread) 10

7 Types of thread synchronization 10

8 Mutual exclusion threads and its type 11

9 How to achieve mutual exclusive thread 13

10 Inter-thread communication (implemented using wait (), notify () and notifyAll () 15

 INTRODUCTION
Parallelism is a key requirement for high performance and responsiveness in modern computing systems. To
achieve concurrency, multiple tasks must be executed at the same time. This is where the concept of threads
comes into play. A thread is simply a process that can run concurrently with other threads in the same process. A
thread shares the same memory as other threads in the same process, but has its own stack and program
counter. Multithreading, multitasking, and multiprocessing are techniques used to achieve parallelism in
computer systems. Multithreading is the ability for a single process to run multiple threads simultaneously.
Multitasking is the ability of the operating system to run multiple processes simultaneously. Multiprocessing is
the ability of a computer system to have multiple processors or cores to run multiple processes simultaneously.

This content takes a closer look at the concepts of threads, multithreading, multitasking, and multiprocessing. It
also explains the difference between processes and threads, and various techniques used to achieve thread-
based multitasking and multithreading. We'll also look at thread synchronization and priority, and the different
types of synchronization used in Java. It also provides sample code samples demonstrating various types of
thread synchronization and mutual exclusion. Finally, we'll discuss inter-thread communication and how to
implement it using the wait(), notify(), and notifyAll() methods.

What is Thread?
A thread is a single sequential flow of control within a program.
 A thread is a thread of execution in a program. The Java Virtual Machine allows an application to have multiple
threads of execution running concurrently. Every thread has a priority. Threads with higher priority are executed in
preference to threads with lower priority

independent unit of execution within a program that consists of a set of instructions and its own stack, program
counter, and registers. It represents the smallest unit of processing and allows parallel execution of multiple threads
within a larger program, making better use of system resources and improving application performance.

 Threads within a process, share the code, data, and heap sections but have their own stack segments.
Threads share static variables and instance variables of an object.

 Threads also have their own copies of CPU

registers like the Program Counter.

• There are two techniques to implement threads in Java:

✦To subclass Thread and override run().

✦To implement the Runnable interface (by defining run()) and embed class instances in a Thread object.

• Once a Thread instance is created, call the start() method to make it run.

✦ This causes the run() method to be executed in a separate thread.

✦ The code following the call to start() will execute concurrently with the thread’s run method.

In Java, a Thread is a lightweight, concurrent unit of execution that consists of a set of instructions. It is a separate
path of execution in a program that runs concurrently with other threads. Java supports multithreading, allowing
multiple threads to run simultaneously, thereby improving the efficiency and performance of a program.

 There may be more than one thread in a process.

✦Is called a multithreaded process.

Creating a thread
There are two ways to create a thread.

1 It can be created by extending the Thread class and overriding its run() method:

11 and is to implement the Runnable interface:

2

Running a thread
If your class extends the Thread class, you can run a thread by creating an instance of the class and calling its
start() method.
 Then If a class implements the Runnable interface, you can run a thread by passing an instance of the class to the
constructor of a Thread object and then calling the thread's start() method.

Multiprogramming
o "The simultaneous presence of multiple programs in main memory is called multiprogramming."
o Since there are multiple programs in memory, as soon as the currently running program finishes running, the next
one is sent to be used.
o Even if the currently executing program requests I/O resources, another program is submitted to the CPU for
execution in the meantime.
o The main goals of multiprogramming are:

o Maximum CPU usage.

o Efficient main memory management

Multithreading
is a technique used for concurrent execution of more than one part of a program, enabling maximum utilization of
CPU. The primary purpose of multithreading is to improve the performance and responsiveness of an application by
running threads in parallel, while also efficiently sharing processor resources and allowing other threads to continue
executing even if one thread is blocked or waiting.

o A thread is a light weight process.

Multitasking is a method of concurrently managing multiple tasks (programs) on a computer by effectively sharing
system resources, such as CPU, memory, and I/O devices. It allows multiple tasks to be executed simultaneously,
switching between them as needed and making the system more responsive and efficient.

o Multiple jobs are executed by the CPU simultaneously by switching between them.

Multiprocessing
is a system that uses multiple processors or multi-core processors to execute multiple tasks or processes
simultaneously. In a multiprocessing system, tasks can be distributed across multiple CPUs, enabling faster execution
and increased overall performance.

Multiprocessor systems can be divided into two types.

o Symmetric multiprocessing: Here the operating system resides on one of her processors and the other runs user
programs.
o Asymmetric Multiprocessing: The operating system runs on any available processor, or all processors run user
programs simultaneously.
o A multiprocessor system can be represented virtually as: 3

Difference between Multiprogramming, Multithreading, Multitasking

and Multiprocessing
 Multiprocessin
Feature Multiprogramming Multitasking Multithreading
g

Running Running
Running multiple
Running multiple multiple multiple
tasks
Definition programs on a single threads within a processes on
(applications) on
CPU single task multiple CPUs
a single CPU
(application) (or cores)

Resources
Resources (CPU, Each process
Resources (CPU, (CPU,
Resource memory) are has its own set
memory) are shared memory) are
Sharing shared among of resources
among programs shared among
tasks (CPU, memory)
threads

Uses priority- Uses priority-

Uses round-robin or based or time- based or time- Each process
priority-based slicing slicing can have its
Scheduling
scheduling to allocate scheduling to scheduling to own scheduling
CPU time to programs allocate CPU allocate CPU algorithm
time to tasks time to threads

Each task has its Threads share Each process

Memory Each program has its
own memory memory space has its own
Management own memory space
space within a task memory space

Requires a Requires a
Requires a
Requires a context context switch context switch
Context context switch to
switch to switch to switch to switch
Switching switch between
between programs between between
tasks
threads processes

Uses thread Uses inter-

synchronization process
Inter-Process Uses message passing Uses message
mechanisms communication
Communicatio or shared memory for passing or shared
(e.g., locks, mechanisms
n (IPC) IPC memory for IPC
semaphores) (e.g., pipes,
for IPC sockets) for IP

4
Process vs thread
Process
 A Process is inert. A process never executes anything; it is simply a container for threads.
 Threads run in the context of a process. Each process has at least one thread.
 A thread represents a path of execution that has its own call stack and CPU state.
 Threads are confined to context of the process that created them.
– A thread executes code and manipulates data within its process’s address space.
– If two or more threads run in the context of a single process they share a common address
space. They can execute the same code and manipulate the same data.
– Threads sharing a common process can share kernel object handles because the handles
belong to the process, not individual threads.

Properties of process
Here are the important properties of the process:

 Creation of each process requires separate system calls for each process.
 It is an isolated execution entity and does not share data and information.
 Processes use the IPC(Inter-Process Communication) mechanism for communication that
significantly increases the number of system calls.
 Process management takes more system calls.
 A process has its stack, heap memory with memory, and data map.

what is thread
Threads are a subset of processes, also known as lightweight processes. A process can contain multiple
threads, which are independently managed by the scheduler. All threads within a process are linked together.
Threads share information such as: B. Data segments, code segments, files, etc. shared between peer threads.
However, it contains its own registers, stacks and counters.

Properties of Thread
Here are important properties of Thread:

 Single system call can create more than one thread

 Threads share data and information.
 Threads shares instruction, global, and heap regions. However, it has its register and stack.
 Thread management consumes very few, or no system calls because of communication between
threads that can be achieved using shared memory

Thread type
There are two types of threads:
 1. User-level threads
As the name suggests, user-level threads are managed only by the user and the kernel has no

knowledge of them.
They are faster and easier to create and manage.
The kernel takes all these threads as her one process and treats them as just her one process.
User-level threads are implemented by user-level libraries, not by system calls

. 2. Kernel-level threads
Kernel-level threads are handled by the operating system and managed by the kernel. These threads are
slower than user-level threads because the context information is managed by the kernel. To create and
implement kernel-level threads, you need to make a system call.

Process
Global Variables

Process Heap

Process Environment Strings

Thread1 Stack Thread2 Stack Thread3 Stack

Thread1 Thread2 Thread3

Difference between Process and Thread:

S.NO Process Thread

Process means any program is in

Thread means a segment of a process.
1. execution.

The process takes more time to

The thread takes less time to terminate.
2. terminate.
S.NO Process Thread

3. It takes more time for creation. It takes less time for creation.

It also takes more time for

It takes less time for context switching.
4. context switching.

The process is less efficient in

Thread is more efficient in terms of communication.
5. terms of communication.

We don’t need multi programs in action for multiple

Multiprogramming holds the
threads because a single process consists of multiple
concepts of multi-process.
6. threads.

7. The process is isolated. Threads share memory.

The process is called the A Thread is lightweight as each thread in a process

8. heavyweight process. shares code, data, and resources.

Process switching uses an Thread switching does not require calling an operating
9. interface in an operating system. system and causes an interrupt to the kernel.

If one process is blocked then it

If a user-level thread is blocked, then all other user-
will not affect the execution of
level threads are blocked.
10. other processes

The process has its own Process

Thread has Parents’ PCB, its own Thread Control Block,
Control Block, Stack, and Address
and Stack and common Address space.
11. Space.

Since all threads of the same process share address

Changes to the parent process do space and other resources so any changes to the main
not affect child processes. thread may affect the behavior of the other threads of
12. the process.

13. A system call is involved in it. No system call is involved, it is created using APIs.
 S.NO Process Thread

The process does not share data

Threads share data with each other.
14. with each other.

Thread-based multitasking and multithreading

Thread-based multitasking and multithreading are programming concepts that allow the execution of
multiple threads simultaneously within a single process. They help to improve the efficiency and
performance of an application by allowing it to execute different tasks concurrently. Let's break down the
two concepts for a better understanding.

1. Thread-based multitasking:
Thread-based multitasking is a form of multitasking in which a single process has multiple threads of
execution. These threads belong to the same process, share its memory and resources and can run
concurrently, allowing tasks to be done simultaneously. Each thread works independently and executes
instructions in parallel or concurrently.
For example, in a word processor application, one thread can be responsible for spell checking, and
another for formatting the text simultaneously. This enhances the performance of the application since it
divides the tasks among different threads rather than executing them sequentially.

Multitasking can be achieved in two ways:

o Process-based Multitasking (Multiprocessing)

o Thread-based Multitasking (Multithreading)

1 Process-based multitasking (multiprocessing)

o Every process has an address in memory. That is, each process allocates a separate memory area.
o The process is heavyweight.
o Higher communication costs between processes.
o Switching from one process to another takes time saving and loading registers, allocating memory,
updating lists, etc.

8
2) thread-based multitasking (multithreading)
o Threads share the same address space.
o Threads are lightweight.
o Low communication cost between threads.

Multithreading:.
Multithreading is a technique employed in thread-based multitasking that allows multiple threads to
execute simultaneously within a single process. Multithreading enables a CPU to manage and run
multiple threads without the need to create a new process for each task. This enhances resource
utilization, improves application responsiveness, and reduces the overhead associated with process
creation.

Multi-thread and Thread synchronization, and priorities

Multi-threading:
Multi-threading is a technique or a concept in computer programming where multiple threads of execution
(smaller units of a process) are created within a single process, allowing multiple tasks to run concurrently
(simultaneously) within an application. This is one of the key methods for improving the performance of a
program, especially on multi-core processors. Multi-threading can be used to perform tasks like
background data loading, handling complex user interactions, or running multiple tasks simultaneously
without freezing the user interface.

Thread Synchronization:
 Programming a multi-threaded process requires great care. The main difficult issues are the sharing
of objects and the techniques used for thread coordination and cooperation.
 Each thread’s local variables in methods are private to it – threads have private stacks. However,
threads are not given private copies of static (class) variables or object instance variables.
 Thread synchronization is needed to as two threads may try to alter a shared instance or static
variable at the same time.
 Java allows threads to be blocked and woken up via arbitrary objects that act as condition variables.
A thread that needs to block awaiting a certain condition calls an object’s wait() method.
 Another thread calls notify() to unblock at most one thread or notifyAll() to unblock all threads
waiting on that object.
 As an example, when a worker thread discovers that there are no requests to process, it calls wait()
on the instance of Queue. When the I/O thread subsequently adds a request to the queue, it calls
the queue’s notify() method to wake up a worker.

it is a mechanism that ensures that different threads within a process can operate concurrently but in a
controlled manner. It ensures that only one thread can access shared resources (memory or data
structures) at a time, thus preventing race conditions or data corruption.
9

Thread synchronization concepts and techniques include:

1. Mutex (short for "Mutual Exclusion") - An object that ensures mutual exclusion among the threads,
thereby allowing only one thread to access shared resources at a time.
2. Semaphore - A value representing the number of threads that can access a shared resource
simultaneously.
3. Critical Section - A section of code where only one thread can execute at a given time and other threads
must wait for the current executing thread to finish.
4. Monitor - A synchronization construct that wraps around an object's methods, allowing only one thread
to access protected methods at a time.
5. Barriers - A synchronization point where multiple threads can meet and block each other until all
participating threads have reached the barrier.

Thread Priorities:
Thread priorities are assigned to the threads by the operating system, precisely the thread scheduler, to
determine the execution order of the threads in a multi-threaded environment. Threads with higher
priorities are prioritized for execution before the threads with lower priorities. However, different
operating systems and schedulers may handle priorities differently.
Thread priorities can be used to manage the responsiveness of an application, ensuring that critical tasks
are completed first or more frequently. For example, a thread handling user input should have a higher
priority than a background thread performing less important tasks.
Keep in mind that setting thread priorities are not a guaranteed way to predict or control the order of
thread execution, as this largely depends on the thread scheduler and the operating system. It is essential
to use appropriate thread synchronization techniques to ensure that important tasks complete in the
desired order.

Why use Synchronization?

The synchronization is mainly used to

1. To prevent thread interference.

2. To prevent consistency problem.

Types of synchronization (process and thread)

Process synchronization refers to the coordination and management of the order and timing of multiple
processes running concurrently within an operating system. This synchronization ensures that these
processes do not interfere with each other and can cooperate efficiently. Process synchronization
techniques are primarily used to prevent race conditions, ensure data consistency, and manage resource
allocation among different processes.
10
Thread synchronization, on the other hand, specifically deals with the coordination and management of
multiple threads within a single process. Since threads within a process share the same memory space and
resources, thread synchronization helps prevent race conditions, maintain data consistency, and manage
concurrent access to shared resources among various threads. Techniques used for thread synchronization
include locks, mutexes, semaphores, and barriers

There are two types of thread synchronization mutual exclusive and inter-thread communication.

1. Mutual Exclusive
1. Synchronized method
2. Synchronized block.
3. Static synchronization.
2. Cooperation (Inter-thread communication in java)

Mutual Exclusive
Mutual Exclusive helps keep threads from interfering with one another while sharing data. It can be
achieved by using the following three ways:

1. By Using Synchronized Method

2. By Using Synchronized Block
3. By Using Static Synchronization

Concept of Lock in Java

Synchronization is built around an internal entity known as the lock or monitor. Every object has a
lock associated with it. By convention, a thread that needs consistent access to an object's fields
has to acquire the object's lock before accessing them, and then release the lock when it's done
with them.

7 Mutual exclusion threads

import java.io.*;
import java.util.*;

class my {
public void my(String yxx)
{
System.out.println( yxx);
try {
Thread.sleep(100);
}
catch (Exception e) {
System.out.println("Thread interrupted.");
}
System.out.println( yxx );
}
}
class ThreadedSend extends Thread {
private String yxx;
my my;

ThreadedSend(String me, Sender bb)

{
yxx = me;
my = bb;
}

Public void run()

{

Synchronized (my)
{
my.send(yxx);
}
}
}

class we {
public static void main(String args[])
{
my send = new my();
ThreadedSend y1 = new ThreadedSend(" biruk ", send);
ThreadedSend y2 = new ThreadedSend("td ", send);

y1.start();
y2.start();

try {
y1.join();
y2.join();
}
catch (Exception e) {
System.out.println("Interrupted");
}
}}
Output
biruk Sent
td Sent

8 Mutual exclusion threads

Mutual exclusion (mutex) is a concurrency control mechanism that prevents multiple threads from
simultaneously executing critical sections of code that access shared resources, such as variables and data
structures. This helps to avoid race conditions, where the behavior of the program depends on the relative
timing of events, such as the order in which threads are scheduled to run.

In many programming languages and libraries, mutual exclusion can be achieved by using locks,
semaphores, or other synchronization primitives. When a thread wants to enter a critical section, it must
first acquire a lock or semaphore. If the lock is already held by another thread, the requesting thread will
have to wait until the lock is released. This way, only one thread can execute the critical section at a time.

class Mutual {
private int counter;
 public Mutual (int initialValue) {
this.counter = initialValue;
}
public synchronized void increment() {
counter++;
System.out.println("Incremented: " + counter);
}
public synchronized void decrement() {
counter--;
System.out.println("Decremented: " + counter);
}
}

class IncrementThread extends Thread {

private Mutual Mutual;

public IncrementThread(Mutual Mutual) {

this. Mutual = Mutual;
}

public void run() {

for (int i = 0; i < 10; i++) {
Mutual .increment();
}
}
}

class DecrementThread extends Thread {

private Mutual Mutual;

public DecrementThread(Mutual Mutual) {

this. Mutual r = Mutual;
}

public void run() {

for (int i = 0; i < 10; i++) {
Mutual.decrement();
}
}
}

public class MutexExample {

public static void main(String[] args) {
Mutual counter = new Mutual (0);
IncrementThread incrementThread = new IncrementThread(counter);
DecrementThread decrementThread = new DecrementThread(counter);

incrementThread.start();
decrementThread.start();

try {
incrementThread.join();
decrementThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("Final counter value: " + counter);

}
}
 How to achieve mutual exclusive thread
class my{
void printTable(int n){//method not synchronized.
for(int i=1;i<=5;i++){
System.out.println(n*i);
try{
Thread.sleep(400);
}catch(Exception e){System.out.println(e);}
}

}
}
class MyThread1 extends Thread{
my t;
MyThread1(Table t){
this.t=t;
}
public void run(){
t.printTable(5);
}

}
class Thread2 extends Thread{
my t;
Thread2(Table t){
this.t=t;
}
public void run(){
t.printTable(100);
}
}
class TestSynchronization1{
public static void main(String args[]){
Table obj = new Table();//only one object
MyThread1 t1=new MyThread1(obj);
MyThread2 t2=new MyThread2(obj);
t1.start();
t2.start();
}

TestSynchronization2.java

class my
{
synchronized static void printTable(int n){
for(int i=1;i<=10;i++){
System.out.println(n*i);
try{
we.sleep(400);
}catch(Exception e){}
}
}
}
class Thread1 extends we{
public void run(){
my.printTable(1);
}
}
class Thread2 extends we{
public void run(){
my.printTable(10);
 }
}
class Thread3 extends we{
public void run(){
my.printTable(100);
}
}
class Thread4 extends we{
public void run() {
my.printTable(1000);
}
}
public class TestSynchronization4{
public static void main(String t[]){
Thread1 t1=new Thread1 ();
Thread2 t2=new Thread2();
Thread3 t3=new Thread3();
Thread4 t4=new Thread4();
t1.start();t2.start();
t3.start();t4.start();
}
}

10. Inter-thread communication

Inter-thread communication in Java is a mechanism that allows multiple threads to communicate with each other by
exchanging data and sending signals while running simultaneously. This helps the various threads coordinate and
synchronize their operations. Several techniques are used to facilitate communication between Java threads:

* wait(), notify() and notifyAll() methods - These methods belong to the Object class and allow threads to
coordinate their actions by signaling each other. A thread can use the wait() method to wait for another thread to finish
its work. Another thread can use notify() to notify that the task has completed and wake up waiting threads.
NoticeAll() can notify multiple waiting threads. This mechanism requires a synchronized block or method to ensure
that only one thread can execute code at a time.

Example of Inter Thread Communication in Java

class C{
int am=200;

synchronized void withdraw(int am){

System.out.println("withdraw...");
if(this.am<am){
System.out.println("waiting for deposit...");
try{wait();}catch(Exception e){}
 }
this.am-=am;
System.out.println("completed...");
}
synchronized void deposit(int am){
System.out.println(" deposit...");
this.am+=am;
System.out.println("completed... ");
notify();
}}

class Test{
public static void main(String args[]){
final C c=new C();
new Thread(){
public void run(){c.withdraw(15000);}
}.start();
new Thread(){
public void run(){c.deposit(10000);}
}.start(); }}

communication example;

public class my {

public static void main(String[] args) throws InterruptedException {

we b = new we();
b.start();
synchronized (b) {
System.out.println(" calling wait() method"); // step 1
b.wait();
System.out.println(" notification call"); // step 4
System.out.println("totol balance " + b.totalBalance);
}

class we extends we {

int Balance = 0;

public void run() {

synchronized (this) {
System.out.println(" total balance"); // step 2
for (int i = 0; i <= 20; i++) {
Balance =Balance + i;
}
System.out.println(" notification call"); // step 3
this.notify();
}
 }

summary
  A thread is a single sequential flow of control within a program.
 Threads within a process, share the code, data, and heap sections but have their own stack segments.
 ✦ The code following the call to start() will execute concurrently with the thread’s run method.
 It is a separate path of execution in a program that runs concurrently with other threads.
 The primary purpose of multithreading is to improve the performance and responsiveness of an
application by running threads in parallel, while also efficiently sharing processor resources and
allowing other threads to continue executing even if one thread is blocked or waiting.
• Processes use the IPC(Inter-Process Communication) mechanism for communication that
significantly increases the number of system calls.

Reference

Java: The Comprehensive Guide to Java Programming for Professionals (Rheinwerk Computing)

Java: The Complete Reference (Osborne Complete Reference Series) 7th Edition

https://www.seas.upenn.edu/~cis110/current/lectures/References.pdf
https://www.simplilearn.com/tutorials/java-tutorial/java-api
https://i.stack.imgur.com/NVNge.jpg

17