JudahSan · June 28, 2024 15:47
diff --git a/README.md b/README.md
diff --git a/main-processes.c b/main-processes.c
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/wait.h>
 #include <sys/types.h>

 int main(int argc, char* argv[]) {
  int x = 5;
  int pid = fork();
  if (pid == -1) {
    return 1;
  }
  
  if (pid == 0) {
    x++;
  }
  
  sleep(2);
  printf("Value of x: %d\n", getpid());
  if (pid != 0) {
  wait(NULL);
  }
  return 0  
 }
diff --git a/main-threads.c b/main-threads.c
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>

 int x = 3;

 void* routine() {
  x++;
  sleep(2);
  printf("Value of x: %d\n", getpid());
 }

 void routine2() {
  sleep(2); 
  printf("Process ID %d\n", getpid());
 }

 int main(int argc, char* argv[]) {
  pthread_t t1, t2;
  if (pthread_create(&t1, NULL, &routine, NULL) !=0) {
    return 1;
  }
  if (pthread_create(&t2, NULL, &routinee, NULL) !=0) {
    return 2;
  }
  if (ppthread_join(t1, NULL) !=0) {
    return 3;
  }
  if (pthread_join(t2, NULL) !=0) {
    return 4;
  }
  return 0;
 }
diff --git a/main.c b/main.c
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <pthread.h>

 void* routine() {
  printf("Test from threads\n");
  sleep(3);
  printf("Ending thread\n");
 }

 int main(int argc, char* argv[]) {
  pthread_t t1, t2;
  if (pthread_create(&t1, NULL, &routine, NULL) !=0) {
    return 1;
  }
  if (pthread_create(&t2, NULL, &routine, NULL) !=0) {
    return 2;
  }
  if (ppthread_join(t1, NULL) !=0) {
    return 3;
  }
  if (pthread_join(t2, NULL) !=0) {
    return 4;
  }
  return 0;
 }
Comparison Basis	Process	Thread
Definition	A process is a program under execution i.e. an active program.	A thread is a lightweight process that can be managed independently by a scheduler
Context switching time	Processes require more time for context switching as they are heavier.	Threads require less time for context switching as they are lighter than processes.
Memory Sharing	Processes are totally independent and don’t share memory.	A thread may share some memory with its peer threads.
Communication	Communication between processes requires more time than between threads.	Communication between threads requires less time than between processes.
Blocked	If a process gets blocked, remaining processes can continue execution.	If a user level thread gets blocked, all of its peer threads also get blocked.
Resource Consumption	Processes require more resources than threads.	Threads generally need less resources than processes.
Dependency	Individual processes are independent of each other.	Threads are parts of a process and so are dependent.
Data and Code sharing	Processes have independent data and code segments.	A thread shares the data segment, code segment, files etc. with its peer threads.
Treatment by OS	All the different processes are treated separately by the operating system.	All user level peer threads are treated as a single task by the operating system.
Time for creation	Processes require more time for creation.	Threads require less time for creation.
Time for termination	Processes require more time for termination.	Threads require less time for termination.
	#include <stdlib.h>
	#include <stdio.h>
	#include <unistd.h>
	#include <sys/wait.h>
	#include <sys/types.h>

	int main(int argc, char* argv[]) {
	int x = 5;
	int pid = fork();
	if (pid == -1) {
	return 1;
	}

	if (pid == 0) {
	x++;
	}

	sleep(2);
	printf("Value of x: %d\n", getpid());
	if (pid != 0) {
	wait(NULL);
	}
	return 0
	}