गो ants का परिचय
ants एक उच्च प्रदर्शन गोरूटीन पूल है जो एक बड़े संख्या में गोरूटीनों के अनुसूचीबद्ध और प्रबंधन को कार्यान्वयन करता है, संसाधनों की सीमा और पुनःप्रयोग की अनुमति देता है, जिससे कारल्पनिक प्रोग्राम विकसित करते समय कार्यों के अधिक दक्ष प्रवर्तन को साधारण प्राप्त किया जा सकता है।
विशेषताएँ
- स्वचालित रूप से एक विशाल संख्या के गोरूटीनों को अनुसूचीबद्ध करें और उन्हें पुनःप्रयोग करें।
- समय-समय पर समाप्त हो जाने वाले गोरूटीनों को संसाधनों को और बचाने के लिए नियमित रूप से साफ करें।
- उपयोगी इंटरफेस की बड़ी संख्या प्रदान करता है: कार्य प्रस्तुति, चल रहे गोरूटीनों की संख्या प्राप्त करना, पूल का आकार नामकरण करना, पूल को छोड़ना और पुनःप्रारंभ करना।
- प्रोग्राम की क्रेश होने से बचाने के लिए पैनिक ग्रेसफुली संबोधित करें।
- संसाधन पुनःप्रयोग मेमोरी उपयोग को बड़ी हद बचाता है। बड़े पैमाने पर बैच समकालिक कार्यों के संदर्भ में, यह मूल रूप से गोरूटीन समकालिकता से उच्च प्रदर्शन प्रदान करता है।
- गैर-अवरोधी मेकेनिज़म।
ants कैसे काम करता है
प्रवाह चार्ट
एनिमेटेड इमेजेस
स्थापना
ants v1 संस्करण का उपयोग करें:
go get -u github.com/panjf2000/ants
ants v2 संस्करण का उपयोग करें (GO111MODULE=on सक्षम करें भविष्य):
go get -u github.com/panjf2000/ants/v2
उपयोग
जब एक गो समकालीन प्रोग्राम लिखते हैं जो एक बड़े संख्यामें गोरूटीनों को प्रस्थापित करता है, तो निर्विवादी रूप से इसमें सिस्टम संसाधन (मेमोरी, CPU) का बड़ा हिस्सा अवशोषित करना पड़ता है। ants का उपयोग करके, आप गोरूटीन पूल को निर्माण कर संसाधनों को पुनःप्रयोग करके संसाधनों की बचत कर सकते हैं और प्रदर्शन को सुधार सकते हैं।
package main
import (
"fmt"
"sync"
"sync/atomic"
"time"
"github.com/panjf2000/ants/v2"
)
var sum int32
func myFunc(i interface{}) {
n := i.(int32)
atomic.AddInt32(&sum, n)
fmt.Printf("दौड़ें %d के साथ\n", n)
}
func demoFunc() {
time.Sleep(10 * time.Millisecond)
fmt.Println("नमस्ते दुनिया!")
}
func main() {
defer ants.Release()
runTimes := 1000
// सामान्य पूल का उपयोग करें।
var wg sync.WaitGroup
syncCalculateSum := func() {
demoFunc()
wg.Done()
}
for i := 0; i < runTimes; i++ {
wg.Add(1)
_ = ants.Submit(syncCalculateSum)
}
wg.Wait()
fmt.Printf("चल रहे गोरूटीन: %d\n", ants.Running())
fmt.Printf("सभी कार्यों को समाप्त करें।\n")
// एक फ़ंक्शन के साथ पूल का उपयोग करें,
// गोरूटीन पूल की क्षमता और समय समाप्त होने के लिए 10 और 1 सेकंड को सेट करें।
p, _ := ants.NewPoolWithFunc(10, func(i interface{}) {
myFunc(i)
wg.Done()
})
defer p.Release()
// कार्यों को एक-एक करके प्रस्तुत करें।
for i := 0; i < runTimes; i++ {
wg.Add(1)
_ = p.Invoke(int32(i))
}
wg.Wait()
fmt.Printf("चल रहे गोरूटीन: %d\n", p.Running())
fmt.Printf("सभी कार्यों को समाप्त करें, परिणाम है %d\n", sum)
}
पूल कॉन्फ़िगरेशन
// Option पर्वदाता को प्रतिकरण करता है।
type Option func(opts *Options)
// Options उन सभी विकल्पों को शामिल करता है जो एक एंट्स पूल को निर्माण करते समय लागू किए जाएंगे।
type Options struct {
// ExpiryDuration एक सवेंजर गोरूटीन के लिए अवधि है जो समय से पहले समाप्त हो गए कर्मचारियों को साफ करने के लिए है,
// सवेंजर `ExpiryDuration` में हर कर्मचारी की पूरी जांच करता है और उन कर्मचारियों को साफ करता है जो `ExpiryDuration` से अधिक समय के लंबित रह गए हैं।
ExpiryDuration time.Duration
// PreAlloc इसका संकेत देता है कि पूल को आरंभ करते समय मेमोरी पूर्व-आबंश करने की आवश्यकता है या नहीं।
PreAlloc bool
// Pool.Submit पर ब्लॉक हो रही गोरूटीन की अधिकतम संख्या।
// 0 (डिफ़ॉल्ट मूल्य) का मतलब है कि इस प्रकार की कोई प्रतिबंधितता नहीं है।
MaxBlockingTasks int
// जब Nonblocking सत्य है, Pool.Submit कभी भी ब्लॉक नहीं होगा।
// जब Pool.Submit एक ही समय में नहीं किया जा सकता है, तो ErrPoolOverload वापस किया जाएगा।
// Nonblocking सत्य होने पर, MaxBlockingTasks कार्यरत नहीं होता है।
Nonblocking bool
// PanicHandler को हर कर्मचारी गोरूटीन से पैनिक संहिता करने के लिए उपयोग किया जाता है।
// अगर फ़ालसा है, तो कर्मचारी गोरूटीन से फिर से पैनिक बसाया जाएगा।
PanicHandler func(interface{})
// Logger लॉग जानकारी के लिए अनुकूलित लॉगर है, अगर यह सेट नहीं है,
// तो डिफ़ॉल्ट मानक लॉगर से उपयोग किया जाता है।
Logger Logger
}
// WithOptions पूरे विकल्प कॉन्फ़िग स्वीकार करता है।
func WithOptions(options Options) Option {
return func(opts *Options) {
*opts = options
}
}
// WithExpiryDuration साफ करने की अंतराल समय को सेट करता है।
func WithExpiryDuration(expiryDuration time.Duration) Option {
return func(opts *Options) {
opts.ExpiryDuration = expiryDuration
}
}
// WithPreAlloc संकेत देता है कि क्या इसे कार्यकर्ताओं के लिए मेमोरी मेजबानी जानी चाहिए।
func WithPreAlloc(preAlloc bool) Option {
return func(opts *Options) {
opts.PreAlloc = preAlloc
}
}
// WithMaxBlockingTasks की संख्या सेट करता है जब पूल क्षमता तक पहुँचता है।
func WithMaxBlockingTasks(maxBlockingTasks int) Option {
return func(opts *Options) {
opts.MaxBlockingTasks = maxBlockingTasks
}
}
// WithNonblocking संकेत करता है कि जब उपलब्ध कार्यकर्ता नहीं होते हैं, तो पूल शून्य लौटाएगा।
func WithNonblocking(nonblocking bool) Option {
return func(opts *Options) {
opts.Nonblocking = nonblocking
}
}
// WithPanicHandler पैनिक हैंडलर सेट करता है।
func WithPanicHandler(panicHandler func(interface{})) Option {
return func(opts *Options) {
opts.PanicHandler = panicHandler
}
}
// WithLogger एक अनुकूलित लॉगर सेट करता है।
func WithLogger(logger Logger) Option {
return func(opts *Options) {
opts.Logger = logger
}
}
NewPool/NewPoolWithFunc को बुलाते समय विभिन्न वैकल्पिक समारोहों का उपयोग करके ants.Options में प्रत्येक कॉन्फ़िगरेशन आइटम के मान सेट किए जा सकते हैं, और फिर इसे गोरूटीन पूल कॉस्टमाइज़ करने के लिए उपयोग किया जा सकता है।
कस्टम पूल
ants एक विशिष्ट पूल क्षमता के साथ उपयोगकर्ता का खुद का पूल निर्माण का समर्थन करता है; NewPool मेथड को बुलाकर, निम्नलिखित क्षमता के साथ नया पूल निर्मित किया जा सकता है:
p, _ := ants.NewPool(10000)
कार्य सबमिशन
कार्य सबमिट करने के लिए ants.Submit(func()) मेथड को बुलाया जाता है:
ants.Submit(func(){})
गोरूटीन पूल क्षमता को गतिशील रूप से समायोजित करना
गोरूटीन पूल क्षमता को गतिशील रूप से समायोजित करने के लिए, आप Tune(int) मेथड का उपयोग कर सकते हैं:
pool.Tune(1000) // इसकी क्षमता को 1000 करें
pool.Tune(100000) // इसकी क्षमता को 100000 करें
यह मेथड संदर्भ सुरक्षित है।
गोरूटीन क्यू मेमोरी का पूर्व-मेमोरी आबंश
ants आपको पूरे पूल के लिए मेमोरी पूर्व-आबंश करने की अनुमति देता है, जो कि कुछ विशिष्ट परिस्थितियों में गोरूटीन पूल के प्रदर्शन में सुधार कर सकता है। उदाहरण के लिए, जहां एक बहुत बड़ी क्षमता वाले पूल की आवश्यकता होती है और हर गोरूटीन का कार्य समय-ग्रहणी होता है, गोरूटीन कतार के लिए मेमोरी का पूर्व-आबंश करना अनावश्यक मेमोरी पुनर्निर्देशन को कम करेगा।
// जब आप इस फ़ंक्शन को बुलाते हैं, तो एंट्स पूल की पूरी क्षमता को पूर्वर्खित करेगा
p, _ := ants.NewPool(100000, ants.WithPreAlloc(true))
पूल रिलीज करें
pool.Release()
पूल को पुनः प्रारंभ करें
// Reboot() मेथड को बुलाकर, आप पहले से नष्ट हो चुके एक पूल को पुनः सक्रिय कर सकते हैं और इसे पुनः प्रयोग में ला सकते हैं।
pool.Reboot()
कार्य निष्पादन क्रम के बारे में
ants न केवल किसी विशेष क्रम की निष्पादन की गारंटी नहीं देता है, बल्कि निष्पादन क्रम को निश्चित रूप से संकेतित नहीं करता है। यह इसलिए है क्योंकि ants सभी प्रस्तुत कार्यों की समकालिक रूप से प्रक्रिया करता है, और कार्यों को समकालिक रूप से चल रहे कर्मचारियों को सौंप दिया जाएगा, जिससे कार्यों को समकालिक और अनिश्चित क्रम में निष्पादित किया जाएगा।