Concurrency-1 Introduction to Processes

and Threads

In this tutorial, we will cover the following concepts.

How Computer Applications Run

Concurrency: Real-World Applications of Threads

- Google Docs
- Music Player
- Adobe Lightroom

Processes and Threads

- Benefits of Multithreading
- Challenges of Multithreading

Concurrent vs Parallel Execution

Multithreading in Java

Thread Creation
- Subclass of Thread Class
- Using Runnable
Starting a Thread
Problem Statement 1 : Number Printer

Additional Concepts

Commonly used Methods on Threads

Problem Statement 2: Factorial Computation Task
Thread Lifecycle & States

Understanding How Computer Applications Run

Computer applications are complex systems that run on a computer's operating system,
interacting with hardware and software components to perform various tasks. To comprehend
how these applications operate efficiently, it's essential to delve into fundamental concepts like
processes, threads, CPU scheduling, multithreading, and parallel execution. Let us understand
how a program runs.

1. Programs / Processes

Programs: These are sets of instructions for the computer. Each application you use, such as a
web browser or word processor, is a program.
Processes: When you open a program, it becomes a process. A process is an instance of a
program in execution.

2. Memory Allocation
When you start a program, the operating system (OS) allocates memory to it. This memory
contains the program's code, data, and other necessary information.

3. Processor (CPU) Execution

The Central Processing Unit (CPU) is the brain of the computer. It fetches instructions from
memory and executes them.
Each process takes turns using the CPU. The OS manages this by employing a technique called
CPU Scheduling.

4. Context Switching

The CPU rapidly switches between different processes. This is known as context switching.
The OS saves the current state of a process, loads the state of the next process, and hands
control to it.

5. Multitasking

The ability of a computer to execute multiple processes concurrently is called multitasking.

While it may seem like everything is happening at once, the CPU is actually rapidly switching
between processes.

6. Parallel Execution

In some systems, especially those with multiple processors or cores, true parallel execution can
occur. This means multiple processes genuinely run simultaneously.

7. Threads

A process can be further divided into threads. Threads within a process share the same
resources but can execute independently. Multithreading allows for parallel execution within a
single process.

8. Synchronization

When multiple processes or threads share resources (like data), synchronization mechanisms
are employed to avoid conflicts. This ensures that data remains consistent.We will discuss
synchronization in great detail in coming lectures.

9. Task Management by the Operating System

The OS keeps track of all running processes and manages their execution.
It assigns priorities, allocates resources, and ensures fair access to the CPU. This is done by
scheduling algorithms. Some of the popular scheduling algorithms are as follows -

First-Come-First-Serve (FCFS): Processes are executed in the order they arrive.

Shortest Job Next (SJN): The process with the shortest execution time is selected.
Round Robin (RR): Each process gets a fixed time slice, then moves to the back of the
queue.
Priority Scheduling: Processes are assigned priorities, and the highest priority process is
executed first.
Modern CPUs often employ a mix of static and dynamic scheduling strategies.
Advanced techniques, like predictive algorithms, may be used to anticipate the next process to
run.

10. Interrupts

The CPU can be interrupted to handle external events, like input from a user or data arriving
from a network.Interrupts are crucial for maintaining responsiveness in a multitasking
environment.

11. Termination of Processes

When a program finishes its task or is closed by the user, the associated process is terminated.
The OS reclaims the allocated resources and frees up memory.

12. Efficient Resource Utilization

The goal is to efficiently utilize the available resources, ensuring that each running application
gets its fair share of CPU time. In summary, the execution of multiple applications or processes
involves careful management by the operating system, with the CPU rapidly switching between
tasks, allocating resources, and ensuring that everything runs smoothly. Multitasking and, in
some cases, parallel execution contribute to the efficiency and responsiveness of modern
computer systems.

Conclusion

Understanding how computer applications run involves grasping the intricacies of processes,
threads, CPU scheduling, multithreading, and parallel execution. As technology evolves,
mastering these concepts becomes increasingly important for developing efficient and
responsive applications. Experimenting with these concepts in programming languages and
frameworks will deepen your understanding and proficiency in building robust and high-
performance software.

Concurrency: Real-World Applications of Threads

Concurrent programming, which involves the execution of multiple tasks simultaneously, is a
fundamental concept in modern software development. One powerful mechanism for achieving
concurrency is the use of threads. Let's explore how threads are employed in real-world
applications, focusing on Google Docs, Music Players, and Adobe Lightroom.

Concurrent programming enables multiple operations to progress in overlapping time intervals.

Threads, the smallest units of execution within a process, are instrumental in achieving
concurrency. They allow different parts of a program to run concurrently, enhancing efficiency
and responsiveness.

1. Google Docs: Collaborative Editing

Google Docs exemplifies the power of concurrency through its collaborative editing feature.
When multiple users are editing a document simultaneously, threads come into play. Each
user's edits are handled by a separate thread, ensuring that changes made by one user do not
disrupt the editing experience of others.
Threads in Google Docs

Thread per User: Each user's editing actions are processed by an individual thread.
Conflict Resolution: Threads synchronize to resolve conflicts and merge edits
seamlessly.
Auto-Suggest/Auto-complete: A separate thread can run spell check for the words you
write.
UI Thread: A separate thread can continuously update UI for the users.

2. Music Players: Smooth Playback and User Interaction

In music players like Spotify or iTunes, threads are crucial for delivering a smooth user
experience during playback while allowing users to interact with the application concurrently.

How Threads Work in Music Players

Playback Thread: A dedicated thread manages audio playback, ensuring uninterrupted

streaming.
User Interface Thread: Another thread handles user interactions, such as browsing
playlists or adjusting settings.
Parallel Execution: Threads allow simultaneous playback and user interactions without
one affecting the other.

3. Adobe Lightroom: Image Processing

In photo editing applications like Adobe Lightroom, where resource-intensive tasks like image
processing are common, threads are employed to maintain responsiveness and reduce
processing times.

How Threads Work in Lightroom

Image Processing Threads: Multiple threads handle the processing of different parts of
an image concurrently.
Background Tasks: Threads enable background tasks like importing photos while
allowing users to continue editing.
Responsive UI: Threads ensure that the user interface remains responsive even during
computationally intensive operations.

Processes and Threads - Deep Dive

A process is an independent program in execution. It has its own memory space called heap,
code, data, and system resources. The heap isn't shared between two applications or two
processes, they each have their own. The terms process and application are often used
interchangeably. Processes enable multiple tasks to run concurrently, offering isolation and
independence.

Process Lifecycle

Creation: When a program is launched, it is loaded into memory, a process is created.

Execution: The process runs its instructions.
Termination: The process completes its execution or is terminated.
A thread is the smallest unit of execution within a process. Multiple threads can exist within a
single process, sharing the same resources like memory but executing independently.

Benefits of Multithreading - Why use multiple threads?

Performance: Threads can execute concurrently, enhancing performance.

Responsiveness: Multithreading allows a program to remain responsive during time-
consuming tasks. This is especially helpful in applications with user interfaces.
Efficiency: Exploiting parallelism improves overall system performance.
One of the most common reasons, is to offload long running tasks.
Instead of tying up the main thread, we can create additional threads, to execute tasks
that might take a long time. This frees up the main thread so that it can continue
working, and executing, and being responsive to the user.
You also might use multiple threads to process large amounts of data, which can
improve performance, of data intensive operations.
A web server, is another use case for many threads, allowing multiple connections and
requests to be handled, simultaneously.
Resource Sharing: Threads within a process share resources, reducing overhead.

Challenges

Data Synchronization: Threads may need to synchronize access to shared data to

prevent conflicts.
Deadlocks: Concurrent threads might lead to situations where each is waiting for the
other to release a resource.

We will address these challenges in the up-coming classes.

Concurrent Execution vs Parallel Execution

 Concurrent execution refers to the ability of a system to execute multiple tasks or
processes at the same time, appearing to overlap in time. Concurrent Execution can
happen on single core as well.

Parallel execution involves the simultaneous execution of multiple tasks or processes

using multiple processors or cores. Multiple cores are must for truly parallel execution.

Data Parallelism: Dividing a task into subtasks processed concurrently.

Task Parallelism: Assigning multiple independent tasks to separate processors/cores.

Key Differences

Concurrent Execution - Tasks may overlap in time but not necessarily execute
simultaneously.
Parallel Execution - Tasks are actively running at the same time on separate processors.

Resource Utilization

Concurrent Execution - Utilizes a single processor by interleaving tasks.

Parallel Execution - Utilizes multiple processors, ensuring more tasks are completed in the
same time frame.

Hardware Requirement

Concurrent Execution - Can occur on a system with a single processor.

Parallel Execution - Requires multiple processors or cores.
Example

Concurrent Execution - Multiple applications running on a single-core processor.

Parallel Execution - Image processing tasks being performed simultaneously on different
cores of a multi-core processor.

Multithreading in Java
In the Java, multithreading is driven by the core concept of a Thread. There are two ways to
create Threads in Java.

Thread Class: Java provides the Thread class, which serves as the foundation for creating and
managing threads.

Runnable Interface: The Runnable interface is often implemented to define the code that a
thread will execute.

Lets write some logic that runs in a parallel thread by using the Thread framework. In the below
code example we are creating two threads and running them concurrently.

Way-1 : Subclassing a Thread Class

public class NewThread extends Thread {

public void run() {
// business logic
...
}
}
}

Class to initialize and start our thread.

public class MultipleThreadsExample {

public static void main(String[] args) {
NewThread t1 = new NewThread();
t1.setName("MyThread-1");
NewThread t2 = new NewThread();
t2.setName("MyThread-2");
t1.start();
t2.start();
}
}

Way -2 : Using Runnable (Preferred Way)

class SimpleRunnable implements Runnable {

public void run() {
// business logic
}
}
public class Main {
public static void main(String[] args) {
Thread t = new Thread(new SimpleRunnable());
t.start();
}
}

The above SimpleRunnable is just a task which we want to run in a separate thread.
There’re various approaches we can use for running it; one of them is to use the Thread class.

Simply put, we generally encourage the use of Runnable over Thread:

When extending the Thread class, we’re not overriding any of its methods. Instead, we override
the method of Runnable (which Thread happens to implement).

This is a clear violation of IS-A Thread principle

Creating an implementation of Runnable and passing it to the Thread class utilizes
composition and not inheritance – which is more flexible
After extending the Thread class, we can’t extend any other class
From Java 8 onwards, Runnables can be represented as lambda expressions

public class ThreadWithLambdaExample {

public static void main(String[] args) {
// Creating a thread with a Runnable implemented as a lambda expression
Thread myThread = new Thread(() -> {
System.out.println(Thread.currentThread().getName());
...
}
});

// Starting the thread

myThread.start();
}
}

We create a new Thread and pass a Runnable as a lambda expression directly to its
constructor. The lambda expression defines the code to be executed in the new thread. In this
case, it's a simple prints message that prints the name of Thread.

Starting a Thread - Behind the Scenes

When you call thread.start() in Java, it initiates the execution of the thread and invokes the
run method of the thread. Here's a step-by-step explanation of what happens:

1. Thread Initialization

If you have a class that extends the Thread class, or if you have a class that implements the
Runnable interface, you create an instance of that class, which represents the thread.

Thread myThread = new MyThread(); // or Thread myThread = new Thread(new

MyRunnable());
The thread is in the "new" state after initialization. When you call start(), the thread transitions
to the "runnable" state. It is ready to run but is waiting for its turn to be scheduled by the Java
Virtual Machine (JVM).

myThread.start();

2. Thread Scheduling:

The JVM's scheduler determines when the thread gets CPU time for execution. The actual
timing is managed by the operating system, and it may vary.

3. run() Method Execution:

Once the thread is scheduled, the JVM calls the run method of the thread. The run method
contains the code that will be executed in the new thread.

class MyThread extends Thread {

public void run() {
// Code to be executed by the thread
}
}

If you implemented Runnable instead:

class MyRunnable implements Runnable {

public void run() {
// Code to be executed by the thread
}
}

4. Concurrent Execution:

If there are multiple threads in the program, they may execute concurrently, with each thread
running independently, potentially interleaving their execution.

5. Thread Termination:

The run method completes its execution, and the thread transitions to the "terminated" state.
The thread is no longer active.

Important Notes

Direct run Method Invocation: Calling the run method directly (myThread.run()) will not
start a new thread; it will execute the run method in the current thread (ie main
thread).

One-Time Execution: The start method can only be called once for a thread.
Subsequent calls will result in an IllegalThreadStateException.

In summary, calling thread.start() initiates the execution of a new thread, and the JVM
takes care of the thread scheduling and execution of the run method in a separate
concurrent context.
Problem Statement - 1 Number Printer
Write a program to print numbers from 1 to 100 using 100 different threads. Since you can't
control the order of execution of threads, it is okay to get these numbers in any order.
Hint: Create a Runnable Task, which prints a single number.

Solution

NumberPrinter.java

public class NumberPrinter implements Runnable {

int number;
NumberPrinter(int number){
this.number = number;
}
@Override
public void run(){
System.out.println("Printing "+number + " from
"+Thread.currentThread().getName());
}
}

Main.java

public class Main {

public static void main(String[] args) {
for(int i=0; i<100;i++){
Thread t = new Thread(new NumberPrinter(i));
t.start();
}
}
}

Sample Output

Printing 3 from Thread-3

Printing 19 from Thread-19
Printing 14 from Thread-14
Printing 6 from Thread-6
Printing 21 from Thread-21
Printing 22 from Thread-22
Printing 0 from Thread-0
Printing 10 from Thread-10
...
Printing 94 from Thread-94
Printing 95 from Thread-95
Printing 96 from Thread-96
Printing 97 from Thread-97
Printing 98 from Thread-98
Printing 99 from Thread-99
Additonal Concepts (Optional)
Lets cover some more advanced concepts related to Threads.

Commonly used Methods on Threads

In Java, the Thread class provides several commonly used methods for managing and
controlling threads. Here are some of the key methods:

1. start()

Initiates the execution of the thread, causing the run method to be called.
Usage myThread.start();

2. run()

Contains the code that will be executed by the thread. This method needs to be overridden
when extending the Thread class or implementing the Runnable interface.
Usage: Defined by the user based on the specific task.

3. sleep(long milliseconds)

Description: Causes the thread to sleep for the specified number of milliseconds, pausing its
execution.
Usage:Thread.sleep(1000);

4. join()

Waits for the thread to complete its execution before the current thread continues. It is often
used for synchronization between threads.
Usage: myThread.join();

5. interrupt()

Interrupts the thread, causing it to stop or throw an InterruptedException. The thread must
handle interruptions appropriately.
Usage:
myThread.interrupt();

6. isAlive():

Returns true if the thread has been started and has not yet completed its execution, otherwise
returns false.
Usage: boolean alive = myThread.isAlive();

7. setName(String name)

Sets the name of the thread.

Usage: myThread.setName("MyThread");

8. getName()
Returns the name of the thread.
Usage: String threadName = myThread.getName();

9. setPriority(int priority)

Sets the priority of the thread. Priorities range from Thread.MIN_PRIORITY to

Thread.MAX_PRIORITY.
Usage: myThread.setPriority(Thread.MAX_PRIORITY);

10. getPriority()

Returns the priority of the thread.

Usage: int priority = myThread.getPriority();

11. currentThread()

Returns a reference to the currently executing thread object.

Usage: Thread currentThread = Thread.currentThread();

These methods provide essential functionality for managing thread execution, synchronization,
and interaction. When working with threads, it's crucial to understand and use these methods
effectively to create robust and efficient concurrent programs.

Problem Statement - 2 Factorial Computation Task

Write a program that computes Factorial of a list of numbers. Each factorial should be
computed on a separate thread. For each factorial calculation, do not wait for more than 2
seconds.
Hint: Use the join() method on each factorial thread, before main starts executing again.

Solution

FactorialThread.java
import java.math.BigInteger;

public class FactorialThread extends Thread {

private long number;
private BigInteger result;
private boolean isFinished;

FactorialThread(long number){
this.number = number;
result = BigInteger.valueOf(0); //Or BigInteger.ZERO;
isFinished = false;
}

@Override
public void run() {
//Business Logic
result = factorial(number);
isFinished = true;
}
BigInteger factorial(long n){
BigInteger ans = BigInteger.ONE;
for(long i=2; i<=n; i++){
ans = ans.multiply(BigInteger.valueOf(i));
}
return ans;
}

BigInteger getResult(){
return result;
}
boolean isFinished(){
return isFinished;
}
}
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {

// Task calculate Factorial of List of Numbers

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

List<Long> inputNumbers = Arrays.asList(100000000L, 3435L, 35435L,

2324L, 4656L, 23L, 5556L);
List<FactorialThread> threads = new ArrayList<>();
for(long number:inputNumbers){
FactorialThread t = new FactorialThread(number);
//System.out.println(t.getState());
threads.add(t);
}

for(Thread t:threads){
t.start();
}

for(Thread t:threads){
t.join(2000);
}

//--------------------//
for(int i=0;i<inputNumbers.size();i++){
FactorialThread t = threads.get(i); //ith Thread Object
if(t.isFinished()){
System.out.println(t.getResult());
}
else{
System.out.println("Couldn't complete calc in 2s");
}
}
System.out.println("Main is completed!");
}
}

Thread Life Cycle

During thread lifecycle, threads go through various states. The java.lang.Thread class
contains a static State enum – which defines its potential states. During any given point of
time, the thread can only be in one of these states:

NEW – a newly created thread that has not yet started the execution
RUNNABLE – either running or ready for execution but it’s waiting for resource
allocation
BLOCKED – waiting to acquire a monitor lock to enter or re-enter a synchronized
 block/method
WAITING – waiting for some other thread to perform a particular action without any
time limit
TIMED_WAITING – waiting for some other thread to perform a specific action for a
specified period
TERMINATED – has completed its execution

1.NEW

A NEW Thread (or a Born Thread) is a thread that’s been created but not yet started. It remains
in this state until we start it using the start() method.

The following code snippet shows a newly created thread that’s in the NEW state:

Runnable runnable = new NewState();

Thread t = new Thread(runnable);
System.out.println(t.getState());

Since we’ve not started the mentioned thread, the method t.getState() prints:

NEW

2. Runnable

When we’ve created a new thread and called the start() method on that, it’s moved from NEW
to RUNNABLE state. Threads in this state are either running or ready to run, but they’re waiting
for resource allocation from the system.

In a multi-threaded environment, the Thread-Scheduler (which is part of JVM) allocates a fixed

amount of time to each thread. So it runs for a particular amount of time, then leaves the
control to other RUNNABLE threads.

For example, let’s add t.start() method to our previous code and try to access its current
state:

Runnable runnable = new NewState();

Thread t = new Thread(runnable);
t.start();
System.out.println(t.getState());

This code is most likely to return the output as:

RUNNABLE

Note that in this example, it’s not always guaranteed that by the time our control reaches
t.getState(), it will be still in the RUNNABLE state.

It may happen that it was immediately scheduled by the Thread-Scheduler and may finish
execution. In such cases, we may get a different output.

3. BLOCKED

A thread is in the BLOCKED state when it’s currently not eligible to run. It enters this state when
it is waiting for a monitor lock and is trying to access a section of code that is locked by some
other thread.
Let’s try to reproduce this state:

public class BlockedState {

public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new DemoBlockedRunnable());
Thread t2 = new Thread(new DemoBlockedRunnable());

t1.start();
t2.start();

Thread.sleep(1000); //pause so that t2 states changes during this time

System.out.println(t2.getState());
System.exit(0);
}
}

class DemoBlockedRunnable implements Runnable {

@Override
public void run() {
commonResource();
}

public static synchronized void commonResource() {

while(true) {
// Infinite loop to mimic heavy processing
// 't1' won't leave this method
// when 't2' try to enter this
}
}
}

In this code:

We’ve created two different threads – t1 and t2, t1 starts and enters the synchronized
commonResource() method; this means that only one thread can access it; all other
subsequent threads that try to access this method will be blocked from the further execution
until the current one will finish the processing.

When t1 enters this method, it is kept in an infinite while loop; this is just to imitate heavy
processing so that all other threads cannot enter this method

Now when we start t2, it tries to enter the commonResource() method, which is already being
accessed by t1, thus, t2 will be kept in the BLOCKED state.
Being in this state, we call t2.getState() and get the output as:

BLOCKED

4. WAITING

A thread is in WAITING state when it’s waiting for some other thread to perform a particular
action. According to JavaDocs, any thread can enter this state by calling any one of the
following three methods:
 object.wait()
thread.join() or
LockSupport.park()

Note that in wait() and join() – we do not define any timeout period as that scenario is covered
in the next section.

In this example, thread-1 starts thread 2 and waits for thread-2 to finish using thread.join()
method. During this time t1 is in WAITING state.

Simple Runnable.java - Thread 1

public class SimpleRunnable implements Runnable{

@Override
public void run(){
Thread t2 = new Thread(new SimpleRunnableTwo());
t2.start();
try {
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

Simple Runnable 2 - Thread 2

public class SimpleRunnableTwo implements Runnable {

@Override
public void run() {
try{
Thread.sleep(5000);
}
catch(InterruptedException e){
Thread.currentThread().interrupt();
e.printStackTrace();
}
}
}

Main
public class Main {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new SimpleRunnable());
t1.start();

Thread.sleep(1000); //1ms pause

System.out.println("T1 :"+ t1.getState()); //T1 is waiting state
System.out.println("Main :" + Thread.currentThread().getState());
}
}

5. TIMED WAITING

A thread is in TIMED_WAITING state when it’s waiting for another thread to perform a particular
action within a stipulated amount of time.

According to JavaDocs, there are five ways to put a thread on TIMED_WAITING state:

thread.sleep(long millis)
wait(int timeout) or wait(int timeout, int nanos)
thread.join(long millis)
LockSupport.parkNanos
LockSupport.parkUntil

Here, we’ve created and started a thread t1 which is entered into the sleep state with a
timeout period of 5 seconds; the output will be TIMED_WAITING.

public class SimpleRunnable implements Runnable{

@Override
public void run() {
try{
Thread.sleep(5000);
}
catch(InterruptedException e){
e.printStackTrace();
}
}
}

In Main, if you check the state of T1 after 2s it will be TIMED WAITING

public class Main {

public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new SimpleRunnable());
t1.start();

Thread.sleep(2000);
System.out.println(t1.getState());
}
}

6. TERMINATED
This is the state of a dead thread. It’s in the TERMINATED state when it has either finished
execution or was terminated abnormally. There are different ways of terminating a thread.

Let’s try to achieve this state in the following example:

public class TerminatedState implements Runnable {

public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new TerminatedState());
t1.start();

// The following sleep method will give enough time for

// thread t1 to complete
Thread.sleep(1000);
System.out.println(t1.getState());
}

@Override
public void run() {
// No processing in this block

}
}

Here, while we’ve started thread t1, the very next statement Thread.sleep(1000) gives enough
time for t1 to complete and so this program gives us the output as:

TERMINATED

--End---