Do Once Golang

Go Programming

Do you ever find yourself needing to execute a function only once? One common solution is to use a boolean flag to keep track of whether the function has been called. However, in Go, there is a more elegant solution: the sync.Once package. In this article, I’ll delve into the sync.Once package in Golang and explain how it can be used to achieve the “do once” behavior.

Understanding the sync.Once Package

The sync.Once package in Golang provides a mechanism to perform initialization exactly once. It guarantees that the function passed as an argument will be executed only once, regardless of how many goroutines call it. This makes it incredibly useful for scenarios where you want to initialize a resource or perform a one-time operation without the need for manual synchronization.

Exploring the Syntax

To use sync.Once, you first declare a variable of type sync.Once. This variable should be used for the one-time initialization. The sync.Once type has a method called Do, which takes a function as an argument. This function will be executed only once, regardless of the number of times Do is called.

Here’s a simple example to illustrate the basic syntax:

var once sync.Once
once.Do(func() {
// Code to be executed once

When to Use sync.Once

With its simplicity and efficiency, sync.Once is especially handy when dealing with resources that need to be initialized only once, such as establishing a database connection, initializing a configuration, or setting up a global data structure. It helps in avoiding unnecessary overhead and ensures that the initialization code is executed only when needed.

Highlighting the Benefits

The use of sync.Once not only simplifies the code by removing the need for manual bookkeeping of whether the function has been called, but it also contributes to better performance. This is because it reduces the contention and synchronization overhead that might occur in scenarios where multiple goroutines are involved.


Embracing the sync.Once package in Golang has certainly elevated my programming experience. The convenience and reliability it offers when needing to execute a function only once are unparalleled. It has streamlined my code and eliminated the hassle of managing flag variables. The next time you encounter a “do once” scenario in your Go code, remember the power of sync.Once and witness the elegance it brings to your solution.