Threads vs. Processes:
- A process is an independent execution unit with its own memory space, system resources, and a unique process ID (PID).
- A thread is a smaller unit of execution within a process. Multiple threads within the same process share the same memory space and system resources but have their own thread ID (TID).
Shared Process ID:
- All threads created within a single process share the same process ID because they belong to the same process. Threads don’t create new processes; they work within the boundaries of the parent process.
Table of Content
Table of Contents
Threads, Multi-Threading and Locks
Multithreading: Efficient Program Execution
- Allows multiple threads (small units of a process) to run within a single program
- Enables simultaneous task execution, improving efficiency
- Useful for handling multiple users or requests without running multiple copies of the program
- Threads share memory and data but maintain individual identities
Locks in Multithreading
- Purpose: Control access to shared resources (memory or data)
- Prevent errors caused by multiple threads accessing the same data simultaneously
- Basic concept:
- Lock before accessing shared data
- Unlock after accessing the data
- Other threads wait if a lock is already held
Basic Example of Multi-Threading
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
// Global variable that is shared among threads
int g = 0;
// Thread function that will be executed by all threads
void* myThreadFun(void* vargp)
{
// Get the thread's process ID
int myid = getpid();
// Static variable shared among all threads
static int s = 0;
// Increment the static and global variables
++s;
++g;
// Print the thread's ID and the current values of static and global variables
printf("Process ID: %d, Static: %d, Global: %d\n", myid, ++s, ++g);
}
int main()
{
int i;
pthread_t tid;
// Create three threads that execute myThreadFun
for (i = 0; i < 3; i++)
pthread_create(&tid, NULL, myThreadFun, NULL);
// Wait for all threads to finish
pthread_exit(NULL);
return 0;
}
How it Works:
Global Variable (
g):gis a global variable that is shared by all threads. When any thread increments it, the updated value is visible to other threads.
Static Variable (
s):sis a static variable inside themyThreadFunfunction. This means it is shared among all threads, but its scope is limited to the function. Since it’s static, its value persists between function calls. Each thread incrementss, and the changes are reflected in every subsequent thread that accesses it.
Thread Creation:
- The program creates 3 threads using the
pthread_create()function. Each thread runs themyThreadFun()function. - The
pthread_exit()inmain()ensures that the program doesn’t exit before all threads have finished execution.
- The program creates 3 threads using the
Thread Execution:
- Each thread prints the process ID (obtained using
getpid()), the incremented values of the static variables, and the global variableg. Even though the function is executed separately by each thread, the static and global variables are shared.
- Each thread prints the process ID (obtained using
Threaded Counter with Mutex Lock
Here’s an example where a mutex is used to protect shared data:
#include <pthread.h>
#include <stdio.h>
int counter = 0;
pthread_mutex_t lock;
void* thread_func(void* arg) {
pthread_mutex_lock(&lock);
counter++;
printf("Counter: %d\n", counter);
pthread_mutex_unlock(&lock);
return NULL;
}
int main() {
pthread_t t1, t2;
pthread_mutex_init(&lock, NULL);
pthread_create(&t1, NULL, thread_func, NULL);
pthread_create(&t2, NULL, thread_func, NULL);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
pthread_mutex_destroy(&lock);
return 0;
}
Explanation:
counter: A shared variable that both threads will modify. Since multiple threads are accessing and modifying it, we need to protect it using a mutex.pthread_mutex_t lock: A mutex (short for mutual exclusion) used to prevent concurrent access to thecountervariable. This ensures that only one thread can modifycounterat a time, avoiding race conditions.
void* thread_func(void* arg): This is the function that each thread will execute. In this case, it takes one argument (arg), which is not used here (passed asNULLwhen calling the function).pthread_mutex_lock(&lock): The thread acquires the mutex lock before modifying the sharedcounter. This ensures that only one thread can increment the counter at a time.counter++: The sharedcountervariable is incremented.printf("Counter: %d\n", counter): The current value ofcounteris printed.pthread_mutex_unlock(&lock): After modifying thecounter, the thread releases the mutex lock, allowing other threads to acquire the lock and access the shared variable.return NULL: Sincevoid*is the return type, the function returnsNULL(no data is returned by this function).
pthread_t t1, t2: These are thread identifiers for two threadst1andt2.pthread_mutex_init(&lock, NULL): Initializes the mutexlock. The second parameter is optional and can be set toNULLfor default mutex behavior.pthread_create(&t1, NULL, thread_func, NULL): This function creates a new threadt1, which will start executing thethread_funcfunction.pthread_create(&t2, NULL, thread_func, NULL): Similarly, this creates a second threadt2to executethread_func.pthread_join(t1, NULL): Thepthread_joinfunction waits for threadt1to finish executing. This ensures that the main thread does not exit beforet1has completed its task.pthread_mutex_destroy(&lock): After all threads are done, the mutexlockis destroyed to release any resources allocated for the mutex.
Output:
Counter: 1
Counter: 2
Practice Question:
Q) Summing an Array Using Multiple Threads
Write a program that sums the elements of an array using multiple threads. Divide the array into equal parts, and assign each part to a separate thread. Each thread will sum the elements of its portion, and the main thread will collect and sum the results from each thread.
- Use a mutex lock to ensure that only one thread at a time updates the global sum.
- Example: If the array is
{1, 2, 3, 4, 5, 6}, and you divide it between two threads, one thread will sum{1, 2, 3}and the other will sum{4, 5, 6}. Both results should be combined in the main thread to get the final sum.
