Menu Close

BlockProfile of runtime package in go

In this tutorial, We are going to learn about BlockProfile of runtime package in go with example in details.

BlockProfile of runtime package in go records the time spent waiting for synchronization primitives such as mutexes and channels. BlockProfile provides facilities for collecting and analyzing profiling data. Block profiling helps developers identify bottlenecks caused by contention or synchronization issues. By analyzing the data, you can optimize your program’s performance by reducing contention or parallelizing work.

Using BlockProfile

To use BlockProfile, you must first enable block profiling in your program. You can do this by setting the BlockProfileRate, which determines the fraction of goroutine blocking events that are recorded. A higher rate will provide more accurate profiling data but will also increase the overhead.


package main

import (








func slowFunction() {

	time.Sleep(100 * time.Millisecond)


func main() {

	runtime.SetBlockProfileRate(1) // Enable block profiling

	f, err := os.Create("")

	if err != nil {




	defer f.Close()

	wg := sync.WaitGroup{}


	for i := 0; i < 10; i++ {

		go func() {

			mu := sync.Mutex{}


			defer mu.Unlock()






	pprof.Lookup("block").WriteTo(f, 0)


In this example, we first enable block profiling by calling ‘runtime.SetBlockProfileRate(1)’. We create a file called ‘’ to store the BlockProfile data. The program simulates contention by running 10 goroutines that lock a mutex and call a slow function. After waiting for the goroutines to finish, we write the block profile data to the file using ‘pprof.Lookup(“block”).WriteTo(f, 0)’.

Analyzing BlockProfile Data

To analyze the BlockProfile data, use the ‘go tool pprof’ command-line interface:

$ go tool pprof

Using the ‘top‘ command in the pprof tool, you can see the functions that contributed the most to blocking time. In our example, you would observe that the ‘slowFunction’ is the primary source of contention.


(pprof) top
Showing nodes accounting for 2s, 100% of 2s total
      flat  flat%   sum%        cum   cum%
        2s   100%   100%         2s   100%  sync.(*WaitGroup).Wait
         0     0%   100%         2s   100%  main.main
         0     0%   100%         2s   100%  runtime.main

Optimizing the Code

Based on the BlockProfile data, you can take steps to optimize your code. For example, in this case, we could parallelize the slow function or use a more efficient locking mechanism to reduce contention and improve performance.

To learn more about golang, You can refer given below link:


Posted in golang, packages, runtime

Leave a Reply

Your email address will not be published. Required fields are marked *