21_Thread Implementation

# Thread Implementation

Threads are basic units of CPU utilization. In modern operating systems, process creation is costly while thread creation is relatively inexpensive. There are two main types of thread implementations:

1. **User-Level Threads**
2. **Kernel-Level Threads**

## User-Level Threads

In user-level threads, all thread management is done by the application. The kernel is not aware of the existence of these threads and manages them as if they were single-threaded processes.

```c++
#include <iostream>
#include <thread>

void thread_function() {
    std::cout << "This is a user-level thread." << std::endl;
}

int main() {
    std::thread t(&thread_function);
    t.join();
    return 0;
}
```

In the above example, a simple user-level thread is created in C++ that outputs a message.

## Kernel-Level Threads

In contrast, kernel-level threads are managed directly by the operating system. The kernel has full knowledge of all threads and schedules them on the available CPU cores.

```c++
#include <pthread.h>
#include <stdio.h>

void *print_message(void*) {
    printf("This is a kernel-level thread.\n");
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, &print_message, NULL);
    pthread_join(thread, NULL);
    return 0;
}
```
In the above example, a kernel-level thread is created using the Pthreads library in C. The kernel schedules this thread alongside other threads in the system.

These two thread types have their own advantages and disadvantages. User-level threads are fast to create and manage but cannot utilize multiprocessing. Kernel threads, on the other hand, can be scheduled on multiple processors but have more overhead due to context switches in the kernel.