Lecture 3 Distributed

Middleware

Middleware

A layer of software between applications and the operating system that enables communication and connectivity in a distributed system.

Network Operating System (NOS)

An operating system that allows communication based on files and provides network transparency.

Distributed Operating System (DOS)

An operating system that allowscommunication based on messages andshared memory.

Autonomy

The degree of independence or self-governance of a machine or system.

Fault tolerance

The ability of a system to continue functioning properly in the presence of faults or errors.

Multitasking

The ability of an operating system to run multiple applications simultaneously.

Multithreading

The ability of an application to perform multiple operations at the same time.

Concurrency

The ability of multiple processes or threads to run concurrently.

Thread

A sequence of instructions that runs concurrently with other threads in a program.

Threaded application

An application that uses multiple threads to perform tasks concurrently.

Thread manager

A component of the operating system that manages the creation and execution ofthreads.

Memory manager

A component of the operating system that manages the allocation and deallocation of memory.

Synchronization

The coordination of multiple threads to ensure proper execution and avoid conflicts.

Inter-Thread Communication

The exchange of data or messages between threads.

Extending Thread class

A method of creating a thread by extending the Thread class and overriding the run()method.

Implementing Runnable interface

A method of creating a thread by implementing the Runnable interface and overriding the run() method.

Life Cycle of Thread

The different states and transitions a thread goes through during its execution.

Dispatch

The process of selecting a thread to run by the operating system.

Class

A blueprint or template for creating objects in object-oriented programming.

Run

The method in a thread class that contains the code to be executed when the thread is started.

Start

The method used to start a thread's execution.

FCFS policy

First-Come-First-Serve policy, where threads are served in the order they arrive.

Synchronized

A keyword in Java used to control access to shared resources by allowing only one thread to execute a synchronized method at a time.

Shared Resources

Resources that are accessed by multiple threads and need to be coordinated to prevent inconsistent states.

Inconsistent State

A state where the data accessed by multiple threads is not synchronized, leading to incorrect or unpredictable results.

Worker Pool

An architecture for multithreaded servers where a fixed pool of worker threads is created to process requests.

Thread-per-request

An architecture where a new thread is allocated for each incoming request and disposed of after the request is complete.

Thread-per-connection

An architecture where a thread is allocated for each client TCP connection and used for all requests arriving over that connection.

Alternative server threading architectures

Different approaches to managing threads in a server to handle multiple requests concurrently.

Thread-Per-Server-Object

An architecture where each object in the server has its own thread of execution, allowing multiple requests to be processed concurrently as long as they are using different objects.

Thread churn

The creation and destruction of threads, which can lead to inefficiencies in server performance.

Concurrency issues

Challenges that arise when multiple threads are accessing and manipulating shared resources simultaneously.

Locking strategy

A method used to control access to shared resources by allowing only one thread to access the resource at a time.

Deadlock

A situation where two or more threads are blocked indefinitely, waiting for each other to release a resource.

Worker pool

An architecture where a fixed number of threads are created and shared among multiple requests, improving efficiency by reusing threads.

Thread-per-request

An architecture where each request is assigned its own thread, allowing for parallel processing of requests.

Thread-per-connection

An architecture where each TCP connection is assigned its own thread, allowing for parallel processing of requests within the same connection.

Threads synchronization

The process of coordinating the access and manipulation of shared resources by multiple threads to avoid conflicts and ensure data consistency.

Separating mechanisms from policies

A design principle in operating systems that allows for flexibility by separating the implementation details (mechanisms) from the decision-making rules (policies).