Программирование на языке Ruby - Хэл Фултон

# Должно быть напечатано:

# 1 и 5

# 2 и 10

# 3 и 15

# 4 и 20

Можно было бы, конечно, использовать для этой цели zip. Но если нужно более элегантное решение, при котором все элементы не будут храниться одновременно, то без потоков не обойтись. Такое решение представлено в листинге 13.7.

def compose(*objects)

 threads = []

 for obj in objects do

  threads << Thread.new(obj) do |myobj|

   me = Thread.current

   me[:queue] = []

   myobj.each {|x| me[:queue].push(x) }

  end

 end

 list = [0]                     # Фиктивное значение, отличное от nil.

 while list.nitems > 0 do       # Еще есть не nil.

  list = []

  for thr in threads

   list << thr[:queue].shift    # Удалить по одному из каждого.

  end

  yield list if list.nitems > 0 # He вызывать yield, если все равны nil.

 end

end

x = [1, 2, 3, 4, 5, 6, 7, 8]

y = "    первыйn    второйn    третийn четвертыйn    пятыйn"

z = %w[a b с d e f]

compose(x, у, z) {|a,b,c| p [a, b, c] }

# Выводится:

# [1, "    первыйn", "a"]

# [2, "    второйn", "b"]

# [3, "    третийn", "c"]

# [4, " четвертыйn", "d"]

# [5, "     пятыйn", "e"]

# [6, nil, "f"]

# [7, nil, nil]

# [8, nil, nil]

Обратите внимание: мы не предполагаем, что все объекты имеют одно и то же число элементов. Если один итератор доходит до конца раньше остальных, то он будет генерировать значения nil до тех пор, пока не закончит работу «самый длинный» итератор.

Конечно, можно написать и более общий метод, который на каждой итерации будет обрабатывать более одного элемента. (В конце концов, не все итераторы возвращают по одному значению за раз.) Можно было бы в первом параметре передавать число значений для каждого итератора.

Можно также пользоваться произвольными итераторами (а не только стандартным each). Их имена можно было бы передавать в виде строк, а вызывать с помощью метода send. Много чего еще можно придумать.

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

13.2.10. Параллельное рекурсивное удаление

Забавы ради напишем код, который будет удалять дерево каталогов. Процедура рекурсивного удаления использует потоки. Как только обнаруживается очередной подкаталог, мы запускаем новый поток, который будет обходить его и удалять содержимое.

Созданные в ходе работы программы потоки хранятся в массиве threads. Поскольку это локальная переменная, у каждого потока будет собственная копия массива. Раз к ней может обращаться всего один поток, синхронизировать доступ не надо.

Отметим также, что в блок потока передается полное имя файла fullname, чтобы не нужно было беспокоиться по поводу того, что поток обращается к переменной, которую кто-то еще изменяет. Поток делает для себя локальную копию fn этой переменной.

Прежде чем удалять очередной каталог, мы должны дождаться завершения всех созданных в процессе его обхода потоков.

def delete_all(dir)

 threads = []

 Dir.foreach(dir) do |e|

  next if [".",".."].include? e # Пропустить . и ..

  fullname = dir + "/" + e

  if FileTest.directory?(fullname)

   threads << Thread.new(fullname) {|fn| delete_all(fn) }

  else

   File.delete(fullname)

  end

 end

 threads.each { |t| t.join }

 Dir.delete(dir)

end

delete_all("/tmp/stuff")

Будет ли работать такая программа быстрее, чем ее вариант без потоков? В наших тестах получалось по-разному. Возможно, это зависит от операционной системы и структуры конкретного каталога — глубины, количества файлов и т.д.

13.3. Заключение

Как было сказано, в Ruby не используются платформенные потоки. Программа не станет работать быстрее при наличии нескольких процессоров, но некоторого распараллеливания работы достичь все же можно. Потоки полезны во многих случаях» но писать и отлаживать многопоточную программу довольно трудно, особенно если для получения правильного результата приходится применять изощренные способы синхронизации.

Для синхронизации Ruby предоставляет такие классы, как Mutex, Monitor и ConditionVariable. Имеются также безопасные относительно потоков классы очередей Queue и SizedQueue.

В главе 14 мы перейдем от обсуждения техники программирования к решению конкретных задач, а именно сценариев системного администрирования.

Глава 14. Сценарии и системное администрирование

И сказал главный программист: «Даже если программа состоит всего из трех строчек, когда-то ее придется сопровождать».

Программистам часто приходится писать небольшие сценарии для запуска внешних программ и работы с операционной системой на достаточно высоком уровне. Особенно это относится к ОС UNIX, где для повседневной работы составляются многочисленные сценарии на языке интерпретатора команд (shell).

Ruby не всегда удобно использовать в качестве такого «склеивающего» языка, поскольку он задуман как более универсальный инструмент. Но в принципе все, что можно сделать на языке bash (и ему подобных), можно реализовать и на Ruby.

Нередко для этой цели можно воспользоваться каким-то более традиционным языком. Преимущества Ruby в его универсальности, богатстве функций и объектной ориентированности. Предполагая, что найдутся люди, желающие использовать Ruby для взаимодействия с операционной системой на таком уровне, мы продемонстрируем несколько полезных приемов.

Выстроить эту главу было трудно, поскольку есть много способов логически сгруппировать рассматриваемый материал. Если вы не смогли найти нужную тему там, где ожидали, попробуйте просмотреть другие разделы.

Кроме того, многие вопросы, которые можно было бы включить сюда, вошли в другие главы. Обратите внимание, в частности, на главу 10, где рассматриваются ввод/вывод и атрибуты файлов; эта информация часто бывает полезна при написании сценариев.

14.1. Запуск внешних программ

Никакой язык не может использоваться в качестве «клея», если он не позволяет запускать внешние программы. В Ruby для этого есть несколько способов.

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

14.1.1. Методы system и exec

Метод system (из модуля Kernel) эквивалентен одноименной функции из библиотеки языка С. Он выполняет указанную команду в отдельной оболочке.

system("/usr/games/fortune")

# Вывод направляется, как обычно, на stdout...

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

system("rm", "/tmp/file1")

system("rm /tmp/file2")

# Оба варианта годятся.

# А тут есть различие...

system("echo *")   # Печатается список всех файлов.

system("echo","*") # Печатается звездочка (расширение

                   # имени файла не производится).

# Более сложные командные строки тоже работают.

system("ls -l | head -n |")

Посмотрим, как это будет работать в семействе операционных систем Windows. В случае с простой исполняемой программой поведение должно быть таким же, как в UNIX. В зависимости от варианта Ruby для вызова встроенных в оболочку команд может потребоваться запуск cmd.ехе  — интерпретатора команд в Windows (в некоторых версиях ОС он называется command.com). Ниже приведены примеры запуска внешней и встроенной команды:

system("notepad.ехе","myfile.txt") # Никаких проблем...

system("cmd /с dir","somefile")    # 'dir' - встроенная команда!

Другое решение — воспользоваться библиотекой Win32API и определить собственный вариант метода system.

require "Win32API"

def system(cmd)

 sys = Win32API.new("crtdll", "system", ['P'], 'L')

 sys.Call(cmd)

end

system("dir") # cmd /с необязательно!

Таким образом, можно добиться более-менее системно-независимого поведения system. Но если вы хотите запомнить выведенную программой информацию (например, в переменной), то system — не лучший способ (см. следующий раздел).