Tell about the non-obvious concurrency problems you faced in real projects and how you solved them.

In real Go projects, I encountered several non-obvious concurrency issues:

• Data race — when multiple goroutines read and write to shared variables simultaneously without synchronization. I solved this using sync.Mutex, sync.RWMutex, or channels for data transfer.

• Deadlock — for example, when two goroutines wait for each other, holding mutexes. To resolve this, I analyzed the order of lock acquisition, tried to minimize mutex hold times, and used timeouts.

• Lost signals in channels — if a goroutine doesn't read from a channel in time, and another writes, it can cause blocking or data loss. I used buffered channels or controlled goroutine start order.

• Goroutine leaks — when goroutines remain blocked and do not terminate, for example, waiting on a channel that is never closed. I used profiling and contexts (context.Context) for operation cancellation.

• Unpredictable execution order — sometimes it's hard to track the sequence of events. I used logging with timestamps and tracing tools.

Example of using a mutex to protect a shared resource:

var mu sync.Mutex
var counter int

func increment() {
    mu.Lock()
    defer mu.Unlock()
    counter++
}

The main thing is to carefully think through the architecture of parallel components and use Go's built-in synchronization mechanisms.