sync.Pool

Author: naeemaei

15-Concurrency/08-Pool/01-ConnectionPool/go.mod

@@ -0,0 +1,3 @@
+module pool
+
+go 1.18

15-Concurrency/08-Pool/01-ConnectionPool/main.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+"fmt"
+"sync"
+)
+
+type DbConnection struct {
+Host string
+DbName string
+User string
+Password string
+}
+
+var connectionPool sync.Pool = sync.Pool{
+New: func() interface{} {
+return &DbConnection{
+Host: "localhost",
+DbName: "test",
+User: "root",
+Password: "root",
+}
+},
+}
+
+func main() {
+
+connection := connectionPool.Get().(*DbConnection)
+
+fmt.Printf("%v\n", connection)
+
+connectionPool.Put(connection)
+
+connection = connectionPool.Get().(*DbConnection)
+
+fmt.Printf("%v\n", connection)
+
+connectionPool.Put(connection)
+
+}

15-Concurrency/08-Pool/01-ConnectionPool/main_test.go

@@ -0,0 +1,35 @@
+package main
+
+import "testing"
+
+func BenchmarkWithoutPool(b *testing.B) {
+var connection *DbConnection
+b.ReportAllocs()
+b.ResetTimer()
+for i := 0; i < b.N; i++ {
+for i := 0; i < 10000; i++ {
+connection = &DbConnection{
+Host: "localhost",
+DbName: "test",
+User: "root",
+Password: "root",
+}
+
+connection.DbName = "test"
+}
+}
+
+}
+
+func BenchmarkWithPool(b *testing.B) {
+var connection *DbConnection
+b.ReportAllocs()
+b.ResetTimer()
+for i := 0; i < b.N; i++ {
+for i := 0; i < 10000; i++ {
+connection = connectionPool.Get().(*DbConnection)
+connection.DbName = "test"
+connectionPool.Put(connection)
+}
+}
+}

15-Concurrency/08-Pool/02-Examples/go.mod

@@ -0,0 +1,3 @@
+module poolExample
+
+go 1.18

15-Concurrency/08-Pool/02-Examples/main.go

@@ -0,0 +1,10 @@
+// https://medium.com/swlh/go-the-idea-behind-sync-pool-32da5089df72
+
+package main
+
+func main() {
+//RunMemoryUsageExample()
+RunNonBufferPoolExample()
+//RunBufferPoolExample()
+
+}

15-Concurrency/08-Pool/02-Examples/memoryStatus.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+"fmt"
+"runtime"
+"time"
+)
+
+func RunMemoryUsageExample() {
+
+// Below is an example of using our PrintMemUsage() function
+// Print our starting memory usage (should be around 0mb)
+PrintMemUsage()
+
+var overall [][]int
+for i := 0; i < 4; i++ {
+
+// Allocate memory using make() and append to overall (so it doesn't get
+// garbage collected). This is to create an ever increasing memory usage
+// which we can track. We're just using []int as an example.
+a := make([]int, 0, 999999)
+overall = append(overall, a)
+
+// Print our memory usage at each interval
+PrintMemUsage()
+time.Sleep(time.Second)
+}
+
+// Clear our memory and print usage, unless the GC has run 'Alloc' will remain the same
+overall = nil
+PrintMemUsage()
+
+// Force GC to clear up, should see a memory drop
+runtime.GC()
+PrintMemUsage()
+
+}
+
+func PrintMemUsage() {
+var m runtime.MemStats
+runtime.ReadMemStats(&m)
+// For info on each, see: https://golang.org/pkg/runtime/#MemStats
+fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
+fmt.Printf("\tTotalAlloc = %v MiB", bToMb(m.TotalAlloc))
+fmt.Printf("\tSys = %v MiB", bToMb(m.Sys))
+fmt.Printf("\tNumGC = %v\n", m.NumGC)
+}
+
+func bToMb(b uint64) uint64 {
+return b / 1024 / 1024
+}

15-Concurrency/08-Pool/02-Examples/poolExample.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+"bytes"
+"sync"
+)
+
+var data = make([]byte, 10000)
+
+var pool = sync.Pool{
+New: func() interface{} {
+return &bytes.Buffer{}
+},
+}
+
+func RunBufferPoolExample() {
+
+PrintMemUsage()
+for i := 0; i < 10_000; i++ {
+UseBufferWithPool()
+}
+//runtime.GC()
+PrintMemUsage()
+
+}
+
+func UseBufferWithPool() {
+buf := pool.Get().(*bytes.Buffer)
+buf.Write(data)
+buf.Reset()
+pool.Put(buf)
+}
+
+func UseBuffer() {
+var buf bytes.Buffer
+buf.Write(data)
+}
+
+func RunNonBufferPoolExample() {
+
+PrintMemUsage()
+for i := 0; i < 10_000; i++ {
+UseBuffer()
+}
+//runtime.GC()
+PrintMemUsage()
+
+}

15-Concurrency/08-Pool/02-Examples/poolExample_test.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+"sync"
+"testing"
+)
+
+type DbConnection struct {
+DbName string
+UserId string
+Password string
+Timeout int
+}
+
+var connectionPool = sync.Pool{
+New: func() any {
+return &DbConnection{
+DbName: "DbTest",
+UserId: "UserTest",
+Password: "PasswordTest",
+Timeout: 20,
+}
+},
+}
+
+func BenchmarkWithoutPool(b *testing.B) {
+var p *DbConnection
+b.ReportAllocs()
+b.ResetTimer()
+for i := 0; i < b.N; i++ {
+for j := 0; j < 10000; j++ {
+p = &DbConnection{}
+p.Timeout = 45
+}
+}
+}
+
+func BenchmarkWithPool(b *testing.B) {
+var p *DbConnection
+b.ReportAllocs()
+b.ResetTimer()
+for i := 0; i < b.N; i++ {
+for j := 0; j < 10000; j++ {
+p = connectionPool.Get().(*DbConnection)
+
+connectionPool.Put(p)
+}
+}
+}