| CSC 302- Principles of Operating Systems | Assignment on Multithreading | | | Stephen Nyabuti – 12S01ABT023 |

Feb 2013 |

1. How multithreading works in a server
Multithreading occurs when a process executing an application, is divided into threads that can run concurrently. Multithreading is useful for applications that perform a number of essentially independent tasks that do not need to be serialized.
When a multithreaded application is active in a server, the events that occur take place in three phases: i. Start-up phase- requests come in and are handed to a thread for processing. ii. Work phase- in this phase multiple client requests are handled concurrently in multiple contexts. The system allocates a separate thread for each request. In response to clients’ requests for a service, the server dispatcher creates multiple threads in one server that can be assigned to various client requests simultaneously. Each thread is associated with a separate context or request to the server. This feature is useful in both conversational and RPC servers which otherwise may stay idle waiting for the client side of a conversation. iii. Completion phase- When the application is shut down or stopped, the server performs any termination processing that is necessary such as closing a resource manager.

2. Advantages and Disadvantages of implementing multithreading
As user space threads * Switching threads is faster when thread management is done in user space. * Fast thread switching. * Fast thread scheduling. * A multithreaded program operates faster on computer systems that have multiple CPU’s with multiple cores. * A multithreaded application remains responsive to input. This makes it possible for the application to remain responsive to user input while executing tasks. * Superior application responsiveness. If a request can be shown on its own thread applications do not freeze. Another application will not wait pending the completion of another request. * They use a cooperative approach to sharing the CPU which is a drawback. * Blocking system calls are problematic since one blocked thread will block all threads. * In cooperative multithreading the thread themselves are relied to relinquish control once they stop. This creates problems when threads are waiting for resources to become available. * In preemptive multithreading, a system may make a context switch at an inappropriate time causing priority inversion or other negative effects.
As Kernel space threads * No runtime system in each process * The Kernel can easily reschedule threads when they block. * Improved throughput - many concurrent computed operations and I/O requests within a single process. * Simultaneous and fully symmetric use of multiple processors for computation and I/O. * Improved server responsiveness. Large or complex requests or slow clients do not block other requests for service. The overall throughput of the server is much better. * Minimized system resource usage. Threads impose minimal impact on system resources. They require less overhead to create manage and maintain compared to a traditional process. * Thread synchronization functions can be used to provide enhanced process- to - process communication. * The system may make a context switch at an inappropriate time causing priority inversion or other negative effects. This is a drawback. * Another disadvantage in kernel space multithreading is slower thread switching compared to user space threads. * Thread scheduling is also slower than in user space threads. * They get blocked if all of their associated kernel threads get blocked even if there are some user threads that are ready to run.

3. Challenges brought about by multithreading and how they can be overcome.
Thread share data structures and this may bring about challenges when one thread closes a file while another one is still reading from it, or double memory allocation when one thread starts allocating itself more memory and in the process of execution, another thread also notices that there is little memory and also allocates memory. This problem is solved by thread synchronization.
Parent and Child processes in multithreading also face some problems. For example, when a parent process has multiple threads, the child process also has the same for the process to function properly. This creates a challenge for instance when a thread in the parent process is blocked. It will result in the two processes being blocked. To resolve this problem, threads of the parent processes are implemented separate from those of the child processes.
Deadlock is another challenge brought about by multithreading. A Deadlock occurs when each thread is waiting for the other to do something. This problem is solved by the Component Object Model (COM). The COM call control helps in preventing deadlocks.
Multithreading may lead to race condition. This is when one thread finishes before another on which it depends, causing the former to use an unutilized value since the latter has not supplied one. COM supplies some functions specifically designed to help avoid race conditions.

REFERENCES
Multithreading. Retrieved February 19, 2013, from http://www.webopedia.com/TERM/M/ multithreading.html
Stalling, W. (2008). Operating Systems. 6th Edition.
Randon James.(1998) Software and hardware management (4th ed.) U.S.A; McGraw Hill.
Kernel Space. Retrieved February 20, 2013, from www.linfo.org/kernel_space.html
Multithreading Problems. Retrieved February 20,2013, from http://www.roguewave.com/portals/0/products/threadspotter/docs/2011.2/manual_html_linux/manual_html/multithreading_problems.html