Come funziona la soluzione consumatore-produttore?

La risposta di scriptin sta dando una soluzione ragionevole, ma non risponde alle tue domande sul fallimento dell'implementazione che hai avuto.

• Viene visualizzato un errore "coda vuota" quando chiami pop su una coda Ruby in modalità non bloccante ( true passato) e non ci sono elementi in coda.
• Il tuo thread "produttore" viene creato e il tuo thread "consumatore" viene creato, ma verranno eseguiti indipendentemente e inizieranno ad essere eseguiti ogni volta che Ruby avrà voglia.
• Se il tuo "consumatore" viene eseguito prima che il "produttore" abbia inserito qualcosa nella coda, ovviamente il "consumatore" poperà una coda vuota e genererà un'eccezione.

La soluzione a questo è facile; il consumatore non dovrebbe usare la modalità non bloccante. Non passare true , chiama solo pop() . Il punto intero del thread consumatore è che può bloccare una coda in attesa del produttore, senza che il resto dell'applicazione si fermi.

Come chiamare lastfm.track.scrobble - sì, questo è l'esecuzione di quel metodo immediatamente e spinge il risultato sulla coda, che non è esattamente quello che vuoi :-D ed è in effetti il motivo per cui "in modo affidabile" il tuo thread di consumo arriva a fare la coda prima che il produttore abbia la possibilità di spingere qualsiasi cosa (anche se il thread del produttore viene eseguito per primo, fa una lenta chiamata "scrobble" e si aspetta che le richieste / risposte HTTP siano completate; il thread consumatore viene eseguito e tenta di leggere dalla coda vuota).

Vuoi spingere i parametri a scrobble sulla coda, poi fare in modo che il thread del consumatore esegua lo scrobbling. È "più bello" / più strutturato per creare piccole classi che incapsulano il lavoro e spingere le istanze di quelle sulla tua coda, ma una soluzione poco costosa e malvagia usa semplicemente l'hash che scrobble prende come input. Dobbiamo anche ricordarci di eseguire il ciclo sopra le voci della coda all'interno del consumatore, invece di elaborarne solo una! Quindi ( UNTESTED ) potremmo avere:

queue = SizedQueue.new(10)

Thread.new do 
  songs.each do |song|
      queue << { artist: song[:artist], track: song[:track] }
  end
  queue << "done"
end

consumer = Thread.new do
  loop do
    scrobble_args = queue.pop()
    Thread.exit if scrobble_args == "done"
    lastfm.track.scrobble(scrobble_args)
    puts "Scrobbled #{scrobble_args[:track] by scrobble_args[:artist]}."
  end
end

consumer.join

Questo dovrebbe lavorare tecnicamente, ma è totalmente inutile, perché quel thread solitario per il consumatore sta solo elaborando la coda in serie. Quindi cerchiamo di semplificare questo. In realtà, vuoi solo scaricare tutte le "canzoni" in coda e fare in modo che il thread del consumatore faccia il lavoro. Poiché vogliamo eseguire in parallelo, creeremo una serie di thread.

# I'm not bothering with the producer thread here so the queue size is unlimited.
# You could just as well put the 'songs.each' inside a producer thread with a
# a sized queue, as per your original code, if you wanted.
#
queue = Queue.new
songs.each do | song |
  queue << song
end

consumers = []

1.upto( 10 ) do
  consumers << Thread.new do

    # Keep looping until asked to exit
    #
    loop do
      song = queue.pop()
      Thread.exit if song == 'done'
      lastfm.track.scrobble( artist: song[ :artist ], track: song[ :track ] )
      puts "Scrobbled #{ song[ :track ] } by #{ song[ :artist ] }."
    end
  end

  # Push one 'done' exit instruction for each consumer
  #
  queue << 'done'
end

# Wait for all consumer threads to complete
#
consumers.each do | consumer |
  consumer.join()
end

... e quello dovrebbe fare il trucco. La gemma "Parallela" probabilmente farà lo stesso genere di cose sotto il cofano.

Sembra che ogni canzone sia elaborata indipendentemente, nel qual caso hai solo bisogno di una raccolta parallela. Google veloce ha trovato questo gioiello: link

Il codice sarebbe qualcosa del genere:

Parallel.each(songs) do |song|
  lastfm.track.scrobble artist: song[:artist], track: song[:track]
  puts "Scrobbled #{song[:track]} by #{song[:artist]}."
end

o quello, se vuoi vedere i risultati:

scrobbled_songs = Parallel.map(songs) do |song|
  scrobbled_song = lastfm.track.scrobble artist: song[:artist], track: song[:track]
  puts "Scrobbled #{song[:track]} by #{song[:artist]}."
  scrobbled_song
end

Come dice il documento, puoi regolare il numero di processi / thread in modo che corrisponda al numero di core della CPU.

Sta ancora bloccando ogni richiesta HTTP (supponendo che lastfm.track.scrobble stia bloccando l'operazione), lo stai facendo in parallelo usando più core (supponendo che ne hai più di uno).

Se hai bisogno di requisitoria HTTP asincrona, potresti semplicemente cercare uno strumento valido, come em-http-request o simili.