What is the difference between lightweight process and thread?

Question

I found an answer to the question here. But I don\'t understand some ideas in the answer. For instance, lightweight process is said to share its logical address space with other

Answer 1

From MSDN, Threads and Processes:

Processes exist in the operating system and correspond to what users see as programs or applications. A thread, on the other hand, exists within a process. For this reason, threads are sometimes referred to as light-weight processes. Each process consists of one or more threads.

Answer 2

A process contains one or more threads in it and a thread can do anything a process can do. Also threads within a process share the same address space because of which cost of communication between threads is low as it is using the same code section, data section and OS resources, so these all features of thread makes it a "lightweight process".

Answer 3

Based on Tanenbaum's book "Distributes Systems", light weight processes is generally referred to a hybrid form of user-level thread and kernel-level thread. An LWP runs in the context of a single process, and there can be several LWPs per process. In addition each LWP can be running its own (user-level) thread. Multi-threaded applications are constructed by creating threads (with thread library package), and subsequently assigning each thread to an LWP.

The biggest advantage of using this hybrid approach is that creating, destroying, and synchronizing threads is relatively cheap and do not need any kernel intervention. Beside that, provided that a process has enough LWPs, a blocking system call will not suspend the entire process.

Answer 4

Threads run within processes.

Each process may contain one or more threads.

If kernel doesn't know anything about the threads running in the process, we have threads running on user space and thus no multiprocessing capabilities are available.

On the other hand, we can have threads running on the kernel space; this means that each process runs on a different CPU. This enables us multiprocessing, but as you may assume it is more expensive in terms of operating system resources.

Finally, there is a solution that lies somewhere in the middle; we group threads together into LWP. Each group runs on different CPU, but the threads in the group cannot be multi processed. That's because kernel in this version knows only about the groups (which are multiprocessed) but nothing about the threads that they contain. Hope it is clear enough.

Answer 5

IMO, LWP is a kernel thread binding which can be created and executed in the user context.

If I'm not mistaken, you can attach user threads to a single LWP to potentially increase the level of concurrency without involving a system call.

Answer 6

Thread is basically task assigned with one goal and enough information to perform a specific task . A process can create multiple threads for doing its work as fast as possible. e.g A portion of program may need input output, a portion may need permissions.

User level thread are those that can be handled by thread library.

On the other hand kernel level thread (which needs to deal with hadrware)are also called LWP(light weight process) to maximize the use of system and so the system does not halt upon just one system call.