In concurrent programming, a critical section is a piece of code that accesses a shared resource (data structure or device) that must not be concurrently accessed by more than one thread of execution. A critical section will usually terminate in fixed time, and a thread, task, or process will have to wait a fixed time to enter it (aka bounded waiting). Some synchronization mechanism is required at the entry and exit of the critical section to ensure exclusive use, for example a semaphore.
By carefully controlling which variables are modified inside and outside the critical section, concurrent access to that state is prevented. A critical section is typically used when a multithreaded program must update multiple related variables without a separate thread making conflicting changes to that data. In a related situation, a critical section may be used to ensure a shared resource, for example a printer, can only be accessed by one process at a time.
How critical sections are implemented varies among operating systems.
The simplest method is to prevent any change of processor control inside the critical section. On uni-processor systems, this can be done by disabling interrupts on entry into the critical section, avoiding system calls that can cause a context switch while inside the section, and restoring interrupts to their previous state on exit. Any thread of execution entering any critical section anywhere in the system will, with this implementation, prevent any other thread, including an interrupt, from being granted processing time on the CPU - and therefore from entering any other critical section or, indeed, any code whatsoever - until the original thread leaves its critical section.
This brute-force approach can be improved upon by using semaphores. To enter a critical section, a thread must obtain a semaphore, which it releases on leaving the section. Other threads are prevented from entering the critical section at the same time as the original thread, but are free to gain control of the CPU and execute other code, including other critical sections that are protected by different semaphores.
Some confusion exists in literature about the relationship between different critical sections in the same program. Clearly, a resource that must be protected from concurrent access must be accessible by several entry points in the code. If the resource were only accessible through a single entry point, then multithreaded processing would not be a necessary consideration. Each resource must be guarded by a common, "global" semaphore. Is each piece now a critical section, or are all the pieces guarded by the same semaphore in aggregate a single critical section? This confusion is evident in definitions of a critical section such as "... a piece of code that can only be executed by one process or thread at a time".
Read more about Critical Section: Application Level Critical Sections, Kernel Level Critical Sections
Famous quotes containing the words critical and/or section:
“His misfortune was that he loved youth—he was weak to it, it kindled him. If there was one eager eye, one doubting, critical mind, one lively curiosity in a whole lecture-room full of commonplace boys and girls, he was its servant. That ardour could command him. It hadn’t worn out with years, this responsiveness, any more than the magnetic currents wear out; it had nothing to do with Time.”
—Willa Cather (1873–1947)
“Socialite women meet socialite men and mate and breed socialite children so that we can fund small opera companies and ballet troupes because there is no government subsidy.”
—Sugar Rautbord, U.S. socialite fund-raiser and self-described “trash” novelist. As quoted in The Great Divide, book 2, section 7, by Studs Terkel (1988)