Existe alguma ferramenta / comando no Linux que eu possa usar para executar um comando em mais de uma guia simultaneamente? Eu quero executar o mesmo comando: ./myprog argument1 argument2 simultaneamente em mais de um shell para verificar se os mutexes estão funcionando bem em um programa encadeado. Eu quero ser capaz de aumentar o número de instâncias deste programa, de modo a colocar meu código sob estresse mais tarde.
Eu estou procurando algo como o que parede faz. Eu posso pensar em usar tty, mas isso só parece ser muito doloroso se eu tiver que escalar isso para muitos mais shells.
Como o mavillan já sugeriu, use o terminador . Permite exibir muitos terminais de forma lado a lado. Ao ativar o recurso de transmissão, você pode inserir o mesmo comando simultaneamente em cada terminal.
Aqui está um exemplo com o comando date transmitido para uma grade de 32 terminais.
tmux tem essa capacidade. (juntamente com muitas outras capacidades úteis na mesma linha)
Pode ser feito por:
:setw synchronize-panes on
Outra ferramenta para adicionar à lista é chamada multixterm . Usa xterm terminais. Você pode invocá-lo assim:
$ multixterm
E uma vez você será presenteado com uma GUI.
Vocêpodeentãocomeçaragirarasjanelasxtermclicandonobotãonewxterm.Aqui,porexemplo,invoquei2.Sevocêclicarnajanelaprincipal,poderácomeçaradigitarcomandosnasduasjanelassimultaneamente:
Parece estar disponível apenas no Ubuntu, semelhante ao multixterm.
trecho
The purpose of keyboardcast is to allow you to send keystrokes to multiple X windows at once. This allows you, for example, to control a number of terminals connected to different but similar hosts for purposes of mass- administration.
You can also select non-terminals. If you come up with a reasonable use for this ability I'd be interested in hearing about it.
The program can select windows to send to either by matching their titles (using a substring) or by clicking on them (in a method similar to GIMP's screenshot feature).
The program also features the ability to spawn off multiple instances of gnome-terminal executing a single command on multiple arguments (for example executing 'ssh' on several hosts). The gnome-terminals are invoked with the profile 'keyboardcast' if it exists (so, for example, your font size can be smaller).
Você pode fazer algo como:
max_processes=20
for ((i=0; i<$max_processes; i++))
do
/path/to/myprog arg1 arg2 > /tmp/myprog.${i}.log &
done
Ou se a saída de cada comando for relevante durante a execução, você pode configurar a tela.
vi ~/.screenrc
screen -t inst1 1 /path/to/myprog arg1 arg2
screen -t inst2 2 /path/to/myprog arg1 arg2
screen -t inst3 3 /path/to/myprog arg1 arg2
screen -t inst4 4 /path/to/myprog arg1 arg2
A tela requer mais trabalho manual.
Tente o Terminator (terminal do emulador). Pode ter muitas sessões de shell na mesma janela e você pode transmitir um comando para todas elas.
Sou um usuário do KDE, com o konsole 2.13.2 no KDE 4.13.3 você pode fazer isso:
abra o konsole
dividir a vista verticalmente
escrevesimultaneamenteemcadaterminaldentrodajanela
Você pode usar uma ferramenta como o MobaXterm e permitirá que você se conecte simultaneamente e cole seus comandos em todas as suas janelas.
Se você quiser ver apenas a saída da execução do 100º programa:
#!/bin/bash
prog="/path/to/myprog"
args="argument1 argument2"
max=100
for i in $(seq $max); do
if [ $i -lt $max ]; then
exec $prog $args &> /dev/null &
else
exec $prog $args
fi
done
Você pode controlar konsole a DCOP . Um exemplo é aqui :
#!/bin/bash
checkfile() {
if [ ! -f $1 ]; then
echo "could not find $1"
exit 99
else
echo "OK"
fi
}
# Check for App1 XML
echo -n "Checking for App 1 XML... "
XMLA=/domain/DM.xml
checkfile ${DEVROOT}/${XMLA}
# Check for App2 XML
echo -n "Checking for App 2 XML... "
hostname=$(hostname)
XMLB=/domain/DM_${hostname}.xml
checkfile ${DEVROOT}/${XMLB}
# Launch Konsole
echo -n "Launching konsole... "
K=$(dcopstart konsole-script)
[ -z "${K}" ] && exit 98
# Create second tab and resize
SDA=$(dcop $k konsole currentSession)
SDB=$(dcop $k konsole newSession)
dcop $K $SDA setSize 121x25
# Let bash login, etc.
sleep 1
# Rename the tabs
dcop $K $SDA renameSession "App 1"
dcop $K $SDB renameSession "App 2"
# Start services, letting user watch
echo -n "starting app1... "
dcop $K konsole activateSession $SDA
dcop $K $SDA sendSession "echo -ne '3]0;DEV (${hostname})#!/bin/bash
checkfile() {
if [ ! -f $1 ]; then
echo "could not find $1"
exit 99
else
echo "OK"
fi
}
# Check for App1 XML
echo -n "Checking for App 1 XML... "
XMLA=/domain/DM.xml
checkfile ${DEVROOT}/${XMLA}
# Check for App2 XML
echo -n "Checking for App 2 XML... "
hostname=$(hostname)
XMLB=/domain/DM_${hostname}.xml
checkfile ${DEVROOT}/${XMLB}
# Launch Konsole
echo -n "Launching konsole... "
K=$(dcopstart konsole-script)
[ -z "${K}" ] && exit 98
# Create second tab and resize
SDA=$(dcop $k konsole currentSession)
SDB=$(dcop $k konsole newSession)
dcop $K $SDA setSize 121x25
# Let bash login, etc.
sleep 1
# Rename the tabs
dcop $K $SDA renameSession "App 1"
dcop $K $SDB renameSession "App 2"
# Start services, letting user watch
echo -n "starting app1... "
dcop $K konsole activateSession $SDA
dcop $K $SDA sendSession "echo -ne '3]0;DEV (${hostname})%pre%7' && clear && starter $XMLA"
sleep 2
echo -n "starting app2... "
dcop $K konsole activateSession $SDB
dcop $K $SDB sendSession "echo -ne '3]0;DEV (${hostname})%pre%7' && clear && starter $XMLB"
echo done.
7' && clear && starter $XMLA"
sleep 2
echo -n "starting app2... "
dcop $K konsole activateSession $SDB
dcop $K $SDB sendSession "echo -ne '3]0;DEV (${hostname})%pre%7' && clear && starter $XMLB"
echo done.
sh <<-STRESS &
$( printf 'myprog &\n%.0b' \
'seq 1 ${MAX_CONCURRENT_PROCS}' )
STRESS
echo "$!"
Concordo com o comentário que o @msw faz acima. Isto lhe escreverá um script para ser iniciado por um processo sh em background e imprimirá o pid do child sh process para que você possa monitorá-lo e seus filhos conforme ele funciona.
@Jinpeng estava no caminho certo com o Paralelo GNU , mas não com a implementação.
Exemplo: Execute 10 instâncias paralelas do seu programa, com cada thread executando seu programa apenas uma vez:
parallel -j10 './myprog argument1 argument2 #' ::: {1..10}
Exemplo: execute 10 encadeamentos paralelos, com cada um desses encadeamentos executando seu programa infinitamente:
parallel -j10 'while true ; do ./myprog argument1 argument2 ; done #' ::: {1..10}
Você pode dimensionar isso facilmente para centenas de segmentos, substituindo o 10 em meus exemplos.
parallel -j200 ... ::: {1..200}
Se o seu programa produz quaisquer mensagens stdout e você quiser vê-las à medida que elas são produzidas (ao invés do padrão que as agrupa), a opção --ungroup para paralelo pode ser útil.
parallel --ungroup ...
Se você estiver executando muitos threads de sua estação de trabalho e não quiser que as coisas parem de responder, considere nice ing toda a subárvore do processo no momento da inicialização.
nice -n19 parallel ...
Nota lateral, o GNU Parallel geralmente não é instalado por padrão, mas geralmente está em seus repositórios normais de pacotes, então instale-o como qualquer outro pacote: dnf install parallel , apt-get install parallel , brew install parallel , etc.
Você pode iniciar processos em segundo plano com nohup .
Exemplo:
nohup ./myprog -arg1 -arg2 &
Saída:
[1] 1769
nohup: ignoring input and appending output to 'nohup.out'
Lembre-se de matar a tarefa mais tarde com o PID :
kill 1769
Para trazer o processo em primeiro plano, você deve inserir o número do trabalho, neste caso [1] :
fg %1
gnu parallel é exatamente a ferramenta que você está procurando.
parallel -j 9 yourcommand
Meu pouco para moer:
#!/bin/sh
[ $# -lt 1 ] && {
echo "Use: $0 <file>
where file includes list of server"
exit 9
}
cp ~/.config/terminator/config ~/.config/terminator/config.'date +%Y%m%d-%H%M'
cat ~/.config/terminator/config.'date +%Y%m%d-%H%M'|grep -v "^.plugins" >~/.config/terminator/config
inc=5
echo " [[terms]]" >>~/.config/terminator/config
for i in 'cat $1' ; do
echo " [[[window${inc}]]]"
echo " type = Window"
echo " [[[terminal${inc}]]]"
echo " profile = default"
echo " order = 0"
echo " type = Terminal"
echo " parent = window${inc}"
echo " command = ssh $i"
inc=$((inc+1))
done >>~/.config/terminator/config
echo "[plugins]" >>~/.config/terminator/config
Fará a configuração do terminador (termos de layout) para muitas janelas em um grupo.
EDIT: Pelo menos, o terminator é capaz de enviar broadcast para todos os terminais do mesmo grupo. Esta função é comutável - para que você possa habilitá-la, escreva 'su -', desative e grave a senha para os terminais e habilite-a novamente.
Tags shell terminal parallelism