Zaplanowane zadania odpytywania Przejdź

Question

Pisałem jakiś kod, który będzie jednocześnie odpytywania adresów URL co 30 minut:

func (obj * MyObj) Poll() { 
    for ;; { 
     for _, url := range obj.UrlList { 
      //Download the current contents of the URL and do something with it 
     } 
     time.Sleep(30 * time.Minute) 
} 

//Start the routine in another function 
go obj.Poll() 

Jak bym następnie dodać do obj.UrlList gdzie indziej w kodzie i upewnić się, że następnym razem, adresy URL są sondowane, że UrlList w Gromadzie ankiety również zostały zaktualizowane i jako takie będą również odpytywać nowy adres URL?

Rozumiem, że pamięć jest dzielona przez komunikowanie się, a nie odwrotnie w Go. Badałem kanały, ale nie jestem pewien, jak je zaimplementować w tym przykładzie.

Answer 1

Oto niesprawdzone, ale bezpieczny model okresowo pobierając kilka adresów z możliwością dynamicznie dodać nowe adresy URL do listy adresów URL bezpiecznie. Dla czytelnika powinno być oczywiste, co będzie konieczne, jeśli chcesz usunąć adres URL.

type harvester struct { 
    ticker *time.Ticker // periodic ticker 
    add chan string // new URL channel 
    urls []string  // current URLs 
} 

func newHarvester() *harvester { 
    rv := &harvester{ 
     ticker: time.NewTicker(time.Minute * 30), 
     add: make(chan string), 
    } 
    go rv.run() 
    return rv 
} 

func (h *harvester) run() { 
    for { 
     select { 
     case <-h.ticker.C: 
      // When the ticker fires, it's time to harvest 
      for _, u := range h.urls { 
       harvest(u) 
      } 
     case u := <-h.add: 
      // At any time (other than when we're harvesting), 
      // we can process a request to add a new URL 
      h.urls = append(h.urls, u) 
     } 
    } 
} 

func (h *harvester) AddURL(u string) { 
    // Adding a new URL is as simple as tossing it onto a channel. 
    h.add <- u 
} 

Answer 2

// Type with queue through a channel. 
type MyType struct { 
    queue chan []*net.URL 
} 

func (t *MyType) poll() { 
    for urls := range t.queue { 
     ... 
     time.Sleep(30 * time.Minute) 
    } 
} 

// Create instance with buffered queue. 
t := MyType{make(chan []*net.URL, 25)} 

go t.Poll() 

Answer 3

Jeśli trzeba odpytywać w regularnych odstępach czasu, to nie użytku time.Sleep ale time.Ticker zamiast (lub krewnego jak time.After) powinno. Powodem jest to, że sen to tylko sen i nie uwzględnia dryfu z powodu prawdziwej pracy, którą wykonałeś w swojej pętli. Odwrotnie, Ticker ma oddzielną goroutine i kanał, które razem są w stanie wysyłać ci regularne wydarzenia, a przez to powodować coś przydatnego do wykonania.

Oto przykład podobny do twojego. Wprowadzam losowy jitter, aby zilustrować korzyści z używania Ticker'a.

package main 

import (
    "fmt" 
    "time" 
    "math/rand" 
) 

func Poll() { 
    r := rand.New(rand.NewSource(99)) 
    c := time.Tick(10 * time.Second) 
    for _ = range c { 
     //Download the current contents of the URL and do something with it 
     fmt.Printf("Grab at %s\n", time.Now()) 
     // add a bit of jitter 
     jitter := time.Duration(r.Int31n(5000)) * time.Millisecond 
     time.Sleep(jitter) 
    } 
} 

func main() { 
    //go obj.Poll() 
    Poll() 
} 

Po uruchomieniu tego stwierdziłem, że pomimo jittera utrzymywał się w ścisłym 10-sekundowym cyklu.