In Go language, we can define an empty struct, that is, a struct without any member variables, and use the keyword struct{} to represent it. This structure seems to be of no use, but in fact it is widely used in the Go language. This article will introduce the use of empty structures from multiple aspects to let everyone better understand its role.
1. Definition and initialization of empty structures
An empty structure refers to a structure that does not contain any fields. In Golang, you can use struct{} to define an empty structure. Here is a simple example:
package main
import "fmt"
func main() {
var s struct{}
("%#v\n", s) // Output: struct {}{} }In this example, we define a variable named s and initialize it as an empty structure. Then we use : to print out this empty structure. Note that the %#v placeholder is used when printing, which can output variables in Go syntax format.
The output is struct {}{}, which means that s is an empty structure and does not contain any fields. It should be noted that the empty structure variable does not actually occupy any memory space, that is, its size is 0 bytes.
2. The size and memory usage of empty structures
As mentioned above, the size of an empty structure is 0 bytes. This means it does not take up any memory space. This can be verified by using functions:
package main
import (
"fmt"
"unsafe"
)
func main() {
var s struct{}
("Size of struct{}: %v\n", (s)) // Output: Size of struct{}: 0 }In this example, we use the function to get the size of s and print the result out. Since s is an empty structure, its size is 0.
It should be noted that although the size of an empty structure is 0, it does not mean that it cannot be passed as a function parameter or return value. Because in Go, each type has its own type information that can be used for type checking and conversion. Therefore, even an empty structure has its own position and function in the type system.
3. An empty structure as a placeholder
The most common use of empty structures is as placeholders. In a function or method signature, if there are no parameters or return values, an empty structure can be used to identify the function or method. Here is a simple example:
package main
import "fmt"
func doSomething() struct{} {
("Doing something")
return struct{}{}
}
func main() {
doSomething()
}In this example, we define a function called doSomething that accepts no parameters and returns no values. We can use an empty structure to identify its return value. In the implementation of the doSomething function, we simply print a message and return an empty structure.
In the main function, we call the doSomething function. Since it does not return any value, we do not need to store its results in a variable.
It should be noted that in this example, we explicitly specify the type of the return value as struct{}. This is because if the type of return value is not specified, the Go compiler will parse it to the interface{} type by default. In this case, each call to the doSomething function will be assigned a new empty interface object, which may cause performance problems.
4. The empty structure serves as a channel element
An empty structure can also be used as an element type for the channel. In Go, a channel is a mechanism for communicating and syncing between coroutines. When using a channel, we need to specify the type of element in the channel.
If we don't need to transfer any value in the channel, then we can use an empty structure as the element type. Here is a simple example:
package main
import "fmt"
func main() {
c := make(chan struct{})
go func() {
("Goroutine is running")
c <- struct{}{}
}()
<-c
("Goroutine is done")
}In this example, we create a channel named c and specify its element type as struct{}. We then run some code in a new coroutine and send an empty structure into the channel in the coroutine. In the main function, we receive an element from the channel, where we are actually waiting for the end of the coroutine. Once we receive an element, we print out "Goroutine is done".
It should be noted that in this example, we did not send any useful data to the channel. Instead, we just use channels to synchronize execution between coroutines. This approach is very useful for implementing complex concurrency models, as it avoids the use of explicit mutexes or semaphores for synchronization and communication.
5. The empty structure serves as the placeholder for the map
In Go, map is a data structure used to store key-value pairs. If we only need a set of keys and do not store any values, then we can use an empty structure as the value type of map. Here is a simple example:
package main
import "fmt"
func main() {
m := make(map[string]struct{})
m["key1"] = struct{}{}
m["key2"] = struct{}{}
m["key3"] = struct{}{}
(len(m)) // Output: 3 }In this example, we create a map named m and specify its value type as struct{}. We then add three keys to the map, all of which have empty structures. Finally, we print the length of the map, which is 3.
It should be noted that in this example, we do not use any other features of the empty structure. We just use it as the value type of map because we don't need to store any values in map.
6. The empty structure serves as the method receiver
In Go, a method is a mechanism to associate functions with a specific type. If we do not need to access any receiver fields in the method, then we can use an empty structure as the receiver type. Here is a simple example:
package main
import "fmt"
type MyStruct struct{}
func (m MyStruct) DoSomething() {
("Method is called")
}
func main() {
s := MyStruct{}
()
}In this example, we create a structure called MyStruct and define a method DoSomething for it. In this method, we just print a message.
In the main function, we create a MyStruct instance s and then call its DoSomething method. Since we do not need to access any fields of the receiver in the method, we can use an empty structure as the receiver type.
It should be noted that even if we use an empty structure as the receiver type in our method, we can still pass other parameters to the method. For example, we can modify the DoSomething method like this:
func (m MyStruct) DoSomething(x int, y string) {
("Method is called with", x, y)
}In this example, we add two parameters to the DoSomething method. However, we can still use empty structures as receiver type.
7. The empty structure is implemented as an interface
In Go, an interface is a mechanism to define the behavior of an object. If we do not need any method to implement the interface, then we can use an empty structure as the implementation. Here is a simple example:
package main
import "fmt"
type MyInterface interface {
DoSomething()
}
type MyStruct struct{}
func (m MyStruct) DoSomething() {
("Method is called")
}
func main() {
s := MyStruct{}
var i MyInterface = s
()
}In this example, we define an interface called MyInterface and define a method DoSomething for it. We also define a structure called MyStruct and implement the DoSomething method for it.
In the main function, we create a MyStruct instance s and assign it to the variable i of type MyInterface. Since MyStruct implements the DoSomething method, we can call the method and print out a message.
It should be noted that in this example, we did not add any specials to the interface implementation. We just use an empty structure as implementation, because we don't need any method to implement the interface.
8. The empty structure serves as the semaphore
In Go, we can use empty structures as semaphores to control concurrent access. Here is a simple example:
package main
import (
"fmt"
"sync"
)
func main() {
var wg
var mu
var signal struct{}
for i := 0; i < 5; i++ {
(1)
go func(id int) {
()
defer ()
("goroutine", id, "is waiting")
()
("goroutine", id, "is signaled")
}(i)
}
("main thread is sleeping")
("press enter to signal all goroutines")
()
closeCh := make(chan struct{})
go func() {
for {
select {
case <-closeCh:
return
default:
()
signal = struct{}{}
()
}
}
}()
("all goroutines are signaled")
close(closeCh)
()
("all goroutines are done")
}In this example, we create a WaitGroup and a Mutex to synchronize between multiple goroutines. We also define an empty structure called signal.
In the for loop, we started 5 goroutines. In each goroutine we acquire the Mutex lock and print a waiting message. Then, we use WaitGroup to wait for all goroutines to complete.
In the main function, we wait for a while and then send signals to all goroutines. To achieve this, we create a channel called closeCh and create an infinite loop in it. In each loop, we check if a closeCh channel has received a shutdown signal. If not, we acquire the Mutex lock and set the signal variable to an empty structure. In this way, all goroutines waiting for the signal variable will be awakened.
Finally, we wait for all goroutines to complete and print a completion message.
It should be noted that in this example, we use an empty structure as a semaphore to control concurrent access. Since an empty structure does not occupy any memory space, it is very suitable as a semaphore.
9. Summary
This article introduces eight aspects of using empty structures in Go. We see the use of empty structures as types, map keys, semaphores, and method receivers. We also see empty structures that can help us optimize memory usage and control concurrent access.
Although empty structures are very simple, they are an important part of the Go language. They provide a lightweight way to represent structures without any state or data, and can be applied in a variety of different scenarios.
In addition to the purposes discussed in this article, empty structures can also be used in some other scenarios. For example, when using the context package, we can use an empty structure to represent a context without any data. When using the sync package, we can use an empty structure as a parameter to the method so that no memory is occupied while waiting for the condition.
Of course, empty structures are not the solution to all problems. In some cases, it may be more appropriate to use other data structures or techniques. However, when we need to represent a structure without any state or data, an empty structure is a very elegant and effective solution.
In this article, we delve into the various uses of empty structures through sample code. I hope these examples can help you better understand the concept and usage of hollow structures in Go language.
The above is a detailed description of the wonderful uses of the hollow structure in Go language. For more information about the hollow structure in Go language, please pay attention to my other related articles!