N चैनल कैसे सुने? (गतिशील चयन कथन)


116

दो goroutines निष्पादित करने का एक अंतहीन लूप शुरू करने के लिए, मैं नीचे दिए गए कोड का उपयोग कर सकता हूं:

संदेश प्राप्त करने के बाद यह एक नया गोरोइन शुरू करेगा और हमेशा के लिए चला जाएगा।

c1 := make(chan string)
c2 := make(chan string)

go DoStuff(c1, 5)
go DoStuff(c2, 2)

for ; true;  {
    select {
    case msg1 := <-c1:
        fmt.Println("received ", msg1)
        go DoStuff(c1, 1)
    case msg2 := <-c2:
        fmt.Println("received ", msg2)
        go DoStuff(c2, 9)
    }
}

मैं अब एन गोरॉटिंस के लिए समान व्यवहार करना चाहूंगा, लेकिन उस मामले में चयन विवरण कैसे दिखाई देगा?

यह वह कोड बिट है जिसे मैंने शुरू किया है, लेकिन मैं उलझन में हूं कि चयन कथन को कैसे कोडित किया जाए

numChans := 2

//I keep the channels in this slice, and want to "loop" over them in the select statemnt
var chans = [] chan string{}

for i:=0;i<numChans;i++{
    tmp := make(chan string);
    chans = append(chans, tmp);
    go DoStuff(tmp, i + 1)

//How shall the select statment be coded for this case?  
for ; true;  {
    select {
    case msg1 := <-c1:
        fmt.Println("received ", msg1)
        go DoStuff(c1, 1)
    case msg2 := <-c2:
        fmt.Println("received ", msg2)
        go DoStuff(c2, 9)
    }
}

4
मुझे लगता है कि आप जो चाहते हैं वह चैनल मल्टीप्लेक्सिंग है। golang.org/doc/effective_go.html#chan_of_chan मूल रूप से, आपके पास एक एकल चैनल है जिसे आप सुनते हैं और फिर कई बाल चैनल हैं जो मुख्य चैनल में फ़नल करते हैं। संबंधित SO प्रश्न: stackoverflow.com/questions/10979608/…
ब्रेंडेन

जवाबों:


152

आप इसे रिफ्लेक्ट पैकेज Selectसे फ़ंक्शन का उपयोग करके कर सकते हैं :

func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool)

चयन मामलों की सूची द्वारा वर्णित एक चुनिंदा ऑपरेशन को निष्पादित करता है। गो सेलेक्ट स्टेटमेंट की तरह, यह तब तक ब्लॉक होता है जब तक कि कम से कम एक मामला आगे नहीं बढ़ सकता, एक समान छद्म यादृच्छिक विकल्प बनाता है, और फिर उस मामले को निष्पादित करता है। यह चुने हुए मामले के सूचकांक को लौटाता है और, यदि वह मामला एक प्राप्त ऑपरेशन था, तो प्राप्त मूल्य और एक बूलियन यह दर्शाता है कि क्या मूल्य चैनल पर भेजे जाने से मेल खाता है (जैसा कि चैनल बंद होने पर प्राप्त शून्य मान के विपरीत)।

आप एक ऐसी SelectCaseसंरचना की श्रेणी में आते हैं जो चैनल को चुनने के लिए पहचानती है, ऑपरेशन की दिशा, और भेजने के संचालन के मामले में भेजने के लिए एक मूल्य।

तो आप ऐसा कुछ कर सकते हैं:

cases := make([]reflect.SelectCase, len(chans))
for i, ch := range chans {
    cases[i] = reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(ch)}
}
chosen, value, ok := reflect.Select(cases)
// ok will be true if the channel has not been closed.
ch := chans[chosen]
msg := value.String()

आप यहां एक और fleshed उदाहरण के साथ प्रयोग कर सकते हैं: http://play.golang.org/p/8zwvSk4kxx


4
क्या ऐसे चयन में मामलों की संख्या के लिए एक व्यावहारिक सीमा है? एक है कि यदि आप इससे परे जाते हैं, तो प्रदर्शन गंभीर रूप से प्रभावित होता है?
मैक्सिम व्लादिमीरस्की

4
हो सकता है कि यह मेरी अक्षमता हो, लेकिन जब आप चैनल के माध्यम से जटिल संरचनाएँ भेज रहे हैं और प्राप्त कर रहे हैं, तो मुझे यह पैटर्न वास्तव में कठिन लगता है। टिम अल्क्लेयर ने कहा कि एक साझा "एग्रीगेट" चैनल पास करना, मेरे मामले में बहुत आसान था।
बोरा एम। एल्पर

90

आप प्रत्येक चैनल को एक गोरोइन में लपेटकर इसे पूरा कर सकते हैं जो एक साझा "कुल" चैनल को "फॉरवर्ड" संदेश देता है। उदाहरण के लिए:

agg := make(chan string)
for _, ch := range chans {
  go func(c chan string) {
    for msg := range c {
      agg <- msg
    }
  }(ch)
}

select {
case msg <- agg:
    fmt.Println("received ", msg)
}

यदि आपको यह जानने की आवश्यकता है कि संदेश किस चैनल से उत्पन्न हुआ है, तो आप इसे समग्र चैनल पर अग्रेषित करने से पहले किसी भी अतिरिक्त जानकारी के साथ एक संरचना में लपेट सकते हैं।

मेरे (सीमित) परीक्षण में, यह विधि परावर्तित पैकेज का उपयोग करके बहुत अच्छा करती है:

$ go test dynamic_select_test.go -test.bench=.
...
BenchmarkReflectSelect         1    5265109013 ns/op
BenchmarkGoSelect             20      81911344 ns/op
ok      command-line-arguments  9.463s

यहां बेंचमार्क कोड


2
आपका बेंचमार्क कोड गलत है, आपको बेंचमार्क के भीतर लूप करने कीb.N जरूरत है । अन्यथा परिणाम (जो b.Nआपके आउटपुट में 1 और 2000000000 से विभाजित हैं ) पूरी तरह से अर्थहीन होंगे।
डेव सी।

2
@DaveC धन्यवाद! निष्कर्ष नहीं बदलता है, लेकिन परिणाम बहुत अधिक समझदार हैं।
टिम अखलाक

1
वास्तव में, मैंने कुछ वास्तविक संख्या प्राप्त करने के लिए आपके बेंचमार्क कोड पर एक त्वरित हैक किया । इस बेंचमार्क से बहुत अच्छी तरह से कुछ अभी भी गायब / गलत हो सकता है, लेकिन इसके लिए केवल अधिक जटिल प्रतिबिंबित कोड है जो केवल एक चीज है, वह यह है कि सेटअप तेज है (GOMAXPROCS = 1 के साथ) क्योंकि इसमें गोरोइनटस के एक गुच्छा की आवश्यकता नहीं है। हर दूसरे मामले में एक सरल गोरोइनट मर्जिंग चैनल परावर्तित समाधान (परिमाण के ~ 2 आदेशों) से उड़ जाता है।
डेव सी।

2
एक महत्वपूर्ण नकारात्मक पक्ष ( reflect.Selectदृष्टिकोण की तुलना में ) यह है कि प्रत्येक चैनल पर न्यूनतम एकल मान पर मर्जिंग बफर करने वाले गोरआउट्स का विलय किया जाता है। आमतौर पर यह एक समस्या नहीं होगी लेकिन कुछ विशिष्ट अनुप्रयोगों में जो एक सौदा ब्रेकर हो सकता है :(?
डेव सी।

1
एक बफ़र मर्ज चैनल समस्या को बदतर बनाता है। मुद्दा यह है कि केवल प्रतिबिंबित समाधान में पूरी तरह से बिना बफर वाले शब्दार्थ हो सकते हैं। मैंने आगे बढ़कर परीक्षण कोड पोस्ट किया है जिसे मैं एक अलग उत्तर के रूप में प्रयोग कर रहा था (उम्मीद है) स्पष्ट करें कि मैं क्या कहना चाह रहा था।
डेव सी।

22

पिछले उत्तरों पर कुछ टिप्पणियों का विस्तार करने के लिए और यहां एक स्पष्ट तुलना प्रदान करने के लिए दोनों दृष्टिकोणों का एक उदाहरण प्रस्तुत किया गया है जो अब तक एक ही इनपुट दिए गए हैं, पढ़ने के लिए चैनलों का एक टुकड़ा और प्रत्येक मान के लिए कॉल करने के लिए एक फ़ंक्शन जिसे भी जानना आवश्यक है, जिसे चैनल मान से आया है।

दृष्टिकोण के बीच तीन मुख्य अंतर हैं:

  • जटिलता। यद्यपि यह आंशिक रूप से एक पाठक की प्राथमिकता हो सकती है लेकिन मुझे लगता है कि चैनल दृष्टिकोण अधिक मुहावरेदार, सीधे-आगे और पठनीय है।

  • प्रदर्शन। मेरे Xeon amd64 सिस्टम पर goroutines + चैनल बाहर परिमाण के दो आदेशों द्वारा परावर्तित समाधान का प्रदर्शन करते हैं (गो में सामान्य प्रतिबिंब अक्सर धीमा होता है और केवल तब उपयोग किया जाना चाहिए जब बिल्कुल आवश्यक हो)। बेशक, अगर परिणाम को संसाधित करने वाले या इनपुट चैनलों के मूल्यों के लेखन में किसी भी तरह की महत्वपूर्ण देरी होती है, तो यह प्रदर्शन अंतर आसानी से महत्वहीन हो सकता है।

  • शब्दार्थ को अवरुद्ध / बफरिंग करना। इसका महत्व उपयोग के मामले पर निर्भर करता है। ज्यादातर यह या तो कोई फर्क नहीं पड़ता या गोरोइन विलय समाधान में मामूली अतिरिक्त बफरिंग थ्रूपुट के लिए सहायक हो सकता है। हालाँकि, यदि शब्दार्थ के लिए यह वांछनीय है कि केवल एक ही लेखक को अनब्लॉक किया जाए और किसी भी अन्य लेखक को अनब्लॉक करने से पहले इसे पूरी तरह से हैंडल किया जाए , तो वह केवल रिफ्लेक्ट सॉल्यूशन के साथ प्राप्त किया जा सकता है।

ध्यान दें, दोनों तरीकों को सरल किया जा सकता है अगर या तो भेजने वाले चैनल की "आईडी" आवश्यक नहीं है या यदि स्रोत चैनल कभी बंद नहीं होंगे।

गोरटाइन विलय चैनल:

// Process1 calls `fn` for each value received from any of the `chans`
// channels. The arguments to `fn` are the index of the channel the
// value came from and the string value. Process1 returns once all the
// channels are closed.
func Process1(chans []<-chan string, fn func(int, string)) {
    // Setup
    type item struct {
        int    // index of which channel this came from
        string // the actual string item
    }
    merged := make(chan item)
    var wg sync.WaitGroup
    wg.Add(len(chans))
    for i, c := range chans {
        go func(i int, c <-chan string) {
            // Reads and buffers a single item from `c` before
            // we even know if we can write to `merged`.
            //
            // Go doesn't provide a way to do something like:
            //     merged <- (<-c)
            // atomically, where we delay the read from `c`
            // until we can write to `merged`. The read from
            // `c` will always happen first (blocking as
            // required) and then we block on `merged` (with
            // either the above or the below syntax making
            // no difference).
            for s := range c {
                merged <- item{i, s}
            }
            // If/when this input channel is closed we just stop
            // writing to the merged channel and via the WaitGroup
            // let it be known there is one fewer channel active.
            wg.Done()
        }(i, c)
    }
    // One extra goroutine to watch for all the merging goroutines to
    // be finished and then close the merged channel.
    go func() {
        wg.Wait()
        close(merged)
    }()

    // "select-like" loop
    for i := range merged {
        // Process each value
        fn(i.int, i.string)
    }
}

प्रतिबिंब चयन:

// Process2 is identical to Process1 except that it uses the reflect
// package to select and read from the input channels which guarantees
// there is only one value "in-flight" (i.e. when `fn` is called only
// a single send on a single channel will have succeeded, the rest will
// be blocked). It is approximately two orders of magnitude slower than
// Process1 (which is still insignificant if their is a significant
// delay between incoming values or if `fn` runs for a significant
// time).
func Process2(chans []<-chan string, fn func(int, string)) {
    // Setup
    cases := make([]reflect.SelectCase, len(chans))
    // `ids` maps the index within cases to the original `chans` index.
    ids := make([]int, len(chans))
    for i, c := range chans {
        cases[i] = reflect.SelectCase{
            Dir:  reflect.SelectRecv,
            Chan: reflect.ValueOf(c),
        }
        ids[i] = i
    }

    // Select loop
    for len(cases) > 0 {
        // A difference here from the merging goroutines is
        // that `v` is the only value "in-flight" that any of
        // the workers have sent. All other workers are blocked
        // trying to send the single value they have calculated
        // where-as the goroutine version reads/buffers a single
        // extra value from each worker.
        i, v, ok := reflect.Select(cases)
        if !ok {
            // Channel cases[i] has been closed, remove it
            // from our slice of cases and update our ids
            // mapping as well.
            cases = append(cases[:i], cases[i+1:]...)
            ids = append(ids[:i], ids[i+1:]...)
            continue
        }

        // Process each value
        fn(ids[i], v.String())
    }
}

[ खेल के मैदान पर पूर्ण कोड ।]


1
यह भी ध्यान देने योग्य है कि goroutines + चैनल समाधान सब कुछ selectया नहीं कर सकता reflect.Selectहै। जब तक वे चैनलों से सब कुछ नहीं लेते हैं, तब तक गोरे लोग घूमते रहेंगे, इसलिए कोई स्पष्ट रास्ता नहीं है जिससे आप Process1जल्दी बाहर निकल सकें । यदि आपके पास कई पाठक हैं, तो समस्याओं के लिए भी संभावना है, क्योंकि गोरोइन्ट्स प्रत्येक चैनल से एक आइटम को बफर करता है, जिसके साथ ऐसा नहीं होगा select
जेम्स हेनस्ट्रिज

@JamesHenstridge, रोकने के बारे में आपका पहला नोट सत्य नहीं है। आप Process1 को रोकने की व्यवस्था करेंगे ठीक उसी तरह जैसे आप Process2 को रोकने की व्यवस्था करेंगे; उदाहरण के लिए एक "स्टॉप" चैनल जोड़ा गया है जो बंद हो गया है जब गोरोइन्ट्स बंद होना चाहिए। Process1 को वर्तमान में उपयोग किए जाने वाले सरल लूप के बजाय लूप के selectभीतर एक दो मामले की आवश्यकता होगी । Process2 को किसी अन्य मामले को चिपकाने की आवश्यकता होगी और उस मूल्य के विशेष हैंडल को । forfor rangecasesi
डेव सी।

यह अभी भी उस समस्या को हल नहीं करता है कि आप उन चैनलों से मान पढ़ रहे हैं जिनका उपयोग स्टॉप अर्ली केस में नहीं किया जाएगा।
जेम्स हेनस्ट्रिज

0

यह दृष्टिकोण यह मानकर काम क्यों नहीं करेगा कि कोई घटनाएँ भेज रहा है?

func main() {
    numChans := 2
    var chans = []chan string{}

    for i := 0; i < numChans; i++ {
        tmp := make(chan string)
        chans = append(chans, tmp)
    }

    for true {
        for i, c := range chans {
            select {
            case x = <-c:
                fmt.Printf("received %d \n", i)
                go DoShit(x, i)
            default: continue
            }
        }
    }
}

8
यह एक स्पिन-लूप है। एक इनपुट चैनल की प्रतीक्षा करते समय एक मान होता है जो उपलब्ध सभी सीपीयू की खपत करता है। के पूरे मुद्दे selectकई चैनलों (एक के बिना पर defaultखंड) है कि यह कुशलता से जब तक कम से कम एक कताई के बिना तैयार है इंतजार कर रहा है है।
डेव सी

0

संभवतः सरल विकल्प:

चैनलों की एक सरणी होने के बजाय, केवल एक चैनल को अलग-अलग गोरआउट्स पर चलाए जा रहे फ़ंक्शंस के पैरामीटर के रूप में पास क्यों नहीं किया जाता है, और फिर उपभोक्ता goroutine में चैनल को सुनें?

यह आपको अपने श्रोता में सिर्फ एक चैनल का चयन करने की अनुमति देता है, एक साधारण चयन के लिए, और कई चैनलों से संदेशों को एकत्रित करने के लिए नए गोरोइटिन के निर्माण से बचता है?

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.