Ruby threading vs normal

Question

Допустим, у меня есть 4 папки с 25 папками в каждом. В каждой из этих 25 папок есть 20 папок с 1 очень длинным текстовым документом. Метод, который я использую сейчас, кажется, имеет место для улучшения и в каждом сценарии, в котором я реализую потоки ruby, результат медленнее, чем раньше. У меня есть массив из 54 имен папок. Я перебираю каждый из них и использую метод foreach для получения глубоко вложенных файлов. В цикле foreach я делаю 3 вещи. Я получаю содержимое сегодняшнего файла, я получаю содержимое вчерашнего файла, и я использую свой алгоритм diff, чтобы найти то, что изменилось со вчерашнего дня. Как бы вы делали это быстрее с помощью потоков.

def backup_differ_loop device_name 

    device_name.strip! 
    Dir.foreach("X:/Backups/#{device_name}/#{@today}").each do |backup| 

    if backup != "." and backup != ".." 
     @today_filename = "X:/Backups/#{device_name}/#{@today}/#{backup}" 
     @yesterday_filename = "X:/Backups/#{device_name}/#{@yesterday}/#{backup.gsub(@today, @yesterday)}" 

     if File.exists?(@yesterday_filename) 
     today_backup_content = File.open(@today_filename, "r").read 
     yesterday_backup_content = File.open(@yesterday_filename, "r").read 

     begin 
     Diffy::Diff.new(yesterday_backup_content, today_backup_content, :include_plus_and_minus_in_html => true, :context => 1).to_s(:html) 
     rescue 
     #do nothing just continue 
     end 

     end 

     else 
     #file not found 
     end 

    end 

    end 

Answer 1

Первая часть вашей логики - поиск всех файлов в определенной папке. Вместо того, чтобы делать Dir.foreach, а затем проверять «.». и «..» вы можете сделать это в одной строке:

files = Dir.glob("X:/Backups/#{device_name}/#{@today}/*").select { |item| File.file?(item)} 

Обратите внимание на /* в конце? Это будет поиск уровня 1 уровня (внутри папки @today). Если вы хотите также искать внутри подпапок, замените его на /**/*, чтобы вы получили массив всех файлов во всех подпапках @today.

Так что я бы сначала метод, который даст мне двойной массив, содержащий кучу массивов соответствующих файлов:

def get_matching_files 
    matching_files = [] 

    Dir.glob("X:/Backups/#{device_name}/#{@today}/*").select { |item| File.file?(item)}.each do |backup| 
    today_filename = File.absolute_path(backup) # should get you X:/Backups...converts to an absolute path 
    yesterday_filename = "X:/Backups/#{device_name}/#{@yesterday}/#{backup.gsub(@today, @yesterday)}" 

    if File.exists?(yesterday_filename) 
     matching_files << [today_filename, yesterday_filename] 
    end 
    end 

    return matching_files 
end 

и назвать его:

matching_files = get_matching_files 

Теперь мы можем начать многопоточность, в которой вещи, вероятно, замедляются. Я сначала получить все файлы из matching_files массива в очереди, а затем начать 5 потоков, которые будут идти до тех пор, пока очередь не пуста:

queue = Queue.new 
matching_files.each { |file| queue << file } 

# 5 being the number of threads 
5.times.map do 
    Thread.new do 
    until queue.empty? 
     begin 
     today_file_content, yesterday_file_content = queue.pop 
     Diffy::Diff.new(yesterday_backup_content, today_backup_content, :include_plus_and_minus_in_html => true, :context => 1).to_s(:html) 
     rescue 
     #do nothing just continue 
     end 
    end 
    end 
end.each(&:join) 

Я не могу гарантировать, мой код будет работать, потому что я не иметь весь контекст вашей программы. Надеюсь, я дал вам некоторые идеи.

И самое важное: стандартная реализация Ruby может работать только по 1 потоку за раз. Это означает, что даже если вы реализуете вышеприведенный код, вы не получите существенной разницы в производительности. Получайте Rubinius или JRuby, которые позволяют запускать более одного потока одновременно. Или, если вы предпочитаете использовать стандартный MRI Ruby, вам потребуется переструктурировать свой код (вы можете сохранить свою оригинальную версию) и запустить несколько процессов. Вам просто нужно что-то вроде общей базы данных, где вы можете хранить match_files (например, одну строку), и каждый раз, когда процесс «берет» что-то из этой базы данных, он будет отмечать эту строку как «использованную». SQLite - хороший db для этого, я думаю, потому что по умолчанию это потокобезопасно.

Answer 2

Большинство реализаций Ruby не имеют «истинных» многоядерных потоков, то есть нити не улучшат производительность, поскольку интерпретатор может запускать только один поток за раз. Для таких приложений, как ваш с большим количеством дисковых ввода-вывода, это особенно актуально. Фактически даже при реальной многопоточности ваши приложения могут быть привязаны к IO и все еще не видят значительной части улучшения.

Вы, скорее всего, получите результаты, найдя в своем коде неэффективный алгоритм и улучшаете его.