Gain insights into Go's concurrency, delve into efficient programming techniques, learn advanced concepts, and discover how to enhance performance and robustness in your applications.

TarballFiber.tar.gz

raceFlag

server side

user input

server side-copy

serverJob

Go (also known as Golang) is one of the most popular languages today and is a key part of many enterprise tech stacks. Because Go's memory management architecture makes concurrency easier, many developers prefer it over traditional languages.

In this course, you will learn the core constructs and techniques of Go as well as advanced concepts of the language. In particular, you’ll learn how to program efficiently by becoming aware of the pitfalls and patterns that are commonly encountered in Go and by building your own applications.

Once you’ve completed this course, you will be able to write concurrent programs and improve the performance of existing ones, thus creating a more robust experience for everyone. Concurrency is in high demand today since it enables developers to reduce execution time of applications significantly, and Golang provides a very rich support for achieving this.

Concurrency in Go

## The `hchan struct`

Internally, the channels implement an `hchan struct`, which holds the information related to the channels. It includes the buffer size `buf`, the sender `sendx`, the receiver `recvx`, the channel blocked due to sending sendq, the channel blocked due to receiving `recvq`, the mutex `lock`, and many more fields.


type hchan struct {
	qcount   uint           // total data in the queue
	dataqsiz uint           // size of the circular queue
	buf      unsafe.Pointer // points to an array of dataqsiz elements
	elemsize uint16
	closed   uint32
	elemtype *_type // element type
	sendx    uint   // send index
	recvx    uint   // receive index
	recvq    waitq  // list of recv waiters
	sendq    waitq  // list of send waiters

	// lock protects all fields in hchan, as well as several
	// fields in sudogs blocked on this channel.
	lock mutex
}

### Terminology

Let’s explore the terminology of the `hchan struct`.


* `buf`: This represents the circular queue that stores the data.
* `closed`: This indicates whether the channel is closed or not.
* `dataqsiz`: This indicates the `capacity` (for the unbuffered channel, it is 0).
* `elemtype`: This indicates the type of element the channel will transmit.
* `sendx`, `recvx`: These indicate the positions in the buffer from which to read and on which to write, respectively.
* `sendq`, `recvq`: These indicate the blocked goroutines. They are linked lists of type `waitq`. The `waitq` type is a node that contains a struct of type `sudog`. The `sudog` type is a goroutine waiting on an element.
* lock: This i


## Walkthrough the tagline

The goroutines copy the elements into and from the `hchan struct` protected by the mutex `lock`.


>**Note**: : Here’s some good advice from the [Go documentation](https://go.dev/blog/codelab-share) . “Do not communicate by sharing memory; instead, share memory by communicating.”


The channel is basically the pointer. We can pass the channels as arguments. The channels are pointers under the hood, so that’s how we share the same memory. We are giving reference to each place.


The goroutines acquire the lock when inserting the value into the buffer and then release the lock. Similarly, it creates a lock on the buffer when reading the dequeue or receiving value and then unlocks the buffer.

Notice that we aren’t sharing memory anywhere. The memory is the same everywhere. We are just communicating the pointers and protecting the values using the locks.



>**Note**: You can find many more concepts related to channels and their structure in Go’s [official documentation](https://golang.org/src/runtime/chan.go).

## Working of an unbuffered channel

**Note:** Channels implement the `hchan struct`. When we create an unbuffered channel, the buffer size is 0.

```go
ch := make(chan int, 3)
```

When we create a channel using the `make` function,` hchan` is allocated a space in a heap. The `make` function returns a reference to the allocated memory, which is stored as `ch`. Since `ch` is a pointer, it can be sent between functions to perform the send and receive operation on the channel.

# The `hchan struct`

Internally, the channels implement an `hchan struct`, which holds the information related to the channels. It includes the buffer size `buf`, the sender `sendx`, the receiver `recvx`, the channel blocked due to sending sendq, the channel blocked due to receiving `recvq`, the mutex `lock`, and many more fields.


## Terminology

Let’s explore the terminology of the `hchan struct`.


* `buf`: This represents the circular queue that stores the data.
* `closed`: This indicates whether the channel is closed or not.
* `dataqsiz`: This indicates the `capacity` (for the unbuffered channel, it is 0).
* `elemtype`: This indicates the type of element the channel will transmit.
* `sendx`, `recvx`: These indicate the positions in the buffer from which to read and on which to write, respectively.
* `sendq`, `recvq`: These indicate the blocked goroutines. They are linked lists of type `waitq`. The `waitq` type is a node that contains a struct of type `sudog`. The `sudog` type is a goroutine waiting on an element.
* lock: This i


# Walkthrough the tagline

The goroutines copy the elements into and from the `hchan struct` protected by the mutex `lock`.


>**Note**: : Here’s some good advice from the [Go documentation](https://go.dev/blog/codelab-share) . “Do not communicate by sharing memory; instead, share memory by communicating.”


The channel is basically the pointer. We can pass the channels as arguments. The channels are pointers under the hood, so that’s how we share the same memory. We are giving reference to each place.


The goroutines acquire the lock when inserting the value into the buffer and then release the lock. Similarly, it creates a lock on the buffer when reading the dequeue or receiving value and then unlocks the buffer.

Notice that we aren’t sharing memory anywhere. The memory is the same everywhere. We are just communicating the pointers and protecting the values using the locks.



>**Note**: You can find many more concepts related to channels and their structure in Go’s [official documentation](https://golang.org/src/runtime/chan.go).

# Working of an unbuffered channel

**Note:** Channels implement the `hchan struct`. When we create an unbuffered channel, the buffer size is 0.

```go
ch := make(chan int, 3)
```

When we create a channel using the `make` function,` hchan` is allocated a space in a heap. The `make` function returns a reference to the allocated memory, which is stored as `ch`. Since `ch` is a pointer, it can be sent between functions to perform the send and receive operation on the channel.

Learn about the hchan struct and some deep concepts in Golang.


Deep Concepts About Channels

Learn about the hchan struct and some deep concepts in Golang.

Introduction to Concurrency

General Concepts

Sync

Goroutines

Channels

Implementing Concurrency Patterns

Conclusion

Channels Internals

The `hchan struct`

Terminology

Channels Internals

The hchan struct

Terminology

The `hchan struct`