Jak korzystać z basenu goroutine

Question

Chcę używać Go do pobierania arkuszy kalkulacyjnych z cenami z Yahoo Finance. Będę wysyłać żądanie http dla każdego towaru w jego własnej goroutine. Mam listę około 2500 symboli, ale zamiast wykonywać 2500 żądań równolegle, wolę robić 250 na raz. W Javie utworzyłem pulę wątków i ponownie użyłem wątków, gdy będą one darmowe. Próbowałem znaleźć coś podobnego, basen z goroutine, jeśli chcesz, ale nie mogłeś znaleźć żadnych zasobów. Byłbym wdzięczny, gdyby ktoś mógł mi powiedzieć, jak wykonać to zadanie lub wskazać mi zasoby na to samo. Dzięki!

Answer 1

Najprostszym sposobem, jak sądzę, jest stworzenie 250 goroutinów i przekazanie im kanału, za pomocą którego można przekazywać linki od głównej goroutine do dzieci, słuchając tego kanału.

Po przekazaniu wszystkich linków do gorutynów zamyka się kanał, a wszystkie gorutines kończą pracę.

Aby zabezpieczyć się przed główną gorutynką, zanim dzieci przetwarzają dane, można użyć sync.WaitGroup.

Oto kod do zilustrowania (nie ostateczna wersja robocza ale pokazuje punkt), które powiedziałem powyżej:

func worker(linkChan chan string, wg *sync.WaitGroup) { 
    // Decreasing internal counter for wait-group as soon as goroutine finishes 
    defer wg.Done() 

    for url := range linkChan { 
    // Analyze value and do the job here 
    } 
} 

func main() { 
    lCh := make(chan string) 
    wg := new(sync.WaitGroup) 

    // Adding routines to workgroup and running then 
    for i := 0; i < 250; i++ { 
     wg.Add(1) 
     go worker(lCh, wg) 
    } 

    // Processing all links by spreading them to `free` goroutines 
    for _, link := range yourLinksSlice { 
     lCh <- link 
    } 

    // Closing channel (waiting in goroutines won't continue any more) 
    close(lCh) 

    // Waiting for all goroutines to finish (otherwise they die as main routine dies) 
    wg.Wait() 
} 

Answer 2

Można użyć biblioteki implementacji puli wątków w Go z tego git repo

Here jest ładny blog o tym, jak korzystać z kanałów w puli wątków

urywek z bloga

var (
MaxWorker = os.Getenv("MAX_WORKERS") 
MaxQueue = os.Getenv("MAX_QUEUE") 
) 

//Job represents the job to be run 
type Job struct { 
    Payload Payload 
} 

// A buffered channel that we can send work requests on. 
var JobQueue chan Job 

// Worker represents the worker that executes the job 
type Worker struct { 
    WorkerPool chan chan Job 
    JobChannel chan Job 
    quit  chan bool 
} 

func NewWorker(workerPool chan chan Job) Worker { 
    return Worker{ 
     WorkerPool: workerPool, 
     JobChannel: make(chan Job), 
     quit:  make(chan bool)} 
} 

// Start method starts the run loop for the worker, listening for a quit channel in 
// case we need to stop it 
func (w Worker) Start() { 
    go func() { 
     for { 
      // register the current worker into the worker queue. 
      w.WorkerPool <- w.JobChannel 

      select { 
      case job := <-w.JobChannel: 
       // we have received a work request. 
       if err := job.Payload.UploadToS3(); err != nil { 
        log.Errorf("Error uploading to S3: %s", err.Error()) 
       } 

      case <-w.quit: 
       // we have received a signal to stop 
       return 
      } 
     } 
    }() 
} 

// Stop signals the worker to stop listening for work requests. 
func (w Worker) Stop() { 
    go func() { 
     w.quit <- true 
    }() 
}