https://github.com/atomicgo/robin
🔄 Generic, fast and thread-safe round-robin loadbalancer library
https://github.com/atomicgo/robin
atomicgo go golang golang-library loadbalancer loadbalancing round-robin
Last synced: about 1 month ago
JSON representation
🔄 Generic, fast and thread-safe round-robin loadbalancer library
- Host: GitHub
- URL: https://github.com/atomicgo/robin
- Owner: atomicgo
- License: mit
- Created: 2023-06-06T14:24:28.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2024-08-08T17:04:33.000Z (about 1 year ago)
- Last Synced: 2025-05-05T04:45:05.833Z (5 months ago)
- Topics: atomicgo, go, golang, golang-library, loadbalancer, loadbalancing, round-robin
- Language: Go
- Homepage: https://atomicgo.dev
- Size: 57.6 KB
- Stars: 16
- Watchers: 1
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
AtomicGo | robin
---
Documentation
|
Contributing
|
Code of Conduct
---
go get atomicgo.dev/robin
# robin
```go
import "atomicgo.dev/robin"
```
Package robin is a simple, generic and thread\-safe round\-robin load balancer for Go.
It can be used to load balance any type of data. It is not limited to HTTP requests.
Robin takes any slice as an input and returns the next item in the slice. When the end of the slice is reached, it starts again from the beginning.
Thread\-safety is achieved by using atomic operations amd guarantees that two concurrent calls to Loadbalancer.Next will not return the same item, if the slice contains more than one item.
Benchmark:
```
BenchmarkLoadbalancer_Next 252151534 4.746 ns/op 0 B/op 0 allocs/op
BenchmarkLoadbalancer_Next-2 254281032 4.758 ns/op 0 B/op 0 allocs/op
BenchmarkLoadbalancer_Next-4 253424396 4.738 ns/op 0 B/op 0 allocs/op
BenchmarkLoadbalancer_Next-8 254842484 4.752 ns/op 0 B/op 0 allocs/op
BenchmarkLoadbalancer_Next-16 247016046 4.785 ns/op 0 B/op 0 allocs/op
BenchmarkLoadbalancer_Next-32 250539441 4.774 ns/op 0 B/op 0 allocs/op
```
## Index
- [type Loadbalancer](<#Loadbalancer>)
- [func NewLoadbalancer\[T any\]\(items \[\]T\) \*Loadbalancer\[T\]](<#NewLoadbalancer>)
- [func \(l \*Loadbalancer\[T\]\) AddItems\(items ...T\)](<#Loadbalancer[T].AddItems>)
- [func \(l \*Loadbalancer\[T\]\) Current\(\) T](<#Loadbalancer[T].Current>)
- [func \(l \*Loadbalancer\[T\]\) Next\(\) T](<#Loadbalancer[T].Next>)
- [func \(l \*Loadbalancer\[T\]\) Reset\(\)](<#Loadbalancer[T].Reset>)
Loadbalancer is a simple, generic and thread\-safe round\-robin load balancer for Go.
```go
type Loadbalancer[T any] struct {
Items []T
// contains filtered or unexported fields
}
```
Example (Demo)
```go
package main
import (
"atomicgo.dev/robin"
"fmt"
)
type Person struct {
Name string
}
func main() {
people := []Person{
{Name: "person1"},
{Name: "person2"},
{Name: "person3"},
{Name: "person4"},
{Name: "person5"},
}
lb := robin.NewLoadbalancer(people)
for i := 0; i < 10; i++ {
fmt.Println(lb.Next().Name)
}
}
```
#### Output
```
person1
person2
person3
person4
person5
person1
person2
person3
person4
person5
```
```go
func NewLoadbalancer[T any](items []T) *Loadbalancer[T]
```
NewLoadbalancer creates a new Loadbalancer. It is guaranteed that two concurrent calls to Loadbalancer.Next will not return the same item, if the slice contains more than one item.
Example
```go
package main
import (
"atomicgo.dev/robin"
"fmt"
)
func main() {
set := []string{"object1", "object2", "object3"}
lb := robin.NewLoadbalancer(set)
fmt.Println(lb.Current())
}
```
#### Output
```
object1
```
### func \(\*Loadbalancer\[T\]\) [AddItems]()
```go
func (l *Loadbalancer[T]) AddItems(items ...T)
```
AddItems adds items to the Loadbalancer.
Example
```go
package main
import (
"atomicgo.dev/robin"
"fmt"
)
func main() {
set := []int{1, 2, 3}
lb := robin.NewLoadbalancer(set)
lb.AddItems(4, 5, 6)
fmt.Println(lb.Items)
}
```
#### Output
```
[1 2 3 4 5 6]
```
### func \(\*Loadbalancer\[T\]\) [Current]()
```go
func (l *Loadbalancer[T]) Current() T
```
Current returns the current item in the slice, without advancing the Loadbalancer.
Example
```go
package main
import (
"atomicgo.dev/robin"
"fmt"
)
func main() {
set := []int{1, 2, 3}
lb := robin.NewLoadbalancer(set)
fmt.Println(lb.Current())
}
```
#### Output
```
1
```
### func \(\*Loadbalancer\[T\]\) [Next]()
```go
func (l *Loadbalancer[T]) Next() T
```
Next returns the next item in the slice. When the end of the slice is reached, it starts again from the beginning.
Example
```go
package main
import (
"atomicgo.dev/robin"
"fmt"
)
func main() {
set := []int{1, 2, 3}
lb := robin.NewLoadbalancer(set)
for i := 0; i < 10; i++ {
fmt.Println(lb.Next())
}
}
```
#### Output
```
1
2
3
1
2
3
1
2
3
1
```
### func \(\*Loadbalancer\[T\]\) [Reset]()
```go
func (l *Loadbalancer[T]) Reset()
```
Reset resets the Loadbalancer to its initial state.
Example
```go
package main
import (
"atomicgo.dev/robin"
"fmt"
)
func main() {
set := []int{1, 2, 3, 4, 5, 6}
lb := robin.NewLoadbalancer(set)
lb.Next()
lb.Next()
lb.Next()
lb.Reset()
fmt.Println(lb.Current())
}
```
#### Output
```
1
```
Generated by [gomarkdoc]()
---
> [AtomicGo.dev](https://atomicgo.dev) ·
> with ❤️ by [@MarvinJWendt](https://github.com/MarvinJWendt) |
> [MarvinJWendt.com](https://marvinjwendt.com)