Làm cách nào để chạy cùng một lệnh linux trong nhiều hơn một tab / shell?

Có công cụ / lệnh nào trong Linux mà tôi có thể sử dụng để chạy một lệnh trong nhiều tab không? Tôi muốn chạy cùng một lệnh: ./myprog argument1 argument2đồng thời trong nhiều shell để kiểm tra xem các mutexes có hoạt động tốt trong một chương trình luồng hay không. Tôi muốn có thể tăng số lượng phiên bản của chương trình này để đặt mã của tôi vào trạng thái căng thẳng sau này.

Tôi đang tìm kiếm một cái gì đó giống như những gì tường làm. Tôi có thể nghĩ đến việc sử dụng tty's, nhưng điều đó có vẻ như rất đau đớn nếu tôi phải mở rộng quy mô này thành nhiều vỏ hơn.

Như mavillan đã đề xuất, chỉ cần sử dụng terminator . Nó cho phép hiển thị nhiều thiết bị đầu cuối theo cách lát gạch. Khi bật tính năng phát sóng, bạn có thể nhập cùng một lệnh đồng thời trên mỗi thiết bị đầu cuối.

Dưới đây là một ví dụ với lệnh ngày được phát tới một lưới gồm 32 thiết bị đầu cuối.

tmux có khả năng này. (cùng với nhiều khả năng hữu ích khác trong cùng một tĩnh mạch)

Có thể được thực hiện thông qua:

:setw synchronize-panes on

Đa nhiệm

Một công cụ khác để thêm vào danh sách là một công cụ được gọi multixterm. Nó sử dụngxterm thiết bị đầu cuối. Bạn có thể gọi nó như vậy:

$ multixterm

Và một khi bạn sẽ được trình bày với GUI.

Sau đó, bạn có thể bắt đầu quay các xtermcửa sổ bằng cách nhấp vào new xtermnút. Ví dụ ở đây tôi đã gọi 2. Nếu sau đó bạn nhấp vào cửa sổ chính, bạn có thể bắt đầu nhập lệnh trong cả hai cửa sổ cùng một lúc:

bàn phím

Xuất hiện chỉ có sẵn trên Ubuntu, trông tương tự như đa pha.

đoạn trích

Mục đích của bàn phím là cho phép bạn gửi tổ hợp phím đến nhiều cửa sổ X cùng một lúc. Điều này cho phép bạn, ví dụ, kiểm soát một số thiết bị đầu cuối được kết nối với các máy chủ khác nhau nhưng tương tự cho mục đích quản trị đại chúng.

Bạn cũng có thể chọn không thiết bị đầu cuối. Nếu bạn đưa ra một cách sử dụng hợp lý cho khả năng này, tôi sẽ muốn nghe về nó.

Chương trình có thể chọn các cửa sổ để gửi đến bằng cách khớp với tiêu đề của chúng (sử dụng chuỗi con) hoặc bằng cách nhấp vào chúng (theo phương thức tương tự như tính năng chụp màn hình của GIMP).

Chương trình cũng có khả năng sinh ra nhiều phiên bản của gnome-terminal thực thi một lệnh duy nhất trên nhiều đối số (ví dụ: thực thi 'ssh' trên một số máy chủ). Các thiết bị đầu cuối gnome được gọi với cấu hình 'bàn phím' nếu nó tồn tại (vì vậy, ví dụ, kích thước phông chữ của bạn có thể nhỏ hơn).

• Kiểm soát nhiều thiết bị đầu cuối đồng thời
• bàn phím trên launchpad

Nó có thể đạt được bằng cách sử dụng iTerm2

Tham khảo: http://korishev.com/blog/2014/02/11/iterm2-broadcast-input/

Bạn có thể làm một cái gì đó như:

max_processes=20
for ((i=0; i<$max_processes; i++))
do 
    /path/to/myprog arg1 arg2 > /tmp/myprog.${i}.log &
done

Hoặc nếu đầu ra của mỗi lệnh có liên quan trong khi thực hiện, bạn có thể thiết lập màn hình.

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

Màn hình đòi hỏi nhiều công việc thủ công.

Tôi là người dùng KDE, với konsole 2.13.2 trên KDE 4.13.3, bạn có thể làm điều này:

1. mở konsole

2. chia nhỏ xem theo chiều dọc

3. viết đồng thời trên mỗi thiết bị đầu cuối bên trong cửa sổ

Hãy thử Terminator (thiết bị đầu cuối giả lập). Nó có thể có nhiều phiên shell trong cùng một cửa sổ và bạn có thể phát lệnh cho tất cả chúng.

Kẻ hủy diệt

Bạn có thể sử dụng một công cụ như MobaXterm và nó sẽ cho phép bạn kết nối đồng thời và sau đó dán các lệnh của bạn vào tất cả các cửa sổ của bạn.

Nếu bạn chỉ muốn xem đầu ra từ thực hiện chương trình thứ 100:

#!/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

Bạn có thể kiểm soát konsolethông qua DCOP. Một ví dụ là từ đây :

#!/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 '\033]0;DEV (${hostname})\007' && clear && starter $XMLA"
sleep 2
echo -n "starting app2... "
dcop $K konsole activateSession $SDB
dcop $K $SDB sendSession "echo -ne '\033]0;DEV (${hostname})\007' && clear && starter $XMLB"
echo done.

sh <<-STRESS & 
$( printf 'myprog &\n%.0b' \
    `seq 1 ${MAX_CONCURRENT_PROCS}` )
STRESS
echo "$!"

Tôi đồng ý với nhận xét @msw đưa ra ở trên. Điều này sẽ viết cho bạn một kịch bản được khởi chạy bởi một shquy trình nền và in ra shpid của quy trình con để bạn có thể theo dõi nó và các phần tử con của nó khi nó hoạt động.

@Jinpeng đã đi đúng hướng với GNU Parallel , chỉ là không triển khai.

Ví dụ: Chạy 10 phiên bản song song của chương trình của bạn, với mỗi luồng chỉ chạy chương trình của bạn một lần:

parallel -j10 './myprog argument1 argument2 #' ::: {1..10}

Ví dụ: Chạy 10 luồng song song, với mỗi luồng đó chạy chương trình của bạn vô hạn:

parallel -j10 'while true ; do ./myprog argument1 argument2 ; done #' ::: {1..10}

Bạn có thể dễ dàng mở rộng quy mô này đến hàng trăm luồng bằng cách thay thế 10trong ví dụ của tôi.

parallel -j200     ...     ::: {1..200}

Nếu chương trình của bạn tạo ra bất kỳ thông báo xuất chuẩn nào và bạn muốn xem chúng khi chúng được tạo ra (chứ không phải mặc định đối chiếu chúng), --ungrouptùy chọn song song có thể hữu ích.

parallel --ungroup   ...

Nếu bạn đang chạy rất nhiều luồng từ máy trạm của mình và không muốn mọi thứ trở nên không phản hồi, hãy xem xét niceviệc sử dụng toàn bộ quy trình trong thời gian khởi chạy.

nice -n19 parallel   ...

Mặt lưu ý, GNU Parallel thường không được cài đặt theo mặc định nhưng thường là trong các hợp đồng mua gói bình thường của bạn, vì vậy chỉ cần cài đặt nó giống như bất kỳ gói khác: dnf install parallel, apt-get install parallel, brew install parallelvv

Bạn có thể bắt đầu các quá trình trong nền với nohup.

Thí dụ:

nohup ./myprog -arg1 -arg2 &

Đầu ra:

[1] 1769    
nohup: ignoring input and appending output to 'nohup.out'

Nhớ giết nhiệm vụ sau với cái đã cho PID:

kill 1769

Để đưa quy trình vào nền trước, bạn phải nhập số công việc, trong trường hợp này [1]:

fg %1

song song gnu chính xác là công cụ bạn đang tìm kiếm. parallel -j 9 yourcommand

My ít đến nhà máy:

#!/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

Sẽ tạo cấu hình terminator (thuật ngữ bố cục) cho nhiều cửa sổ trong một nhóm.

EDIT: Ít nhất, terminator có thể gửi phát sóng đến mọi thiết bị đầu cuối trong cùng một nhóm. Chức năng này có thể chuyển đổi - vì vậy bạn có thể kích hoạt chức năng ghi 'su -' sau đó vô hiệu hóa và ghi mật khẩu nợ vào các thiết bị đầu cuối và bật lại.