Lecture
Concurrency: Executors and Mutual Exclusion
In course
DEMO: eiusmod aliqua elit
Id ut aute tempor exercitation sint voluptate tempor nulla consequat veniam dolore officia. Deserunt laboris ea magna minim velit culpa. Culpa commodo laborum exercitation ut in ut ea in. Ullamco deserunt duis aliqua officia consectetur tempor Lorem consequat non. Consectetur ipsum mollit dolore occaecat ea. Minim mollit sunt ut minim est consectetur amet do elit ullamco occaecat consequat. Cupidatat irure anim velit ex nulla.
Description
This lecture covers the efficient alternatives to threads, known as executors, which allow the redesign of applications by specifying tasks to different pools. It also delves into mutual exclusion properties, focusing on the readers-writers problem, critical sections, synchronized blocks, and monitors in Scala and JVM.
Instructors (2)
do nostrud commodo eu
Proident ex cupidatat deserunt veniam in voluptate. Tempor veniam et voluptate fugiat et sint nulla proident dolore magna adipisicing ut. In dolore in consectetur quis ea ea velit do aliqua. Est commodo sint ut dolor non consectetur reprehenderit ipsum in. Consequat quis reprehenderit aliqua eiusmod voluptate aliqua anim anim ad consequat. Nisi ea ipsum id qui consequat. Amet cillum amet exercitation magna tempor quis.
dolor cupidatat
Consequat Lorem veniam deserunt magna commodo id ad ea nisi. Minim velit sunt ea laboris dolore dolor culpa eu consequat. Elit sunt labore incididunt consequat dolor veniam sint incididunt ullamco velit minim irure culpa.
Official source
About this result
This page is automatically generated and may contain information that is not correct, complete, up-to-date, or relevant to your search query. The same applies to every other page on this website. Please make sure to verify the information with EPFL's official sources.
Ontological neighbourhood
Related lectures (32)
Concurrency and Mutual Exclusion
Covers the importance of concurrency, atomic operations, and mutual exclusion using locks.
Readers-writer Lock
Introduces the readers-writer lock for handling concurrency in scenarios with frequent reads and occasional updates.
Scalable Synchronization Mechanisms for Manycore Operating Systems
Explores scalable synchronization mechanisms for many-core operating systems, focusing on the challenges of handling data growth and regressions in OS.
Concurrency Properties: Basics and Locks
Explores concurrency properties, race conditions, and the basics of locks.
Locking
Explores the concept of locking for mutual exclusion in OS, covering race conditions, parallelism, atomic instructions, deadlock prevention, and best practices.