Mutexes can be a central part of creating highly concurrent systems, but designing a system that utilise them can be very complex.
Based on a real case, we will look at design considerations for a performant and scalable service.
This talk will focus on the RW mutex and good patterns of design for it. Main topics will include using fine grained locks and how to design without exploding the complexity.
Designing this in a good way is a prerequisite for consistent performance and good scalability. The RW mutex has some common pitfalls that we will look into. We will look at when mutexes is a better choice and what performance implications can be.
The real world case of this will investigate implementing a highly scalable service for real time ranking of millions of users and wines at Vivino in hundreds of thousands of unique ranking lists. (this will likely be an open sourced project - see notes)
The talk will be accessible for all learning levels, but most interesting for intermediate Go users who are looking to step up their concurrency programming skills beyond the available concurrency patterns.