DEV Community: Hrishikesh kumar

Multi-threading in Operating System

Hrishikesh kumar — Thu, 19 Sep 2019 10:36:16 +0000

We will go through the basics of multi-threading and single threading and advantages and disadvantages of both.

What is a thread?

Thread is the basic unit of CPU utilization i.e. how an application uses CPU. Let's understand it through an example.
Let's say we open a web-page, we often see the text contents being loaded before the image and video contents. Here loading the web-page is a process and the process contains 2 threads, one for loading the text contents and the other for loading the images contents.

Let's take another example consisting of basic coding problem. Suppose, we want to get the sum of the numbers in an array of length N. We can make this simple process of adding number multi threaded by associating 2 threads for summing them. One for the first half of array, and second for the other half of the array. And then sum the sum of two halves. Here the threads summing the both the halves are child threads and the thread having the final sum is called parent thread.

A process can have as many threads as required (limited to the hardware requirements, and efficiency overheads). Thus, it is clear that code, data, files belonging to a particular process will be common to all the threads in multi threaded process.

But each thread has it's unique thread Id, program counter, register set and stack memory as illustrated in following diagram:

Why do we need multi threading?

Responsiveness - Let's say in the aforementioned example, while loading a web-page, there is some large image being loaded and taking it's time. As the whole process is multi-threaded, the loading of image will not block the loading of text content thus making it more responsive to the user.
Resource sharing - Threads share the memory and resources of the process by default thus allowing application to have several different threads within same address space.
Economy - As threads share the same memory and resources that of the processes. It's economical to create and context switch threads vis-a-vis process creation.

What are the challenges of multi threading?

Identifying tasks to multi thread to make the application efficient.
Maintaining data integrity as there maybe situations where the same data is being manipulated by different threads.
Balancing cost- It is important to share the workload of application equally among different threads otherwise there will be threads doing less work than other creating economical overheads.
It is rather easy to test and debug a single threaded application than multi threaded one.

Parallelism

We would come across two terms very frequently, parallelism and concurrency. Generally, these two go hand-in-hand. But what exactly do they mean?

Parallelism vs Concurrency

A system is parallel if it can perform more than one task simultaneously.

Concurrency is when more than one task makes progress. Even if the system is single core, the CPU schedulers rapidly switch between processes therefore making illusion of parallel system and thus allowing progress for different tasks.

Therefore, it is important to note that concurrency can occur without parallelism.

Types of parallelism

Data parallelism- Here, same data is divided into groups and those subset of data are operated on different cores.
Task parallelism - Unique operations are performed onto the same data on different cores.

Multi-threading models

Many to one model

Many user level threads(threads created in application by user using thread library(explained later)) are mapped onto single kernel level thread. In this, there are following problems:-

Block statement on 1 user level thread blocks all the thread.
No true concurrency.
Not efficient use of multi-core architecture.

One to one model

Single user level thread is mapped onto single kernel level thread. It has following advantage over many to one model:-

Block statement on one thread doesn't blocks any other thread.
True concurrency.
Efficient use of multi-core system.

But it has a problem of overhead for creating as much kernel level threads.

Many to many model

Many user level threads are mapped onto equal or less number of kernel level threads. It solves the problem of overhead for creating kernel level threads.

This model has a variant namely 2 level model which includes many to many as well one to one model.

In this certain thread of a process are mapped onto a certain kernel level thread until it finishes it's execution.

Thread Library

Thread library is API for programmer to create and manage threads in their applications.

There can be two approaches for implementing thread library:-

The 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. This means that invoking a function in the library results in a local function call in user space and not a system call.
The 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. Invoking a function in the API for the library typically results in a system call to the kernel.

There are 3 main thread libraries:-

POSIX Pthreads- Maybe a user level or kernel level library. Mostly used by Linux/Unix based OS.
Windows - Kernel level.
Java - Thread created and managed directly in Java programs. As, JVM itself runs on an OS. So, it is implemented using a thread library present on the OS.

Thread creation

There are 2 strategies for thread creation:-

Asynchronous - Parent thread creates child then executes independently. It means, little data sharing between parent and child thread.
Synchronous - Parent thread waits for the child thread to finish it's execution. More of data sharing is done here.

Pthreads

POSIX standard for thread creation and synchronization.
These are mere specifications for thread behavior, not it's implementation.
Mostly implemented by UNIX type system.
Windows doesn't support it natively.

Windows threads

Similar to Pthread creation and management in many ways.
Differences in method names. For eg:- pthread.join() function is implemented here using WaitForSingleObject().

Java threads

2 techniques for implementing Java threads:-

New class derived from thread class and then override the run method.
Implement the runnable interface.

JVM hides the implementation details of underlying OS and provide consistent, abstract environment that allows Java program to operate at any platform.

All the above user level thread library creation and management comes in the category of explicit threading where the programmer creates and manages threads.
One more way to create and manage threads is to transfer the creation and management from application developers to compilers and run-time libraries. This strategy is known as implicit threading.

2 common strategies of implicit threading are:-

Thread Pool
Open MP

Thread Pool

There were few difficulties while explicit threading:-

How much thread to create in order to use multi-core architecture efficiently?
Time for creating thread.

The general idea behind a thread pool is to create a number of threads at process startup and place them into a pool, where they sit and wait for work. When a server receives a request, it awakens a thread from this pool—if one is available—and passes it the request for service. Once the thread completes its service, it returns to the pool and awaits more work. If the pool contains no available thread, the server waits until one becomes free.

Benefits of thread pool:-

Servicing a request with an existing thread is faster than waiting to create a thread.
Limits on number of threads. Thus, benefiting the system which doesn't support large number of threads.

Open MP

These are set of compiler directives as well as API to provide support for parallel programming.
It identifies the parallel region in the process and executes them.
We can also have control over number of thread being created and data being shared between the threads.

Finally, it's time to delve inside the issues while threading.

Threading issues

`fork()` and `exec()` system calls.

Whether all the threads of the process will be duplicated or it will become
single threaded after executing fork() statement.
exec() statement still almost works the same way i.e. program specified as
parameter will replace the whole process.

Signal handling

Signals are to mark any event while executing a process.
There are 2 types of handler:-

Default signal handler - Kernel runs this while handling the signal.
User defined signal handler - User defined handler will override the default signal handler.

In single threaded program, all the signals are delivered to the process.
In multi threaded program, there are 4 options:-

Deliver the signal to the thread to which the signal applies.
Deliver the signal to every thread in the process.
Deliver the signal to certain threads in the process.
Assign a specific thread to receive all signals for the process.

In case of synchronous signals, the signal needs to be delivered to the thread which signal applies.
In case of asynchronous signals, if the signal is affecting all the threads, then it is to be delivered to every thread. If it is affecting certain thread, then the signal is to be delivered to that certain thread.
Windows doesn't explicitly provides for signal handling but emulate it through Asynchronous procedure calls(APC) . APC is delivered to particular thread rather than the process.

Thread cancellation

The thread which is to be cancelled is known as target thread.
There are 2 strategies for thread cancellation:-

Asynchronous cancellation- One thread immediately terminates the target thread resulting in abrupt termination.
Deferred cancellation - Target thread periodically checks whether it should terminate or not, thus terminating in orderly fashion.

pthread_cancel(tid) only requests to cancel a thread. Original cancellation depends on how target thread is set up to handle request i.e. deferred or asynchronous.

Thread local Storage

Threads belonging to a process share the data of the process. However, in some circumstances, each thread might need its own copy of certain data. We will call such data thread-local storage(TLS). Most thread libraries—including Windows and Pthreads—provide some form of support for thread-local storage. Java provides support as well.

Scheduler activation

For a user level thread to be executed, it has to communicate with kernel level thread. The scheme for this communication is known as scheduler activation.

Kernel provides the application with a set of virtual processors known as light weight process(LWP)
App can schedule user threads on LWP.
Kernel must inform application about the events, called as upcall.
Upcalls are handled by the thread library with an upcall handler, and upcall handlers must run on a virtual processor.
In the case of upcall(let's say block), the kernel makes an upcall to the application informing it that a thread is about to block and identifying the specific thread.
The kernel then allocates a new virtual processor to the application.
The application runs an upcall handler on this new virtual processor, which saves the state of the blocking thread and relinquishes the virtual processor on which the blocking thread is running.
The upcall handler then schedules another thread that is eligible to run on the new virtual processor.
When the event that the blocking thread was waiting for occurs, the kernel makes another upcall to the thread library informing it that the previously blocked thread is now eligible to run.
The upcall handler for this event also requires a virtual processor, and the kernel may allocate a new virtual processor.
After marking the unblocked thread as eligible to run, the application schedules an eligible thread to run on an available virtual processor.

That's it for the basics of threading. Hope you had a good read.

JVM architecture in a nutshell

Hrishikesh kumar — Tue, 13 Aug 2019 14:38:46 +0000

We write a code in our IDE, How it is being executed? How does it shows the output which we want (not always!)? This question has perplexed many beginner as well as some high level coders. Here, I will try to answer those questions to some extent vis-a-vis JAVA.

So, it’s well established fact that all the dirty work of compiling, executing the code is done by Java Virtual Machine(JVM). But what exactly does JVM consists of? How does it executes a code?

Whatever we write on IDE is present in java source file(.java file). It is then compiled using Java compiler( by javac command). A java class file (.class file) is generated which is then fed to the class loader subsystem.

The whole JVM architecture looks as follows:

Class Loader Subsystem

It takes .class file and performs three operations on it:

Loading

All core Java API classes are loaded by Bootstrap class loader. The classes present inside extension folder such as jdk and jrk files are loaded by Extension class loader. Further Application class loader loads classes from application level and loads it into the class-path.

Linking

Here, the class file which is loaded is prepared for execution. Verify operation verifies the syntax. Static variables are allocated memory within prepare block, also those variables are initialized ( Attention:- here the variables are initialized with default values). Further, all symbolic references are replaced with original references from method area while resolve block is being executed.

Initialization

Finally, the static variables are initialized with the original value assigned and all the static blocks are executed.
Each and every file and operations require a memory area during run-time. JVM provides various run-time data areas.

Run-time Data Areas

Method Area

All .class files are dumped here. It also contains all the static variables.

Heap Area

It consists of all the instance variables or object data.

Stack Area

For every thread, separate run-time stack will be created which resides in stack area. And for every method called, one entry will be stored in the stack, that entry is called stack frame.

Each stack frame consists of 3 parts:

Local variable array:- As the name suggests, all the local variables of a method and their values are stored here.

Upper end stack:- This memory area is used for any intermediate operation within a method.

Frame data:- All symbols used in the method is stored here. Also, if any exception occurs, catch block is stored here.

PC Registers

For every thread, separate PC register is created in this area. A PC register contains the address of next executing instruction of that thread.

Lastly, Native method area holds all native method instructions.

Here, we can easily see, as for each thread a separate run-time stack is allocated in stack area, which implies that stack area is thread safe. While, for whole JVM, there will be only 1 method area and heap area, which implies that both of the aforementioned areas are not thread safe.

Execution Engine

Till now, the class is allocated memory and is loaded. All the dirty work of execution of a code is done by this engine. Just like CPU, this executes the program line by line. It also consists of different parts.

Interpreter

It reads, interprets and executes the code line by line.

JIT compiler

It comes into action only when there are repeatedly required methods, not for all methods. Profiler does the job of identifying the repeatedly required methods or hotspot methods.

Then there is garbage collector which collects those variables or methods which are unreachable in a code and frees the memory.

At last, there is native method interface or Java native interface(JNI) which simply provides an interface for Native method libraries to be loaded during run-time.
So, this is what makes up JVM and their functions.

Hope, it gives you a basic idea of what sorcery is going on within the machine!! Enjoy.

Processes in Operating System

Hrishikesh kumar — Fri, 31 May 2019 12:27:32 +0000

Here we will discuss the concept of processes in Operating system. For the basics of operating system you can visit the following article:

Basic Operating System services and structures.

Hrishikesh kumar ・ May 27 '19

#computerscience #explainlikeimfive

So, let's get going with the concept of processes.

Processes are the program in execution. It is not only a program code, but it can also be a program counter, current activity, heap, etc.

Process concept

Process state

There can be 5 process states at any time, which can be as follows:

New- When the process is about to be executed.
Running - when the processor is executing the process.
Waiting - when the process has been executed but waiting for something, let's say input from any device.
Ready - when the process is in the queue, ready to be sent to the CPU.
Terminated - when the execution is over and corresponding resource and memory is de-allocated.

Process state diagram:

Process Control Block(PCB)

Process control block consists of:

Process state:- As illustrated above.
Program counter:- It consists of the pointer pointing towards the address of the next statement to be executed.
CPU register:- PCB consists of state of CPU registers
CPU scheduling information:- To decide when to send a process for execution and when to keep it waiting.
Memory management information:- PCB consists of the addresses of first and last registers involved in any process.
Accounting information:- Collects data like time taken to run, memory used by the process, etc.
I/O status

Threads

In a process, there are several kinds of different small processes(not to be confused with child processes) running simultaneously which are known as threads. For example, a word editing program can take input from the keyboard and run spellchecker simultaneously. These are 2 threads in a single process.

Process scheduling

Process scheduling diagram:

Any incoming program(or job) is first queued in job queue, then it is sent to ready queue when it is ready for execution. Ready queue is basically linked list whose head LL consists of the address of the first PCB(process control block) and tail consists that of the last PCB that are to be sent to CPU for execution.

Once the turn for execution comes, scheduler dispatches it to CPU where it is executed. If the job is computational only, then it will be executed and then the process is terminated but if it requires I/O or it creates child process whose execution has to be completed before the process to be finished, then the process waits for the time being and another process is allocated to the CPU in meantime.

Once the interrupt/I/O/child process finishes its execution, the process is again queued to the ready queue and then it is terminated after it is done processing through CPU.

Scheduler

There are two kinds of schedulers: job scheduler/ long term scheduler and CPU scheduler/ short term scheduler.

Job scheduler schedules how a job is allocated to the ready queue to be executed. Its work comes only when the ready queue has space or an existing process completes execution and its terminated, thus it has comparatively more time for its work, thus its name, long term scheduler.

CPU scheduler tends to be faster as it has to dispatch the program from the ready queue to the CPU for execution. Its work comes relatively faster as the program execution (or part of it) takes lesser time, thus its name, short term scheduler.

Most of the processes can be divided into two categories namely I/O bound and CPU bound. I/O bound processes require less of computational work and more of input from outside whereas the CPU bound tends to be purely computational.

Schedulers collectively have to do the job of sending a mix of both the programs so that the resources are used efficiently. Let's say more of I/O bound processes are sent, then the job queue will be overloaded (as none of the existing programs is finished executing as they are waiting for I/O). On the other hand, let's say more of CPU bound processes are dispatched, then the I/O queue will be empty resulting in resource wastage.

There is also one more category of schedulers which is nowadays used in many OS namely medium term scheduler. The OS using this kind of scheduler sends the processes directly to the ready queue. Medium term scheduler comes into the act when there occurs an interrupt. During that, medium term scheduler swaps the process in execution with the interrupt and successfully dispatches it when the interrupt is over.

Context switch

Context switch is primarily what the medium scheduler does. When an interrupt occurs, the current state(or context) of the process is saved (known as state save or context save) and once the interrupt is over, the state is restored(state restore).

Operation on processes

Process creation

A process can create a child process which in turn can create another child process of its own. A tree is used to maintain the link between them. Every process created is identified by an ID known as Process ID(pid).

2 types of process execution:

Parent and child are concurrently executed.
Parent waits for the child process to finish execution.

2 types of address space used:

Child process is duplicate of the parent using the same resources.
Child process act as a new program using its own resources.

Process termination

A process is terminated when its execution is finished or any other process forces it to terminate.

In some programs, termination of the parent process causes all its child processes to terminate. This is known as cascading termination.

Once the child process is terminated, it has to wait for the process to call it through wait() statement. Till then the child process is called zombie process. And in case, if the parent is terminated and the child is not, then the child process is known as orphan process. In Linux and Unix, orphans are then attached to the next process and then terminated.

Interprocess communication(IPC)

There are two types of processes vis-a-vis communication. Independent processes which do not require communication and cooperating processes which require communication.

Communication can be done through 2 ways(or models):

Shared memory model
Message passing model

Shared memory model

To illustrate this model, let's have a simple problem of producer-consumer model where the producer produces information to be consumed by the consumer. Here, both the processes to run concurrently, there have to have a buffer of items in shared memory which can be filled by producer and emptied by the consumer.

Two types of buffer can be used for the aforementioned process. THe unbounded buffer places no practical limit on the size of buffer. The consumer may have to wait for new items, but the producer can always produce new items. The bounded buffer assumes a fixed buffer size. In this case, the consumer must wait if the buffer is empty and the producer must wait if the buffer is full.

Message passing model

There should exist a communication link in order to pass the message between two processes. Issues related to these are:

Naming

Processes that want to communicate must have a way to refer to each other. They can use either direct or indirect communication.

Under direct communication, each process that wants to communicate must explicitly name the recipient or sender of the message. It can be defined as:

send(P, message) - Send a message to process P.
receive(Q, message) - Receive a message from process Q.

There is sense of symmetry in this scheme as both the processes know the name of other process. There is an asymmetrical variation of this, in which sender names the recipient but recipient doesn't need to get the name of sender. It can be illustrated as:

send(P, message) - Send a message to process P
receive(id, message) - Receive a message from any process. The variable id is set to the name of the process with which communication has taken place.

Under indirect communication, the messages are sent to a mailbox or port from where the recipient of the message can get it. It can be illustrated as:

send (A, message) - Send a message to mailbox A.
receive (A, message) - Receive a message from mailbox A.

So, here it's clear that for two processes to communicate, there should be a shared mailbox. Also, unlike the last one, where only two processes can communicate through direct communication, here more than two processes can communicate by different processes receiving the same message from the mailbox.

Now, let's say Processes P, Q, R all share the same mailbox where P sends and Q, R receives. Then which process will receive the message sent by P and how to avoid the conflict?. It can be decided by the following methods:-

Allow a link to be associated with two processes at most.
Allow at most one process at a time to execute a receive() operation.
Select a random process (from Q and R, but not both) and then select the remaining processes in round robin fashion.

Synchronisation

Message passing maybe either blocking or nonblocking - also known as synchronous and asynchronous

Blocking send - The sending process is blocked until the message is received by the process or mailbox.
Nonblocking send - The sending process sends the message and resumes the operation.
Blocking receive - The receiver blocks until a message is available.
Nonblocking receive - The receiver retrieves either a valid message or a null.

A combination of send and receive calls can be used.

Buffering

Whether communication is direct or indirect, messages exchanged by processes reside in a temporary queue. Such queues can be implemented in 3 ways.

Zero capacity - The queue has max length of zero, so no message can wait, so sender must block until the message is received.
Bounded capacity - The queue has max length of n, so sender will block only when the n messages have filled the queue.
Unbounded capacity - The sender never blocks.

Communication in client-server system

Apart from the above IPCs, three other models can be used for the client-server system: sockets, remote procedure calls(RPC), pipes

Sockets

Sockets are the endpoint of communication. A pair of processes needs a pair of sockets. Sockets are defined as IP address followed by port number. For example, 162.0.0.1:80 means the machine has IP address of 162.0.0.1 and listening to port 80.

Servers implementing specified series (like FTP, HTTP) listen to well known ports( FTP to port 21, HTTP to port 80). All ports numbered less than 1024 are well known ports. Sockets allow only unstructured stream of bytes to be exchanged. Thus it is called lower level of communication. Structuring responsibility lies with the client or server application.

Remote Procedure Calls(RPC)

RPC is loosely based on message sharing model as a message containing all the information (such as listening port address, parameters for the function etc) is sent to the system with listening port. The message is received and if there is any output to be returned, is done in the same manner.

One issue that needs to be dealt with is the differences in data representation on the client and server machines. Consider the representation of 32-bit integers/ Some systems( knows as big-endian) store the most significant byte first, while other systems(known as little-endian) store the least significant byte first. To resolve the differences, many RPC systems define a machine-independent representation of data. One such representation is known as external data representation (XDR). On client or server side, this XDR data can be converted to machine relevant data.

Another issue that can concern is, how the client and server know the port of each other as they don't share a memory? There are two approaches for this:

The information is predetermined i.e. everytime same port is used. But, in this, after compilation, the port can't be changed.
The port information can be obtained dynamically by sending a request for the same and then getting it from other side.

Pipes

Pipes act as a conduit allowing the processes to communicate with each other.
There can be following issues while implementing a pipe:

Bidirectional or unidirectional depending on if the message flow is allowd from both sides or not.
If two way communication is allowed, it is half duplex(the message is allowed to travel only one way at a time) or full duplex(both ways allowed).?
Is there mus relation between parent and child processes?
Can the pipes communicate over a network or on the same machine.

2 pipes are discussed here:

Ordinary pipes

Also known as anonymous pipes on Windows. This pipe is unidirectional and employ a must parent child relationship. This means this kind of pipe used for communication on same machine. Once the communication is over, this pipe ceases to exist.

Named pipes

These are bidirectional pipes and they can employ communication between any two processes( unlike ordinary pipes which employ communication between parent and child processes only). The pipe still exists after a particular communication is over and can be used by other processes after that.

Hope that the basic concept of processes become clear after this.

Basic Operating System services and structures.

Hrishikesh kumar — Mon, 27 May 2019 07:52:32 +0000

Operating System(OS) provides an interface to the user in order to communicate with the hardware.

OS has mainly three functions:-

To provide services
System calls
User Interface

Services

Services like file maintenance, I/O, resource allocation, communication etc. These services are done with the help of system calls.

System calls

System calls provide an interface for the services provided by the OS. Few of the system calls are:

Process control - Any program loaded into memory and ready for execution is known as process. OS provides control on these processes like reading inputs, error detection etc.
File manipulation - Reading, writing, deleting file etc.
Device manipulation - Reading from devices, Setting appropriate parameters in the memory to write to devices etc.
Information manipulation - Transferring information between user program and OS such as time() , date() etc.
Communication - Setting up communication protocol for passing of data between devices. This can be done in 2 ways : message passing model and shared memory model. In the former model the message is passed between devices using hostid() and clientid. In the latter model, data is placed in shared memory. Message sharing model is mainly used for smaller amount of data as it takes more time to communicate than the shared memory model as in the latter model the data is shared at the speed of memory transfer.
Protection & security - Protecting system from malicious softwares, errors etc.

User and OS interface

User Interface are basically of 3 types: command line UI(eg. UNIX), Batch, GUI(eg. Windows)

OS interface consists of the programs which are used to read the user command and act accordingly. This is done through command interpreter. There are 2 methods through which command interpreter can work:

The command interpreter itself contains the code and sets the parameter accordingly. Eg:- A command to delete a file may cause the command interpreter to jump to a section of its own code that sets up parameter for deleting and then make appropriate system calls.
Command interpreter uses the system calls to get any work done. Eg:- Lets say a command rm file.txt is given. The interpreter doesn't understand the code in any way. It will search for the file named rm and load the file into memory, and execute it with the parameter file.txt.

OS structure

1.Simple structure - DOS has this type of structure.

Structure of DOS:

In DOS, user application may bypass the OS and write into ROM itself which is more prone to errors.

2.Layered approach - The OS services are modeled into layers with hardware as the lowest layer and user interface as the topmost layer.

Layered structure:

Here, one thing is to note that the top layer can communicate with lower layers only. So, layer planning has to be done properly. Also, debugging is more easy in this structure as debugging is done layer by layer and the exact location of problem can be ascertained.

3.Microkernel - Kernel is made smaller to make the OS fast to reboot and avoid conflicts. Microkernel is written on ROM so that it cant be modified. Only the most important system services and calls are embedded into the microkernel and the rest of the system calls are written and loaded onto the disk.

4.Modules - In the microkernel approach, there is drawback of system calls being present in the disk which is more volatile as user application are also present there and thus prone to be modified and susceptible to fatal error. To get around this, system calls are written onto disk and in form of modules. These modules when needed are loaded with the kernel which is written in EPROM(Erasable programmable ROM) instead of ROM so that it can be modified when necessary.

OS debugging

Whenever an error is encountered, OS writes error information into a log file which can be later used to debug. OS can also take a core dump - a capture of the memory of the process- and store into a file for later analysis. A failure in kernel is called crash. When crash occurs, error information is saved to a log file, and the memory state is saved to a crash dump.

Performance tuning also forms a part of debugging which is done through many tools such as Windows task manager, DTrace etc.

System boot

The process of starting a computer by loading the kernel is knows as booting the system. On most computer, a small piece of code known as the bootstrap loader locates the kernel, loads it into the memory, and starts its execution.
At this point the system is said to be running.

DEV Community: Hrishikesh kumar

Multi-threading in Operating System

What is a thread?

Why do we need multi threading?

What are the challenges of multi threading?

Parallelism

Parallelism vs Concurrency

Multi-threading models

Thread Library

Thread creation

Pthreads

Windows threads

Java threads

Thread Pool

Open MP

Threading issues

fork() and exec() system calls.

Signal handling

Thread cancellation

Thread local Storage

Scheduler activation

JVM architecture in a nutshell

Class Loader Subsystem

Run-time Data Areas

Execution Engine

Processes in Operating System

Basic Operating System services and structures.

Hrishikesh kumar ・ May 27 '19

Process concept

Process scheduling

Operation on processes

Interprocess communication(IPC)

Communication in client-server system

Basic Operating System services and structures.

Services

System calls

User and OS interface

OS structure

OS debugging

System boot

`fork()` and `exec()` system calls.