Hi Palak,
Summary: Go's approach to concurrency is higher-level, easier, and much more flexible than C's.
C, C++, and
Java provide support for concurrency using threads. Modern operating systems can distribute the work of threads across multiple processors and cores to maximize throughput. However, threads are relatively expensive to create and use quite a lot of resources. A desktop machine might struggle to run an application that uses just 10s of threads---and certainly one that uses 100+ threads.
Go takes a different approach. Go uses goroutines---these can be treated as if they were threads from the point of view of dividing up work to be done. However, goroutines are so lightweight that running 100s, 1000s, or even 10000s of goroutines on a single machine is perfectly possible. So what goroutines provide is much finer-grained concurrency than threads. (Under the hood the Go runtime system multiplexes goroutines onto one or a few threads.)
In addition, although Go provides low-level concurrent operations (such as atomic increment), and mid-level operations (such as mutexes), Go also provides a high-level a concurrency model called Communicating Sequential Processes (CSP). CSP allows programmers to synchronize goroutines and pass data between them using type-safe uni- or dual-directional pipelines that are much easier to program and reason about than the mid- and low-level facilities offered by C and some other languages.