OPERATNG SYSTEM MODULE-2 PRESENTATION OS

• A thread library provides the programmer with an API for
creating and managing threads.
• There are two primary ways of implementing a thread library.
• First approach
– is to provide a library entirely in user space with no kernel
support.
– All code and data structures for the library exist in user
space which means that invoking a function in the library
results in a local function call in user space and not a
system call.
• Second approach
– is to implement a kernel-level library supported directly by
the operating system.
– In this case, code and data structures for the library exist in
kernel space.

• Three main thread libraries are in use today:
 POSIX Pthreads
 Windows Threads
 Java Threads
 Two general strategies for creating multiple threads:
 Asynchronous threading
 Synchronous threading
 In asynchronous threading, once the parent creates a
child thread, the parent resumes its execution, so that the
parent and child execute concurrently.
 Each thread runs independently of every other thread,
and the parent thread need not know when its child
terminates.
 Because the threads are independent, there is typically
little data sharing between threads.

• Synchronous threading occurs when the parent thread
creates one or more children and then must wait for all of
its children to terminate before it resumes —the so-called
fork-join strategy.
• Once each thread has finished its work, it terminates and
joins with its parent. Only after all of the children have
joined , the parent resume execution.
• Synchronous threading involves significant data sharing
among threads.
• For example, the parent thread may combine the results
calculated by its various children.

• The C program demonstrates the basic
Pthreads API for constructing a multithreaded
program that calculates the summation of a
non-negative integer in a separate thread.
• If N is 5, this function would represent the
summation of integers from 0 to 5, which is 15

#include <pthread.h>
#include <stdio.h> int sum; /* This data is shared by the thread(s) */
void *runner(void *param); /* Threads call this function */
int main(int argc, char *argv[])
{
pthread_t tid; /* The thread identifier */
pthread_attr_t attr; /* Set of thread attributes */
if (argc != 2)
{
fprintf(stderr, "usage: %s <integer value>n", argv[0]); return -1;
}
if (atoi(argv[1]) < 0)
{
fprintf(stderr, "%d must be >= 0n", atoi(argv[1]));
return -1;
} /* Get the default attributes */
pthread_attr_init(&attr);
/* Create the thread */
pthread_create(&tid, &attr, runner, argv[1]);
/* Wait for the thread to exit */
pthread_join(tid, NULL);
printf("sum = %dn", sum);
return 0;
} /* The thread will begin control in this function */
void *runner(void *param)
{
int i, upper = atoi(param);
sum = 0;
for (i = 1; i <= upper; i++)
sum += i;
pthread_exit(0);
}

• All Pthreads programs must include the pthread.h header file
• When creating a new thread, we typically specify a function
that the thread will run. This function is sometimes referred
to as the "runner function" or "thread function.“
• When this program begins, a single thread of control begins
in main().
• After some initialization, main() creates a second thread that
begins control in the runner() function.
• Both threads share the global data sum.
• pthread_t tid : Declares a variable tid of type pthread_t,
which is used to identify a thread.
• pthread_attr_t attr : Declares a variable attr of type
pthread_attr_t, which is used to store thread attributes.

if (argc != 2)
{
fprintf(stderr, "usage: %s <integer value>n", argv[0]);
return -1;
}
if (atoi(argv[1]) < 0)
{
fprintf(stderr, "%d must be >= 0n", atoi(argv[1]));
return -1;
}
this code block ensures that the program is provided with the correct
number of command-line arguments which are non-negative integer.
If these conditions are not met, the program prints an error message
and exits with a return code of -1, signaling an error state.

• A separate thread is created with the pthread
create() function call
• In addition to passing the thread identifier and
the attributes for the thread, we also pass the
name of the function where the new thread will
begin execution—in this case, the runner()
function.
• Last, we pass the integer parameter that was
provided on the command line, argv[1].
• At this point, the program has two threads:
– the initial (or parent) thread in main()
– the summation (or child) thread performing the
summation operation in the runner() function.

• pthread_join() Parent thread waits for the created
thread to finish before proceeding with the main
thread.
• printf("sum = %dn", sum): Prints the calculated sum
after the thread has finished.
• The summation thread will terminate when it calls
the function pthread exit().
• Once the summation thread has returned, the parent
thread will output the value of the shared data sum.

• Parent Thread (Main Thread):
– Initialize Attributes: pthread_attr_init(&attr);
– Create Thread: pthread_create(&tid, &attr,
runner, argv[1]);
– Wait for Thread to Finish: pthread_join(tid, NULL);
– Print Result: printf("sum = %dn", sum);
• Child Thread (runner function):
– Calculate Sum: for (i = 1; i <= upper; i++) sum += i;
– Exit Thread: pthread_exit(0);

A simple method for waiting on several threads using the
pthread join() function is to enclose the operation within a
simple for loop.

Windows Threads
• The technique for creating threads using the
Windows thread library is similar to the
Pthreads technique in several ways.

OPERATNG SYSTEM MODULE-2 PRESENTATION OS

• The program defines a global variable Sum to
store the sum of integers calculated by the
thread(s).
• The Summation function is the entry point for
the thread.
• It takes a parameter Param (a pointer to an
integer) and calculates the sum of integers
from 1 to the value pointed to by Param.

DWORD WINAPI Summation(LPVOID Param)
/* LPVOID is a generic pointer that indicates that the
pointer can point to data of any type */
{
DWORD Upper = *(DWORD*)Param;
/*retrieves that value from the memory location
pointed to by Param and storing it in the variable Upper
*/
for (DWORD i = 0; i <= Upper; i++)
Sum += i;
return 0;
}

int main(int argc, char *argv[])
{
DWORD ThreadId;
HANDLE ThreadHandle; declares a variable named ThreadHandle of type HANDLE
int Param;
if (argc != 2)
{
fprintf(stderr,"An integer parameter is requiredn");
return -1;
}
Param = atoi(argv[1]);
if (Param < 0)
{
fprintf(stderr,"An integer >= 0 is requiredn");
return -1;
}
this code block ensures that the program is provided with the correct number of
command-line arguments which are non-negative integer. If these conditions are not
met, the program prints an error message and exits with a return code of -1, signaling
an error state.

• ThreadHandle = CreateThread(...) - creates a
new thread using the CreateThread function
with the parameters passed.
• if (ThreadHandle != NULL) { ... }: This condition
checks if the thread creation was successful by
verifying that ThreadHandle is not NULL. If the
thread was successfully created, the code
inside the if block is executed.

• WaitForSingleObject(ThreadHandle,
INFINITE): waits for the created thread to
finish its execution. The WaitForSingleObject
function suspends the execution of the calling
thread until the specified thread (in this case,
ThreadHandle) terminates.
• INFINITE- wait indefinitely until the thread
finishes.
• CloseHandle(ThreadHandle);: After the
thread has finished, this line closes the handle
to the thread.

• This code creates a thread, waits for it to
finish, closes the thread handle to free up
resources, and then prints the calculated sum
to the console.

Java Threads
• All Java programs comprise at least a single thread
of control—even a simple Java program consisting
of only a main() method runs as a single thread in
the JVM.
• There are two techniques for creating threads in a
Java program.
• One approach is to create a new class that is
derived from the Thread class and to override its
run() method.
• Another approach—and more commonly used—
technique is to define a class that implements the
Runnable interface.

• The Runnable interface is defined as follows:
public interface Runnable
{
public abstract void run();
}
• When a class implements Runnable, it must
define a run() method.
• The code implementing the run() method is
what runs as a separate thread

– private int sum;: declares a private integer variable named sum.
Private keyword indicates that this variable can only be accessed
within the same class (Sum), and not from outside.
• Getsum Method:
public int getSum()
{
return sum;
}
This method is a getter method, which provides access to the
private sum variable.
It allows other classes to retrieve the value of sum without
directly accessing the variable.
The public keyword means that this method can be called from
outside the class.

• getSum() is used to retrieve the value of the private
sum variable, and the value can be modified using a
corresponding setSum() method.
• public void setSum(int sum) declares a method
named setSum that takes an integer parameter
named sum.
• The method has a void return type, indicating that it
doesn't return any value.
• this.sum = sum assigns the value of the parameter
sum to the private variable sum of the class.
• The use of this.sum is necessary to distinguish
between the class's private variable sum and the
method's parameter sum.

class Summation implements Runnable
The Summation class implements the Runnable
interface, which means instances of this class
can be executed by a separate thread.
private int upper represents the upper limit for
the summation.
It is a private instance variable, meaning it can
only be accessed within the Summation class.
private Sum sumValue variable is of type Sum
and represents an instance of the Sum class. It is
also a private instance variable.

• When the summation program runs, the JVM
creates two threads. The first is the parent
thread, which starts execution in the main()
method.
• The second thread is created when the start()
method on the Thread object is invoked. This
child thread begins execution in the run()
method of the Summation class.
• After outputting the value of the summation,
this thread terminates when it exits from its
run() method.

OPERATNG SYSTEM MODULE-2 PRESENTATION OS

Recommended

More Related Content

Similar to OPERATNG SYSTEM MODULE-2 PRESENTATION OS (20)

Recently uploaded (20)

OPERATNG SYSTEM MODULE-2 PRESENTATION OS