Hey buddy, so you’re going neck-deep into Golang and stumbled upon some pain points with concurrency, huh? Don’t worry; you’re not alone. Let’s talk it out and find a way to get you unstuck.

Demystifying Concurrency Concepts in Golang

To start with, Golang’s concurrency model is based on the idea of Go routines and channels. Simply put, Goroutines can be seen as lightweight threads, and channels are the pipes that connect them. You can send and receive values from these channels. Here’s a basic example:

package main

import (
    "fmt"
    "time"
)

func print(word string) {
    for i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(word)
    }
}

func main() {
    go print("Hello")
    print("World")
}

The output will print "Hello" and "World" alternately. This is because we’ve launched print("Hello") in a new Goroutine, which will run concurrently with print("World"). However, things start getting tricky when Goroutines interact with shared resources.

Common Pitfalls to Avoid

1. Race Conditions: This is a bug that occurs when the output of a program is dependent on the sequence or timing of other uncontrollable events. If two Goroutines access the same variable concurrently, and at least one of them is changing its value, you've got yourself a race condition. Golang provides a built-in tool called the Data Race Detector to catch these. Just run "go run -race yourfile.go".

2. Deadlocks: A Deadlock is a situation where a Goroutine is waiting for something that won't happen. In Golang, this is often due to incorrectly organized channel communications. Remember that if a Goroutine is waiting to send on or receive from a channel and that event cannot possibly occur, the scheduler will throw a deadlock error.

What You Should Remember

Battling with concurrency might sometimes feel like a wild goose chase, but once you've got the hang of it, it turns your programs into a work of art. And luckily, Golang has your back. Using “go run -race” and proper usage of channels and locks can save you hours of debugging. Don’t be disheartened by temporary setbacks. They’re steps towards your ultimate success.

Also, remember there isn't always a need for low-level, nitty-gritty optimizations. Sometimes you might think making everything concurrent will drastically improve performance, yet simplicity and readability are often more important. “Do not communicate by sharing memory; instead, share memory by communicating,” as the Go Proverb goes.

The path to mastering concurrency in Golang might have some twists and turns, but trust me, you'll pull it off!