golang线程池ants四种使用方法小结

var (
	// ErrLackPoolFunc will be returned when invokers don't provide function for pool.
	ErrLackPoolFunc = errors.New("must provide function for pool")

	// ErrInvalidPoolExpiry will be returned when setting a negative number as the periodic duration to purge goroutines.
	ErrInvalidPoolExpiry = errors.New("invalid expiry for pool")

	// ErrPoolClosed will be returned when submitting task to a closed pool.
	ErrPoolClosed = errors.New("this pool has been closed")

	// ErrPoolOverload will be returned when the pool is full and no workers available.
	ErrPoolOverload = errors.New("too many goroutines blocked on submit or Nonblocking is set")

	// ErrInvalidPreAllocSize will be returned when trying to set up a negative capacity under PreAlloc mode.
	ErrInvalidPreAllocSize = errors.New("can not set up a negative capacity under PreAlloc mode")

	// ErrTimeout will be returned after the operations timed out.
	ErrTimeout = errors.New("operation timed out")

	// ErrInvalidPoolIndex will be returned when trying to retrieve a pool with an invalid index.
	ErrInvalidPoolIndex = errors.New("invalid pool index")

	// ErrInvalidLoadBalancingStrategy will be returned when trying to create a MultiPool with an invalid load-balancing strategy.
	ErrInvalidLoadBalancingStrategy = errors.New("invalid load-balancing strategy")

	// workerChanCap determines whether the channel of a worker should be a buffered channel
	// to get the best performance. Inspired by fasthttp at
	// https://github.com/valyala/fasthttp/blob/master/workerpool.go#L139
	workerChanCap = func() int {
		// Use blocking channel if GOMAXPROCS=1.
		// This switches context from sender to receiver immediately,
		// which results in higher performance (under go1.5 at least).
		if runtime.GOMAXPROCS(0) == 1 {
			return 0
		}

		// Use non-blocking workerChan if GOMAXPROCS>1,
		// since otherwise the sender might be dragged down if the receiver is CPU-bound.
		return 1
	}()

	// log.Lmsgprefix is not available in go1.13, just make an identical value for it.
	logLmsgprefix = 64
	defaultLogger = Logger(log.New(os.Stderr, "[ants]: ", log.LstdFlags|logLmsgprefix|log.Lmicroseconds))

	// Init an instance pool when importing ants.
	defaultAntsPool, _ = NewPool(DefaultAntsPoolSize)
)

package main

import (
	"fmt"
	"sync"
	"time"

	"github.com/panjf2000/ants/v2"
)

func add(d int) {
	sum := 0
	for i := 0; i < d; i++ {
		sum += i
	}
}
func main() {
	var wg sync.WaitGroup
	now := time.Now()
	for i := 0; i < 5; i++ {
		wg.Add(1)
		ants.Submit(func() {
			add(10000000000)
			wg.Done()
		})
	}
	wg.Wait()
	fmt.Println(time.Since(now))
	now = time.Now()
	for i := 0; i < 5; i++ {
		add(10000000000)
	}
	fmt.Println(time.Since(now))
}

p, _ := ants.NewPool(5)

package main

import (
	"fmt"
	"sync"
	"time"

	"github.com/panjf2000/ants/v2"
)

func add(d int) {
	sum := 0
	for i := 0; i < d; i++ {
		sum += i
	}
}
func main() {
	var wg sync.WaitGroup
	now := time.Now()
	p, _ := ants.NewPool(5)
	for i := 0; i < 5; i++ {
		wg.Add(1)
		p.Submit(func() {
			add(10000000000)
			wg.Done()
		})
	}
	wg.Wait()
	fmt.Println("协程池运行：", time.Since(now))
	now = time.Now()
	for i := 0; i < 5; i++ {
		add(10000000000)
	}
	fmt.Println("循环运行：", time.Since(now))
}

package main

import (
	"fmt"
	"sync"
	"time"

	"github.com/panjf2000/ants/v2"
)

func add(d int) {
	sum := 0
	for i := 0; i < d; i++ {
		sum += i
	}
	fmt.Println("the sum is: ", sum)
}
func main() {
	var wg sync.WaitGroup
	now := time.Now()
	p, _ := ants.NewPoolWithFunc(5, func(i interface{}) {
		add(i.(int))
		wg.Done()
	})
	for i := 0; i < 5; i++ {
		wg.Add(1)
		p.Invoke(1000000000)
	}
	wg.Wait()
	fmt.Println("循环运行：", time.Since(now))
}

package main
import (
	"fmt"
	"sync"
	"time"
	"github.com/panjf2000/ants/v2"
)
func add(d int) {
	sum := 0
	for i := 0; i < d; i++ {
		sum += i
	}
	fmt.Println("the sum is: ", sum)
}
func main() {
	var wg sync.WaitGroup
	runTimes := 20
	now := time.Now()
	mpf, _ := ants.NewMultiPoolWithFunc(10, runTimes/10, func(i interface{}) {
		add(i.(int))
		wg.Done()
	}, ants.LeastTasks)
	for i := 0; i < runTimes; i++ {
		wg.Add(1)
		mpf.Invoke(1000000000)
	}
	wg.Wait()
	fmt.Println("循环运行：", time.Since(now))
}