Interpreting Golang's closure implementation from assembly layer: Escape analysis and performance impact

This article carefully sorted out a series of high-frequency Golang questions that are difficult in interviews. Some of the knowledge points may not have been explored in depth before, but they are crucial in interviews and actual work.

include:Golang's core knowledge points such as basic syntax, concurrency model, and memory management. This article will also go into more mid-to-high-level themes, combining enterprise-level application scenarios to help you stand out in fierce competition.

I sincerely wish every job seeker can find the job he likes.

1. What are the basic data types of Golang and what are their characteristics?

The basic data types of Golang mainly include:

• Boolean type (bool): onlytrueandfalseTwo values ​​are often used for conditional judgment.
• Numeric type:
  • Integer type: Yesint、int8、int16、int32、int64and the corresponding unsigned integer typeuint、uint8、uint16、uint32、uint64wait. Integer types with different digits are suitable for different scenarios and can be selected according to actual needs to save memory.
  • Floating point number type:float32andfloat64, represent single-precision and double-precision floating-point numbers respectively. When performing floating point operations, pay attention to accuracy issues.
  • Plural type:complex64andcomplex128, used to process complex operations.
• String type (string): is an immutable sequence of bytes, encoded using UTF-8. A single byte can be accessed through an index, but be careful to handle multibyte characters.

2. What is the concurrency model of Go language, and what are the functions of Goroutine and Channel?

The Go language adopts CSP (Communicating Sequential Processes) concurrency model, and its core is to share memory through communication, rather than traditional communication through shared memory.

• Goroutine: is a lightweight thread implementation of the Go language, managed by the Go runtime. Compared to traditional threads, Goroutines have minimal overheads to create and destroy, making it easy to create thousands of Goroutines. It makes concurrent programming simple and efficient, and developers can assign different tasks to different Goroutines to execute in parallel.

• Channel: is a mechanism for communication and synchronization between Goroutines. Channels allow you to safely pass data between different Goroutines, avoiding the concurrent security issues caused by shared memory. Channels are divided into buffered and unbuffered. Unbuffered Channels are used for synchronous communication, while buffered Channels can implement asynchronous communication.

Sample code:

package main
 
 import (
     "fmt"
 )
 
 func worker(id int, jobs <-chan int, results chan<- int) {
     for j := range jobs {
         ("Worker %d started job %d\n", id, j)
         results <- j * 2
         ("Worker %d finished job %d\n", id, j)
     }
 }
 
 func main() {
     const numJobs = 5
     jobs := make(chan int, numJobs)
     results := make(chan int, numJobs)
 
     // Start 3 workers Goroutines
     for w := 1; w <= 3; w++ {
         go worker(w, jobs, results)
     }
 
     // Send jobs
     for j := 1; j <= numJobs; j++ {
         jobs <- j
     }
     close(jobs)
 
     // Collect results
     for a := 1; a <= numJobs; a++ {
         <-results
     }
     close(results)
 }

3. Briefly describe the memory management mechanism of the Go language, including garbage collection and memory allocation.

• Garbage Collection (GC): The Garbage Collector for Go uses an improved version of the tag-cleaning algorithm, combining tri-color tagging and write barrier technology. The main workflow is as follows:
  • Marking stage: Starting from the root object, marking all reachable objects.
  • Clear phase: Clear all unmarked objects.
  • Concurrent tagging and cleaning: To reduce the impact on program execution, Go's garbage collector can execute concurrently with the program.
• Memory allocation: The Go language memory allocator uses multi-level caching to divide memory into blocks of different sizes. When a program needs to allocate memory, it is allocated from the appropriate cache according to the size of the memory required. This can improve the efficiency of memory allocation and reduce memory fragmentation.

4. How to deal with errors in Go language, and what are the commonly used error handling methods?

There is no traditional exception handling mechanism in Go, but instead handles errors by returning error values.

Commonly used error handling methods are:

• Returns the error value: If an error is encountered during execution, a non-return will be returned.nilError object. The caller needs to check the returned error value and perform corresponding processing.

package main  
 
import (  
    "errors"  
    "fmt"  
)  
 
func divide(a, b int) (int, error) {  
    if b == 0 {  
        return 0, ("division by zero")  
    }  
    return a / b, nil  
}  
 
func main() {  
    result, err := divide(10, 0)  
    if err != nil {  
        ("Error:", err)  
    } else {  
        ("Result:", result)  
    }  
}  

• usedefer、panicandrecover：
  • deferUsed to delay execution of functions, usually used for operations such as resource release.
  • panicUsed to trigger a runtime error and cause the program to panic.
  • recoverUsed to recover from a panic state, usually indeferUsed in functions.

5. Explain the interface in the Go language. What is its function and implementation?

In Go, an interface is an abstract type that defines the signature of a set of methods but does not contain the implementation of the method. The main functions of the interface are:

• Implementation polymorphism: Different types can implement the same interface, so different types of implementation methods can be called through variables of interface type.
• Decoupling: The interface can separate the caller and implementer of the code, improving the maintainability and scalability of the code.

The implementation of an interface is implicit. As long as a type implements all methods defined in an interface, it is considered that the type implements the interface.

Sample code:

package main
 
 import "fmt"
 
 // Shape defines an interface
 type Shape interface {
     Area() float64
 }
 
 // Rectangle defines a rectangle type
 type Rectangle struct {
     Width float64
     Height float64
 }
 
 // Area method to implement Shape interface
 func (r Rectangle) Area() float64 {
     return *
 }
 
 // Circle defines a circle type
 type Circle struct {
     Radius float64
 }
 
 // Area method to implement Shape interface
 func (c Circle) Area() float64 {
     return 3.14 * *
 }
 
 func main() {
     var s Shape
     r := Rectangle{Width: 10, Height: 5}
     c := Circle{Radius: 3}
 
     s = r
     ("Rectangle Area:", ())
 
     s = c
     ("Circle Area:", ())
 }

6. What is the difference between slices (slices) and arrays (Array) in Go language?

• Definition and length:
  • Array: is a sequence of elements of the same type with a fixed length, and the length needs to be specified when defining.
  • Slice: is a reference to a continuous fragment of an array, a sequence of dynamic lengths, and does not require a specified length.
• Memory allocation:
  • Array: When defined, a continuous piece of memory space will be allocated, and its size is fixed.
  • Slice: is a reference type that contains a pointer to the underlying array, the length and capacity of the slice. The memory allocation of slices is dynamic and can be used throughappendThe function dynamically increases the length of the slice.
• Transmission method:
  • Array: When passed as a parameter, a copy of the value will be performed, that is, a copy of the array is passed.
  • Slice: When passed as a parameter, the reference to the slice is passed, and no value copying is performed. Modifying the slice will affect the original slice.

7. How to achieve concurrency security in the Go language, and what are the commonly used concurrency security mechanisms?

In the Go language, common mechanisms for achieving concurrent security are:

• Mutex: is used to protect shared resources, allowing only one Goroutine to access shared resources at the same time.

package main  
 
import (  
    "fmt"  
    "sync"  
)  
 
var (  
    counter int  
    mutex     
)  
 
func increment() {  
    ()  
    defer ()  
    counter++  
}  
 
func main() {  
    var wg   
    for i := 0; i < 1000; i++ {  
        (1)  
        go func() {  
            defer ()  
            increment()  
        }()  
    }  
    ()  
    ("Counter:", counter)  
}  

• Read and write lock (RWMutex): suitable for scenarios where more reads and fewer writes are allowed to read operations at the same time, but the resources will be exclusive when writing operations.
• Atomic operation: Go languagesync/atomicThe package provides atomic operation functions for atomic read and write operations on integer types, avoiding the overhead of locking.

8. Briefly describe the package management mechanism of the Go language and how to use Go Modules.

The Go language package management mechanism has gone through multiple stages of development, and it is now recommended to use Go Modules for package management.

• Go Modules: is an official package management solution introduced by Go 1.11, which allows developers to use versioned dependency packages in their projects.
• Steps to use:
  1. Initialization module: Execute in the project root directorygo mod init <module-name>,createdocument.
  2. Add dependencies: When new packages are introduced into the code, executego mod tidyCommand, Go Modules will automatically download the required dependency package and update itanddocument.
  3. Administrative version: Can be passedgo getThe command specifies the version of the dependency package, for examplego get /[email protected]。

9. Explain the reflection in Go language. What are its application scenarios?

Reflection refers to the ability to check and operate the type information and values ​​of a program at runtime. In Go, reflection mainly passesreflectPackage implementation. Reflection application scenarios include:

• General functions: Common functions can be written to process different types of data, such as implementing a common JSON serialization and deserialization function.
• Plugin system: dynamically load and call the plug-in at runtime, and perform corresponding operations based on the plug-in type information.
• Configuration analysis: The configuration data can be dynamically mapped into the structure based on the field name and type information in the configuration file.

Sample code:

package main  
 
import (  
    "fmt"  
    "reflect"  
)  
 
func printTypeAndValue(i interface{}) {  
    t := (i)  
    v := (i)  
    ("Type: %v, Value: %v\n", t, v)  
}  
 
func main() {  
    num := 10  
    str := "hello"  
    printTypeAndValue(num)  
    printTypeAndValue(str)  
}  

10. Go languageselectWhat is the function of a statement and how to use it?

selectStatements are used to select multiple channel operations, similar toswitchstatement, but it is specifically used for channels.selectThe function of statements is to implement non-blocking channel operations and improve the concurrency performance of the program.

How to use it is as follows:

package main  
 
import (  
    "fmt"  
    "time"  
)  
 
func main() {  
    ch1 := make(chan int)  
    ch2 := make(chan int)  
 
    go func() {  
        (2 * )  
        ch1 <- 1  
    }()  
 
    go func() {  
        (1 * )  
        ch2 <- 2  
    }()  
 
    select {  
    case val := <-ch1:  
        ("Received from ch1:", val)  
    case val := <-ch2:  
        ("Received from ch2:", val)  
    case <-(3 * ):  
        ("Timeout")  
    }  
}  

In the above code,selectThe statement will wait for any of the multiple channel operations to complete, and if no channel operations are completed within 3 seconds, it will be executed.Branch, outputTimeout。

---

11. Detailed explanation and optimization practice of Go's garbage collection (GC) mechanism

Go's Garbage Collector (GC) uses three-color marking method and write barrier technology to achieve concurrent marking, significantly reducing STW (Stop-The-World) time.
Core points:

Three-color marking process:

• White object: Object to be scanned
• Gray Object: Scanned but subobject not scanned
• Black Object: Scanned and the sub-object completed scanning
• The marking stage traverses the object graph concurrently and finally clears the white object.

GC optimization strategy:

• Reduce heap memory allocation (such as multiplexed object pools)
• Avoid high frequency allocation of small objects (using）
• AdjustmentGOGCParameter control GC trigger threshold

Example: UsepprofAnalyze memory leaks

import _ "net/http/pprof"
 
 func main() {
     go func() {
         (("localhost:6060", nil))
     }()
     // Business code...
 }

---

12. Go performance tuning: from tools to practical combat

Core toolchain:

• pprof: Analyze CPU, memory, and blocking situation

go tool pprof http://localhost:6060/debug/pprof/profile 

• trace: Tracking Goroutine scheduling and GC events

f, _ := ("")
(f)
defer ()

• Benchmark: Writing benchmarks

func BenchmarkAdd(b *) {
    for i := 0; i < ; i++ {
        Add(1, 2)
    }
}

Optimization tips:

• reducedeferUse in hotspot paths (manually manage resource release)
• useAlternative+Stitching strings
• Pre-allocated Slice/Map capacity to avoid capacity expansion overhead

---

13. Go Network Programming: From TCP to gRPC

TCP server development

ln, _ := ("tcp", ":8080")
 for {
     conn, _ := ()
     go handleConn(conn) // Goroutine handles connections
 }
 
 func handleConn(conn ) {
     defer ()
     buf := make([]byte, 1024)
     (buf)
     // Business logic...
 }

gRPC microservice practice

1. Define Proto file:

service UserService {
    rpc GetUser(UserRequest) returns (UserResponse) {}
}

2. Generate code:

protoc --go_out=. --go-grpc_out=.  

3. Implement the server:

type server struct{}
func (s *server) GetUser(ctx , req *) (*, error) {
    return &{Id: , Name: "John"}, nil 
}

---

14. Go database operations: GORM and SQLX depth comparison

characteristic	GORM (ORM framework)	SQLX (Extended Standard Library)
Learning curve	Higher (to understand the ORM model)	Low (similar to native SQL)
performance	Medium (reflection overhead)	High (direct structure binding)
Transaction Management	Support nested transactions	Need to be managed manually
Applicable scenarios	Rapid CRUD development	Complex SQL query and optimization

GORM transaction example:

(func(tx *) error {
    if err := (&User{Name: "Alice"}).Error; err != nil {
        return err 
    }
    if err := ("Age", 30).Error; err != nil {
        return err 
    }
    return nil 
})

---

15. Go standard library must know: analysis of the top ten core packages

• context: Trans-Goroutine context delivery and timeout control
• sync: Provide concurrent primitives such as Mutex, WaitGroup, Once, etc.
• net/http: Quickly build HTTP services and clients
• encoding/json: JSON serialization and deserialization
• os/exec: Execute external commands and get output
• time: time processing and timer (Timer/Ticker)
• flag: Command line parameter analysis
• Testing: Unit Testing and Coverage Statistics
• io/ioutil: Simplify file read and write operations
• reflect: Runtime reflection (use with caution, affecting performance)

(Follow me, I will write an article for detailed explanation later)

---

16. Go testing and debugging: Advanced Tips for Mock and Debug

Mock external dependencies:

type DB interface {
     GetUser(id int) (*User, error)
 }
 
 func ProcessUser(db DB, id int) error {
     user, err := (id)
     // Business logic...
 }
 
 // Inject Mock object during testing
 type MockDB struct{}
 func (m *MockDB) GetUser(id int) (*User, error) {
     return &User{Name: "TestUser"}, nil
 }

Delve debugger practical combat:

dlv debug  
(dlv) break  
(dlv) continue 
(dlv) print variable 

This article will present knowledge points in the form of real interview questions. It is recommended that when reading, you should first think about it yourself, try to give the answer, and then compare it with the analysis of this article.

If you have better insights, please leave a message to communicate.

Welcome to follow ❤

We made oneFree interview question sharing group, communicate with each other, and make progress in practicing the questions together.

Maybe you can get the latest interview questions from your company you want.

Interested friends can add me on WeChat:wangzhongyang1993, Note: Go interview group.