fork() is used to create new processes. These new processes are called as child processes and each child process initially shares all the segments like text, stack, heap etc until child tries to make any change to stack or heap. In case of any change, a seperate copy of stack and heap segments are prepared for child so that changes remain child specific. The text segment is read-only so both parent and child share the same text segment.
Linux Threads vs Light Weight Processes
Threads in Linux are nothing but a flow of execution of the process. A process containing multiple execution flows is known as multi-thread process.
For a non multi-threaded process there is only one execution flow that is the main execution flow and hence it is also known as single threaded process. For Linux kernel, there is no concept of thread. Each thread is viewed by the kernel as a seperate process but these processes are somewhat different from other normal processes.
Threads are often mixed with the term Light Weight Processes or LWPs. The reason dates back to those times when Linux supported threads at user level only. This means that even a multi-threaded application was viewed by kernel as a single process only. this posed big challenges for the library that managed these user level threads because it had to take care of that a thread execution did not hinder if any other thread issued a blocking call.
Later on the implementation changed and processes were attatched to each thread so that kernel can take care of them. But, as discussed earlier, Linux kernel does not see them as threads, each thread is viewed as a process inside kernel. These processes are known as light wight processes.
The main difference between a light weight process(LWP) and a normal process is that LWPs share same address space and other resources like open files etc. As some resources are shared so these processes are considered to be light weight as compared to other normal processes and hence the name light weight processes.
So, effectively we can say that threads and light weight processes are same. It’s just that thread is a term that is used at user level while light weight process is a term used at kernel level.
From implementation point of view, threads are created using functions exposed by POSIX compliant pthread library in Linux. Internally, the
clone() function is used to create a normal as well as a light weight process. This means that to create a normal process
fork() is used that further calls
clone() with appropriate arguments while to create a thread or LWP, a function from pthread library calls
clone() with relvant flags. So, the main difference is generated by using different flags that can be passed to
clone() funciton(to be exact, it is a system call).
Read more about
clone() on their respective man pages.