Question

我在看http://tldp.org/LDP/abs/html/subshells.html，他们提到子套可用于并行化任务。然后他们给出了例子：

(cat list1 list2 list3 | sort | uniq > list123) &
(cat list4 list5 list6 | sort | uniq > list456) &
# Merges and sorts both sets of lists simultaneously.
# Running in background ensures parallel execution.
#
# Same effect as
#   cat list1 list2 list3 | sort | uniq > list123 &
#   cat list4 list5 list6 | sort | uniq > list456 &

wait   # Don't execute the next command until subshells finish.

diff list123 list456

前两个命令是否不会与后两个命令大致同时完成？我原以为最后两个命令也会并行执行，并且有一些sleep循环，我无法创建他们不同的情况。最后两个命令与前两个命令有何不同？如果它们没有区别，那么为什么将子shell作为一种并行化方法被提及时可以将进程放在后台呢？

Answer 1

事实上，两者都是：

FB.Event.subscribe('send_to_messenger', function(e) {
FB.Event.subscribe('clicked', function(e) {
// callback for events triggered by the plugin
console.log('user clicked button');  
window.top.location = 'http://google.com';
}});

和

c1 | c2 &  # where c1 and c2 are arbitrary commands

使用子壳，如：

(c1 | c2) &

没有c1 | c2。原因是，通常，管道需要创建子shell。

（有一些非常特殊的情况，一些shell，包括bash，可以避免创建子shell：例如，&没有为bash中的prog | while read ...循环创建单独的子shell，前提是你set while（lastpipe）和作业控件不活动。它总是在其他shell中创建一个子shell。这可以通过观察变量的值来看出或者在shopt -s lastpipe循环内。但是当while命令不是内置的shell时，shell必须在内部创建一个子shell以便连接管道。）

Answer 2

管道/ oring / anding命令是相同的。

但如果您的并行化需要多行，那么您需要一个子shell，即

(echo a ; sleep 2 ;  echo b) &

不等于

echo a; sleep 2; echo b &

此外，子shell需要实例化单独的环境，因此它具有（通常是微不足道的）执行惩罚

Answer 3

let具有作业脚本和经理脚本，如下所示。然后，管理器将同时运行2个作业，并等待两个作业都完成-参见下面的输出。

job.sh （打印参数并等待0.1秒-循环10次）

while (k < 4) {
        for (int j = 1; j <= 13; j++) {
            Hashtable<Integer, String> Deck = new Hashtable();
            StringBuilder sb = new StringBuilder();
            int cnt = 0;
            while (cnt++ != 10) {
                int myChar = (int) (Math.random() * str.length());
                sb.append(str.charAt(myChar));
            }
            int i = (int) (Math.random() * 52);
            Deck.put(i, sb.toString());
            System.out.print(Deck);
        }

        System.out.println();
        k++;
    }

manager.sh（启动2个并行作业，然后等待两个作业都完成）

i=0
while [ $i -lt 10 ]
do
  echo "${i}: job $1"
  i=$[$i+1]
  sleep 0.1
done

将给出以下输出：

echo "start"

./job.sh 1 &
./job.sh 2 &

wait

echo "done"

哪种证明您的论点是，两个进程的运行时间几乎相同。

子壳和并行处理

3 个答案: