Windows Thread Object Attributes

Thread Functionality

• A thread is a core component of CPU utilization
• Common elements include thread ID, program counter, registers, and stack.
• Threads in a process share code, data, and OS resources.
• A traditional process uses single thread control
• Multiple threads can execute multiple tasks simultaneously.
• A thread should contain data about its execution state, saved context, per-thread static storage, access to memory/resources, and an execution stack

Windows Thread Object Attributes

• Thread ID: Unique identifier when calling a server.
• Thread Context: Register values and volatile data that define execution state.
• Dynamic Priority: The execution priority at a given moment.
• Base Priority: The lower limit of the dynamic priority.
• Thread Processor Affinity: Set of processors it can run on.
• Thread Execution Time: Cumulative time in user/kernel mode.
• Alert Status: Signifies if a waiting thread can execute an asynchronous procedure call.
• Suspension Count: Number of times execution has been suspended.
• Impersonation Token: Allows executing operations for another process.
• Termination Port: Channel where the process manager sends a termination message.
• Thread Exit Status: Reason for termination.

Thread Relationships

• The object-oriented structure of Windows OS facilitates general-purpose process development which includes threads
• Objects used to represent each process contains specific attributes and actions
• A Windows process needs at least one thread to execute and it may create others
• Thread attributes can be derived from the process attributes
• Context attribute contains processor register values which enable suspension and resumption
• The behavior of threads can be altered in Windows by changing its context while suspended
• Unit of resource ownership is usually a process or task
• Unit of dispatching processes is usually threads or lightweight processes

Thread Arrangement/Relationship Types

• One process: One thread (1:1): Each thread uses a unique process with its own space and resources, like MS-DOS and Classic UNIX.
• Multiple processes: One thread per process (M:1): A thread may move from one process to another, allowing mobility across systems (some UNIX variants).
• One process: Multiple threads (1:M): A process defines an address space and resource ownership, like the Java runtime environment.
• Multiple processes: Multiple threads per processes (M:M): Combines the attributes of M:1 and 1:M arrangements.
• Thread constructs simplify programs with functions on single-processor systems
• Threads enhance process execution in single-user multiprocessing systems.

Thread State & Operations

• Key thread states: Running, Ready, and Blocked.
• Process swap out automatically swaps out all the constituting threads
• Four basic thread operations:
  • Spawn: Occurs when a new process is created.
  • Block: Thread waits for a particular event, saving info for resumption.
  • Unblocked: Moves a blocked thread to the ready queue.
  • Finish: Thread finishes execution, deallocating registers and stacks.

Thread Synchronization & Libraries

• Threads in a process share address space and resources
• Thread synchronization is critical to prevent interference because resource alteration affects all threads
• Thread Library: Allows multithreading via an API for creation, management, messaging, scheduling, saving and restoring context.

Types of Threads

User-Level Threads

• Thread management is managed by the application; the kernel isn't aware of threads
• Advantages:
  • No kernel-mode privileges allowing faster thread switching
  • Scheduling can be application-specific
  • User-level threads can run on any OS without kernel changes.

Kernel-Level Threads

• Thread management is performed by the OS kernel.
• The kernel maintains process context and individual thread
• Advantages:
  • Kernel can schedule multiple threads from the same process on multiple processors.
  • Kernel can schedule another thread if one is blocked.
  • Kernel routines can be multithreaded.

Combined Approach (User-Level and Kernel-Level)

• Combines user-level and kernel-level threads
• Thread creation and synchronization are in user space
• User-level threads maps to kernel-level threads.
• Multiple threads can run in parallel and a blocking system call doesn't block the entire process.

MultiThreading

• Multithreading enables multiple concurrent execution paths within a single process
• Multicore systems and multithreaded applications influence application design and performance
• Multithreading is often used for server applications
• General characteristics:
  • Small memory overhead (stack, registers, thread-local data).
  • Small CPU overhead (API calls)
  • Faster process communication
  • Low crash resilience
  • Monitored memory usage via system allocator.

Examples & Benefits of MultiThreading

• Examples of multithreaded applications:
  • Application to create photo thumbnails
  • Web browsers loading from the internet
  • Word processors that respond to user plus spelling/grammar check
• Benefits:
  • Responsiveness: Allows a program to continue if part is blocked.
  • Resource Sharing: Threads share process memory/resources.
  • Economical: Thread creation needs less time and memory
  • Scalability: Allows threads on multi-processor architecture to run in parallel.
• Windows supports multithreading by enabling threads in different processes to execute concurrently
• Threads within a process exchange information through a shared address space
• Threads in different processes exchange information through shared memory.