ProducerConsumer - five variants of the producer/consumer pattern

[hakenr]

Summary

Adds a new ProducerConsumer learning project that walks through the producer/consumer pattern from a naive racy implementation up to a modern Channel<T>-based solution. Each variant is a standalone net10.0 console app, all collected under a single .slnx solution.

What's included

• README.md — task description, goals, questions for each variant, and notes (Czech).
• ProducerConsumer.slnx — multi-project solution.
• Five console apps, each a single Program.cs with top-level statements:
  1. ProducerConsumer.Naive — shared Queue<int> without synchronization. Intentionally buggy: race conditions and busy waiting.
  2. ProducerConsumer.Lock — atomic enqueue/dequeue via lock. Still busy waits.
  3. ProducerConsumer.MonitorWait — Monitor.Wait / Monitor.Pulse; consumer sleeps when the queue is empty. Uses while (not if) to handle spurious wakeups; finished flag + PulseAll for shutdown.
  4. ProducerConsumer.AsyncSemaphore — async consumer using SemaphoreSlim.WaitAsync() so the waiting thread is freed up.
  5. ProducerConsumer.Channel — modern solution using System.Threading.Channels and await foreach, with Writer.Complete() for shutdown.

Each variant produces N=20 items so the producer/consumer interleaving is visible in the console output.

Test plan

• dotnet build ProducerConsumer/ProducerConsumer.slnx — succeeds, 0 warnings, 0 errors.
• All five variants run end-to-end and print items 1..20 as expected.
• Reviewer skim: README content matches the assignment text verbatim; comments in each Program.cs are aligned with the matching README section.

🤖 Generated with Claude Code

[Copilot]

Pull request overview

Adds a new ProducerConsumer learning project to the repo, showcasing five producer/consumer implementations from a deliberately broken baseline through progressively better synchronization approaches up to Channel<T>, bundled in a single .slnx solution.

Changes:

• Added ProducerConsumer/README.md assignment text (Czech) describing goals and questions for each variant.
• Added ProducerConsumer/ProducerConsumer.slnx solution aggregating five standalone console projects.
• Added five net10.0 console apps (Naive, Lock, MonitorWait, AsyncSemaphore, Channel) demonstrating different synchronization techniques.

Reviewed changes

Copilot reviewed 12 out of 12 changed files in this pull request and generated 1 comment.

Show a summary per file

File	Description
ProducerConsumer/README.md	Documents the assignment, goals, and questions for each implementation variant.
ProducerConsumer/ProducerConsumer.slnx	New solution file grouping the five demo projects plus README.
ProducerConsumer/ProducerConsumer.Naive/Program.cs	Intentionally racy/busy-wait baseline implementation.
ProducerConsumer/ProducerConsumer.Naive/ProducerConsumer.Naive.csproj	New console project for the naive variant.
ProducerConsumer/ProducerConsumer.Lock/Program.cs	lock-protected queue access (still busy waiting).
ProducerConsumer/ProducerConsumer.Lock/ProducerConsumer.Lock.csproj	New console project for the lock variant.
ProducerConsumer/ProducerConsumer.MonitorWait/Program.cs	Uses Monitor.Wait/Pulse to remove busy waiting and handle shutdown.
ProducerConsumer/ProducerConsumer.MonitorWait/ProducerConsumer.MonitorWait.csproj	New console project for the Monitor variant.
ProducerConsumer/ProducerConsumer.AsyncSemaphore/Program.cs	Async consumer using SemaphoreSlim.WaitAsync() to avoid blocking a thread.
ProducerConsumer/ProducerConsumer.AsyncSemaphore/ProducerConsumer.AsyncSemaphore.csproj	New console project for the async semaphore variant.
ProducerConsumer/ProducerConsumer.Channel/Program.cs	Channel<T>-based async solution using ReadAllAsync + Complete().
ProducerConsumer/ProducerConsumer.Channel/ProducerConsumer.Channel.csproj	New console project for the channel variant.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

finished is written outside lock (gate) but read under the lock. This is a data race and the consumer may never observe finished == true, leading to a hang after the final available.Release() (consumer wakes, sees queue.Count == 0 and finished == false, continues, then blocks forever on the next WaitAsync). Write finished under the same lock (or use Volatile/Interlocked) and keep the shutdown signal and state change ordered/atomic with respect to the consumer.

[hakenr]

@copilot apply changes based on this feedback

[Copilot]

Fixed in acfd9ac — finished = true is now written inside lock (gate), ensuring the consumer always observes the flag correctly and preventing the hang.