concurrency) - university of...
TRANSCRIPT
![Page 1: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/1.jpg)
Concurrency
![Page 2: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/2.jpg)
Mo+va+on
• Opera+ng systems (and applica+on programs) o9en need to be able to handle mul+ple things happening at the same +me – Process execu+on, interrupts, background tasks, system maintenance
• Humans are not very good at keeping track of mul+ple things happening simultaneously
• Threads are an abstrac+on to help bridge this gap
![Page 3: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/3.jpg)
Why Concurrency?
• Servers – Mul+ple connec+ons handled simultaneously
• Parallel programs – To achieve beFer performance
• Programs with user interfaces – To achieve user responsiveness while doing computa+on
• Network and disk bound programs – To hide network/disk latency
![Page 4: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/4.jpg)
Déjà vu?
• Didn’t we learn all about concurrency in CSE 332/333? – More prac+ce
• Realis+c examples, especially in the project
– Design paFerns and piSalls • Methodology for wri+ng correct concurrent code
– Implementa+on • How do threads work at the machine level?
– CPU scheduling • If mul+ple threads to run, which do we do first?
![Page 5: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/5.jpg)
Defini+ons
• A thread is a single execu+on sequence that represents a separately schedulable task – Single execu+on sequence: familiar programming model
– Separately schedulable: OS can run or suspend a thread at any +me
• Protec+on is an orthogonal concept – Can have one or many threads per protec+on domain
![Page 6: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/6.jpg)
Threads in the Kernel and at User-‐Level
• Mul+-‐threaded kernel – mul+ple threads, sharing kernel data structures, capable of using privileged instruc+ons
– OS/161 assignment 1 • Mul+process kernel – Mul+ple single-‐threaded processes – System calls access shared kernel data structures – OS/161 assignment 2
• Mul+-‐threaded user program – mul+ple threads, sharing same data structures, isolated from other user programs
• Mul+ple mul+-‐threaded processes
![Page 7: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/7.jpg)
Thread Abstrac+on • Infinite number of processors • Threads execute with variable speed – Programs must be designed to work with any schedule
Programmer Abstraction Physical Reality
Threads
Processors 1 2 3 4 5 1 2
RunningThreads
Ready Threads
![Page 8: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/8.jpg)
Programmer vs. Processor View
Programmer·s View
.
.
.x = x + 1 ;y = y + x ;z = x + 5 y ;
.
.
.
Possible Execution
#1...
x = x + 1 ;y = y + x ;z = x + 5 y ;
.
.
.
Possible Execution
#2...
x = x + 1 ;. . . . . . . . . . . . . .
Thread is suspended.Other thread(s) run.Thread is resumed.. . . . . . . . . . . . . . .y = y + x ;z = x + 5 y ;
Possible Execution
#3...
x = x + 1 ;y = y + x ;
. . . . . . . . . . . . . . .Thread is suspended.Other thread(s) run.Thread is resumed.. . . . . . . . . . . . . . . .
z = x + 5 y ;
![Page 9: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/9.jpg)
Possible Execu+ons
Thread 1
Thread 2
Thread 3
One Execution Another Execution
Thread 1
Thread 2
Thread 3
Another Execution
Thread 1
Thread 2
Thread 3
![Page 10: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/10.jpg)
Thread Opera+ons
• thread_create(thread, func, args) – Create a new thread to run func(args) – OS/161: thread_fork
• thread_yield() – Relinquish processor voluntarily – OS/161: thread_yield
• thread_join(thread) – In parent, wait for forked thread to exit, then return – OS/161: assignment 1
• thread_exit – Quit thread and clean up, wake up joiner if any – OS/161: thread_exit
![Page 11: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/11.jpg)
Example: threadHello #define NTHREADS 10 thread_t threads[NTHREADS]; main() { for (i = 0; i < NTHREADS; i++) thread_create(&threads[i], &go, i); for (i = 0; i < NTHREADS; i++) { exitValue = thread_join(threads[i]); prinS("Thread %d returned with %ld\n", i, exitValue); } prinS("Main thread done.\n"); } void go (int n) { prinS("Hello from thread %d\n", n); thread_exit(100 + n); // REACHED? }
![Page 12: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/12.jpg)
threadHello: Example Output
• Why must “thread returned” print in order?
• What is maximum # of threads running when thread 5 prints hello?
• Minimum?
![Page 13: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/13.jpg)
Fork/Join Concurrency
• Threads can create children, and wait for their comple+on
• Data only shared before fork/a9er join • Examples: – Web server: fork a new thread for every new connec+on • As long as the threads are completely independent
– Merge sort – Parallel memory copy
![Page 14: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/14.jpg)
bzero with fork/join concurrency void blockzero (unsigned char *p, int length) { int i, j; thread_t threads[NTHREADS]; struct bzeroparams params[NTHREADS];
// For simplicity, assumes length is divisible by NTHREADS. for (i = 0, j = 0; i < NTHREADS; i++, j += length/NTHREADS) { params[i].buffer = p + i * length/NTHREADS; params[i].length = length/NTHREADS; thread_create_p(&(threads[i]), &go, ¶ms[i]); } for (i = 0; i < NTHREADS; i++) { thread_join(threads[i]); } }
![Page 15: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/15.jpg)
Thread Data Structures Thread 1·s
Perï7hread State
Stack
Thread �·sPerï7hread State
SharedState
ThreadMetadata
SavedRegisters
StackInformation
Thread ControlBlock (TCB)
Stack
ThreadMetadata
SavedRegisters
StackInformation
Thread ControlBlock (TCB)
GlobalVariables
Heap
Code
![Page 16: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/16.jpg)
Thread Lifecycle
Thread Creation
s thread_create( )
SchedulerResumes Thread
Thread Exit
s t h r e a d _ e x i t ( )Thread Yield/Scheduler
Suspends Threads t h r e a d _ y i e l d ( )
Thread Waits for Events t h r e a d _ j o i n ( )
Event Occurs0ther Thread Calls
s t h r e a d _ j o i n ( )
Init Ready
Waiting
Running Finished
![Page 17: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/17.jpg)
Implemen+ng Threads: Roadmap
• Kernel threads – Thread abstrac+on only available to kernel – To the kernel, a kernel thread and a single threaded user process look quite similar
• Mul+threaded processes using kernel threads (Linux, MacOS) – Kernel thread opera+ons available via syscall
• User-‐level threads – Thread opera+ons without system calls
![Page 18: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/18.jpg)
Mul+threaded OS Kernel
Kernel
User-Level Processes
Heap
Code
Globals TCB 1
Kernel Thread 1
Stack
TCB 2
Kernel Thread 2
Stack
TCB 3
Kernel Thread 3
Stack Stack Stack
PCB 1
Process 1
PCB 2
Process 2
Heap
Code
Globals
Stack
Process 1Thread
Heap
Code
Globals
Stack
Process 2Thread
![Page 19: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/19.jpg)
Implemen+ng threads
• Thread_fork(func, args) – Allocate thread control block – Allocate stack – Build stack frame for base of stack (stub) – Put func, args on stack – Put thread on ready list – Will run some+me later (maybe right away!)
• stub(func, args): OS/161 mips_threadstart – Call (*func)(args) – If return, call thread_exit()
![Page 20: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/20.jpg)
Thread Stack
• What if a thread puts too many procedures on its stack? – What happens in Java? – What happens in the Linux kernel? – What happens in OS/161?
– What should happen?
![Page 21: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/21.jpg)
Thread Context Switch
• Voluntary – Thread_yield – Thread_join (if child is not done yet)
• Involuntary – Interrupt or excep+on – Some other thread is higher priority
![Page 22: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/22.jpg)
Voluntary thread context switch
• Save registers on old stack • Switch to new stack, new thread • Restore registers from new stack • Return • Exactly the same with kernel threads or user threads – OS/161: thread switch is always between kernel threads, not between user process and kernel thread
![Page 23: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/23.jpg)
OS/161 switchframe_switch /* a0: old thread stack pointer * a1: new thread stack pointer */
/* Allocate stack space for 10 registers. */ addi sp, sp, -‐40
/* Save the registers */ sw ra, 36(sp) sw gp, 32(sp) sw s8, 28(sp) sw s6, 24(sp) sw s5, 20(sp) sw s4, 16(sp) sw s3, 12(sp) sw s2, 8(sp) sw s1, 4(sp) sw s0, 0(sp)
/* Store old stack pointer in old thread */ sw sp, 0(a0)
/* Get new stack pointer from new thread */ lw sp, 0(a1) nop /* delay slot for load */
/* Now, restore the registers */ lw s0, 0(sp) lw s1, 4(sp) lw s2, 8(sp) lw s3, 12(sp) lw s4, 16(sp) lw s5, 20(sp) lw s6, 24(sp) lw s8, 28(sp) lw gp, 32(sp) lw ra, 36(sp) nop /* delay slot for load */
/* and return. */ j ra addi sp, sp, 40 /* in delay slot */
![Page 24: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/24.jpg)
x86 switch_threads (oldT, nextT) # Save caller’s register state # NOTE: %eax, etc. are ephemeral pushl %ebx pushl %ebp pushl %esi pushl %edi
# Get offsetof (struct thread, stack) mov thread_stack_ofs, %edx # Save current stack pointer to old
thread's stack, if any. movl SWITCH_CUR(%esp), %eax movl %esp, (%eax,%edx,1)
# Change stack pointer to new thread's stack
# this also changes currentThread movl SWITCH_NEXT(%esp), %ecx movl (%ecx,%edx,1), %esp
# Restore caller's register state. popl %edi popl %esi popl %ebp popl %ebx ret
![Page 25: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/25.jpg)
A Subtlety
• Thread_create puts new thread on ready list • When it first runs, some thread calls switchframe – Saves old thread state to stack – Restores new thread state from stack
• Set up new thread’s stack as if it had saved its state in switchframe – “returns” to stub at base of stack to run func
![Page 26: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/26.jpg)
Two Threads Call Yield
164 Chapter 4 Concurrency and Threads
Logical View
Thread 1 Thread 2go(){ go(){
while(1){ while(1){thread_yield(); thread_yield();
} }} }
Physical Reality
Thread 1’s instructions Thread 2’s instructions Processor’s instructions“return” from thread_switch “return” from thread_switch
into stub into stubcall go call gocall thread_yield call thread_yieldchoose another thread choose another threadcall thread_switch call thread_switchsave thread 1 state to TCB save thread 1 state to TCBload thread 2 state load thread 2 state
“return” from thread_switch “return” from thread_switchinto stub into stub
call go call gocall thread_yield call thread_yieldchoose another thread choose another threadcall thread_switch call thread_switchsave thread 2 state to TCB save thread 2 state to TCBload thread 1 state load thread 1 state
return from thread_switch return from thread_switchreturn from thread_yield return from thread_yieldcall thread_yield call thread_yieldchoose another thread choose another threadcall thread_switch call thread_switchsave thread 1 state to TCB save thread 1 state to TCBload thread 2 state load thread 2 state
return from thread_switch return from thread_switchreturn from thread_yield return from thread_yieldcall thread_yield call thread_yieldchoose another thread choose another threadcall thread_switch call thread_switchsave thread 2 state to TCB save thread 2 state to TCBload thread 1 state load thread 1 state
return from thread_switch return from thread_switchreturn from thread_yield return from thread_yield... ... ...
Figure 4.15: Interleaving of instructions when two threads loop and call thread_yield().
![Page 27: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/27.jpg)
Involuntary Thread Switch
• Timer or I/O interrupt – Tells OS some other thread should run
• Simple version (OS/161) – End of interrupt handler calls schedule() – When resumed, return from handler resumes kernel thread or user process
• Faster version (Linux) – Interrupt handler returns to saved state in TCB – Could be kernel thread or user process
![Page 28: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/28.jpg)
Mul+threaded User Processes (Take 1)
• User thread = kernel thread (Linux, MacOS) – System calls for thread fork, join, exit (and lock, unlock,…)
– Kernel does context switch – Simple, but a lot of transi+ons between user and kernel mode
![Page 29: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/29.jpg)
Mul+threaded User Processes (Take 1)
Kernel
User-Level Processes
Heap
Code
Globals TCB 1
Kernel Thread 1
Stack
TCB 2
Kernel Thread 2
Stack
TCB 3
Kernel Thread 3
Stack
TCB 1.B
Stack
TCB 1.A
Stack
Process 1
PCB 1
TCB 2.B
Stack
TCB 2.A
Stack
Process 2
PCB 2
Heap
Code
Globals
Stack
Thread A
Stack
Thread BProcess 2
Heap
Code
Globals
Stack
Thread A
Stack
Thread BProcess 1
![Page 30: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/30.jpg)
Mul+threaded User Processes (Take 2)
• Green threads (early Java) – User-‐level library, within a single-‐threaded process – Library does thread context switch – Preemp+on via upcall/UNIX signal on +mer interrupt
– Use mul+ple processes for parallelism • Shared memory region mapped into each process
![Page 31: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/31.jpg)
Mul+threaded User Processes (Take 3)
• Scheduler ac+va+ons (Windows 8) – Kernel allocates processors to user-‐level library – Thread library implements context switch – Thread library decides what thread to run next
• Upcall whenever kernel ac+on requires (user-‐level) scheduling decision • Process assigned a new processor • Processor removed from process • System call blocks in kernel
![Page 32: Concurrency) - University of Washingtoncourses.cs.washington.edu/courses/cse451/14au/slides/concurrency.pdf · Mo+vaon) • Operang)systems)(and)applicaon)programs)) o9en)need)to)be)able)to)handle)mul+ple)things)](https://reader034.vdocuments.us/reader034/viewer/2022042108/5e8775b8a994db69bd1059cb/html5/thumbnails/32.jpg)
Ques+on
• Compare event-‐driven programming with mul+threaded concurrency. Which is beFer in which circumstances, and why?