What problems can arise from shared memory among threads? How can they be avoided? What synchronization methods do you know?

Shared memory among threads can lead to several problems:

• Data races: when multiple threads read and write the same data simultaneously without synchronization, resulting in unpredictable outcomes.
• Data integrity violations: partial updates can lead to inconsistent states.
• Deadlocks: improper use of locks can cause situations where threads wait for each other indefinitely.

To avoid these issues, various synchronization methods are used:

1. Mutexes: lock access to critical sections, allowing only one thread to work with shared data at a time.
2. RWMutex: allows multiple threads to read data simultaneously but blocks writing.
3. Channels in Go: enable safe data transfer between goroutines without explicit locking.
4. Atomic operations: for simple operations on variables (e.g., increment), atomic functions from the sync/atomic package can be used.

Example with a mutex in Go:

var mu sync.Mutex
var counter int

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

Using channels for data transfer:

ch := make(chan int)
go func() {
    ch <- 42
}()
val := <-ch

The choice of synchronization method depends on the task and performance requirements.