Linux / Bash, wie können Befehle in einer FIFO-Warteschlange geplant werden?

Task Spooler:

http://vicerveza.homeunix.net/~viric/soft/ts/

https://launchpad.net/ubuntu/+source/task-spooler/0.7.3-1

Does the trick very well. Hopefully it will be included in Ubuntu's package repos.

Use ;

For example:
ls ; touch test ; ls

That will list the directory. Only after ls has run it will run touch test which will create a file named test. And only after that has finished it will run the next command. (In this case another ls which will show the old contents and the newly created file).

Similar commands are || and &&.

; will always run the next command.

&& will only run the next command it the first returned success.
Example: rm -rf *.mp3 && echo "Success! All MP3s deleted!"

|| will only run the next command if the first command returned a failure (non-zero) return value. Example: rm -rf *.mp3 || echo "Error! Some files could not be deleted! Check permissions!"

If you want to run a command in the background, append an ampersand (&).
Example:
make bzimage &
mp3blaster sound.mp3
make mytestsoftware ; ls ; firefox ; make clean

Will run two commands int he background (in this case a kernel build which will take some time and a program to play some music). And in the foregrounds it runs another compile job and, once that is finished ls, firefox and a make clean (all sequentially)

For more details, see man bash

[Edit after comment]

in pseudo code, something like this?

 Program run_queue: While(true) { Wait_for_a_signal(); While( queue not empty ) { run next command from the queue. remove this command from the queue. // If commands where added to the queue during execution then // the queue is not empty, keep processing them all. } // Queue is now empty, returning to wait_for_a_signal } 

// // Wait forever on commands and add them to a queue // Signal run_quueu when something gets added. // program add_to_queue() { While(true) { Wait_for_event(); Append command to queue signal run_queue } } 

The easiest way would be to simply run the commands sequentially:

cmd1; cmd2; cmd3; cmdN 

If you want the next command to run only if the previous command exited successfully, use &&:

cmd1 && cmd2 && cmd3 && cmdN 

That is the only bash native way I know of doing what you want. If you need job control (setting a number of parallel jobs etc), you could try installing a queue manager such as TORQUE but that seems like overkill if all you want to do is launch jobs sequentially.

Sie suchen at‚s Zwillingsbruder: batch. Er verwendet denselben Dämon, aber anstatt eine bestimmte Zeit einzuplanen, werden die Jobs in die Warteschlange gestellt und ausgeführt, wenn der durchschnittliche Systemlastdurchschnitt niedrig ist.

Neben dedizierten Warteschlangensystemen (wie der Sun Grid Engine ), die Sie auch lokal auf einer Maschine verwenden können und die Dutzende von Möglichkeiten bieten, können Sie so etwas wie verwenden

 command1 && command2 && command3 

Das ist das andere Extrem - ein sehr einfacher Ansatz. Letzteres sieht weder mehrere gleichzeitige Prozesse vor, noch füllt die "Warteschlange" allmählich.

Ich ging die gleiche Route, suchte Task-Spooler und so weiter. Das Beste vom Besten ist folgendes:

GNU Parallel --semaphore --fg Es hat auch -j für parallele Jobs.