Куда копать для распараллеливания задачи в ruby?

юзай Thread, это стандартная библиотека, они как-раз хороши для IO bound задач

такая хрень делается шелом..спроси админа - он расскажет как.

Смотри примеры с тредами из любого букваря. Настоящей параллельности не будет, ибо GIL, но пока один тред ждет IO руби может выполнять другой. Или просто юзай форк, если не нужно никакого взаимодействия.

Для ruby есть русскоязычная документация, аналогичная https://ruby-doc.org ? К Thread был тестовый подход, эффекта ноль.

Между собой взаимодействия не нужно, спасибо за наводку.

jruby пусть юзает.

Может сразу жаву тогда? Уж лучше eventmachine подтянуть, и то слишком жирно для такой задачи.

Можно, но треды тут не нужны

прочитай про thread и Queue.

Я хэлоувордщик, функционал требуется наколеночный, кроме азов ruby не знаком ни с чем вообще, даже с башем. Была опробована такая конструкция:

buffer=File.open("путь к файлу").readlines
thr=Thread.new { buffer.each {|ip|
	begin
	host=Net::Telnet::new("Host" => ip, "Timeout" => 5, "Waittime" => 2, "Prompt" => /[#>\]-]/)
        ver=host.cmd("<требуемое действие>")
	host.close
	puts ver
	rescue Net::ReadTimeout #в случае ошибки продолжаем обход массива
  $stderr.puts #сообщение об ошибке
end
				} #конец блока buffer.each
} #конец потока thread
thr.join
puts thr #здесь мне выдается 16-ричное значение, а я ожидал перечисления результатов выполнения каждого процесса

Что тогда нужно?

Асинхронные сокеты, конечно! и FSM. С тредами тоже можно, возможно даже удобнее будет, но не обязательно.

ошибка в том, что ты запускаешь 1 тред и в нём устраиваешь цикл.

Тебе надо в цикле запустить N тредов и дождаться окончания всех

Спасибо.

Т.е. «вручную» разбить массив из тысячи элементов на сто массивов по десять элементов, и «вручную» запустить сто потоков? Как теоретически такое сделать для заранее неизвестного/периодически изменяющегося количества элементов в исходном массиве?

Сто потоков - это это из области бреда, руби это такое тормозное гавно, что 100 потоков - верная смерть. Задачу можно решить так: создаешь пул потоков (небольшой, например равный числу ядер-2); создаешь очередь задач, в которую основной поток пихает задания, а другой поток их достает и кладет на свободный поток из пула, или ждет пока кто-то освободится. Классика жанра.

Возьми гем parallel

buffer=File.open("путь к файлу").readlines
results = Parallel.map(buffer, in_threads: <кол-во желаемых нитей>) do |ip|
            # Telnet и прочая фигня
          end

разбивать вместо ста на N, но выше тебе уже подсказали более верное решение с пулами и очередями

Зацени эту мего буструю штуковену, https://github.com/igrigorik/em-http-request

Сто потоков - это это из области бреда, руби это такое тормозное гавно, что 100 потоков - верная смерть.

Тормозить будет ось, а не руби. В данном случае кода исчезающе мало, все упрется в IO. Так что нужны неблокирующие операции, только и всего. Неужели в руби этого нет из коробки? Даже в тикле было испокон веков.

JRuby https://github.com/jruby/jruby/wiki/Concurrency-in-jruby

Ребят, прошу прощения за такую наглость, но реально вынужден обратиться на каналы к вам, братьям-программистам, потому что у меня жопа по жизни и мне не у кого больше попросить помощи. Подробнее у меня на форуме:

https://russiancoders.tech/topic/7lTc4SC5HWjNXyZjqfMh/18/#177

google://ruby thread-safe queue
представь, у тебя есть массив (Array) из каких-то элементов, в твоём случае айпишников. и нужное кол-во тредов просто просят (pop) у этого массива последний\первый элемент. это называется очередь.
но не простая, а thread-safe, значит, что треды не смогут случайно получить один и тот-же элемент.
треды просто работают и забирают из очереди по одному элементу, тебе пофигу на длину очереди, если элементы в ней не протухают со временем. так что, не надо ничего делить на сто.

https://ru.wikipedia.org/wiki/GNU_parallel

Тебе верно сказали - вызов потоков нужно делать внутри цикла:

  lines = File.open("путь к файлу").readlines
  lines.each do |ip|
    Thread.new do
      begin
        host = Net::Telnet::new("Host" => ip, "Timeout" => 5, \
          "Waittime" => 2, "Prompt" => /[#>\]-]/)
        ver = host.cmd("<требуемое действие>")
        puts ver
        host.close
      rescue => err
        $stderr.puts('Exception: '+err.message)
      end
    end
  end

Если есть какой-то один ресурс, к которому нужно обращаться из разных потоков, то можешь ещё почитать про Mutex.

У него тысяча хостов, так что это будет жесткач.

Тогда пусть делает тупую задержку (sleep 1) или умную приостановку, пока N хостов в работе:

  N = 10
  $num = 0
  lines = File.open("путь к файлу").readlines
  lines.each do |ip|
    while $num >= N do
      sleep(0.2)
    end
    Thread.new do
      $num += 1
      begin
        host = Net::Telnet::new("Host" => ip, "Timeout" => 5, \
          "Waittime" => 2, "Prompt" => /[#>\]-]/)
        ver = host.cmd("<требуемое действие>")
        puts ver
        host.close
      rescue => err
        $stderr.puts('Exception: '+err.message)
      end
      $num -= 1
    end
  end