这是并行命令，可以使用我们的多个免费在线工作站之一在 OnWorks 免费托管服务提供商中运行，例如 Ubuntu Online、Fedora Online、Windows 在线模拟器或 MAC OS 在线模拟器
程序：
您的姓名
并行 - 从标准输入并行构建和执行 shell 命令行
概要
并行 [选项] [命令 [参数]] < list_of_arguments
并行 [选项] [命令 [论据]]( ::: 论据| :::: 参数文件 (s) ) ...
并行 --semaphore [选项] 命令
#!/usr/bin/并行 --shebang [选项] [命令 [论据]]
商品描述
GNU 并行 是一种 shell 工具，用于使用一台或多台计算机并行执行作业。 一个
作业可以是单个命令或必须为中的每一行运行的小脚本
输入。 典型的输入是文件列表、主机列表、用户列表、列表
URL 或表格列表。 作业也可以是从管道读取的命令。 GNU
并行 然后可以将输入拆分为块并将块通过管道传输到每个命令中
平行。
如果你今天使用 xargs 和 tee 你会发现 GNU 并行 作为 GNU 非常容易使用 并行
被写入具有与 xargs 相同的选项。 如果你在shell中写循环，你会发现
GNU 并行 也许能够替换大部分循环并通过运行使它们运行得更快
多个工作并行。
GNU 并行 确保命令的输出与您得到的输出相同
您按顺序运行命令。 这使得使用来自 GNU 的输出成为可能 并行
作为其他程序的输入。
对于每一行输入 GNU 并行 将执行 命令 以该行作为参数。 如果不
命令 给出，输入的行被执行。 多条线路将并行运行。
GNU 并行 通常可以用作替代品 参数 or 猫 | 打坏.
读者的 指南
首先观看介绍视频以进行快速介绍：
http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1
然后看看 例s 在列表之后 配置. 这会让你知道什么
GNU 并行 有能力。
然后花一个小时完成教程（男子 并行教程）。 你的命令行
会因此而爱你。
最后，如果您有特殊需要，您可能需要查看本手册的其余部分
已经覆盖。
配置
命令 要执行的命令。 如果 命令 或以下参数包含替换
字符串（例如 {}) 每个实例都将替换为输入。
If 命令 给定，GNU 并行 解决相同的任务 参数。 如果 命令 is
没有给 GNU 并行 行为类似于 猫 | sh.
这个 命令 必须是可执行文件、脚本、组合命令或函数。
如果它是一个 Bash 函数，你需要 出口 -f 先说功能。 使用别名
复制完整环境，如下所述 --env 并使用 环境并行 代替
of 并行.
如果是 zsh 函数，则需要使用此辅助函数 出口 至
导出并将 $PARALLEL_SHELL 设置为 bash：
函数exportf(){
export $(echo $1)="`whence -f $1 | sed -e "s/$1 //" `"
}
函数 my_func(){
回声 $1;
echo "你好";
}
导出 my_func
并行_外壳=/ bin / bash 并行“my_func {}”::: 1 2
该命令不能包含字符 \257（宏：X）。
{} 输入线。 此替换字符串将被替换为从
输入源。 输入源通常是 stdin（标准输入），但也可以
被给予 -a, :::或 ::::.
替换字符串 {} 可以改变 -I.
如果命令行不包含替换字符串，则 {} 将被附加到
命令行。
{.} 没有扩展名的输入行。 此替换字符串将被替换为
删除扩展名的输入。 如果输入行包含 . 最后一次之后 /
最后 . 直到字符串的末尾将被删除并且 {.} 将被替换
与其余。 例如 文件.jpg 成为 FOO, 子目录/foo.jpg 成为 子目录/foo,
子目录/foo.jpg 成为 子目录/foo, 子目录/栏 遗迹 子目录/栏。 如果
输入行不包含 . 它将保持不变。
替换字符串 {.} 可以改变 --呃.
要了解替换字符串，请参阅 {}.
{/} 输入行的基本名称。 这个替换字符串将被输入替换
删除了目录部分。
替换字符串 {/} 可以改变 --basename 替换.
要了解替换字符串，请参阅 {}.
{//} 输入行的目录名。 此替换字符串将被替换为
输入线。 看 目录名（1）。
替换字符串 {//} 可以改变 --目录名替换.
要了解替换字符串，请参阅 {}.
{/.} 没有扩展名的输入行的基本名称。 此替换字符串将是
替换为删除目录和扩展部分的输入。 它是一个
的组合 {/} 和 {.}.
替换字符串 {/.} 可以改变 --基本名称扩展名替换.
要了解替换字符串，请参阅 {}.
{#} （阿尔法测试）
要运行的作业的序列号。 此替换字符串将被替换为
正在运行的作业的序列号。 它包含与相同的数字
$PARALLEL_SEQ。
替换字符串 {#} 可以改变 --seqreplace.
要了解替换字符串，请参阅 {}.
{%} （阿尔法测试）
职位编号。 此替换字符串将被作业的插槽替换
介于 1 和要并行运行的作业数量之间的数字。 永远不会有2
具有相同作业槽号的作业同时运行。
替换字符串 {%} 可以改变 --插槽替换.
要了解替换字符串，请参阅 {}.
{n} 来自输入源的参数 n 或者 n'第一个论点。 这个位置替换
字符串将被输入源的输入替换 n （当与 -a or
::::) 或 n'th 参数（当与 -N）。 如果 n 是否定的，它指的是
以及 n'最后一个论点。
要了解替换字符串，请参阅 {}.
{n.} 来自输入源的参数 n 或者 n'th 没有扩展名的参数。 它是一个
的组合 {n} 和 {.}.
这个位置替换字符串将被来自 input 的输入替换
资源 n （当与 -a or ::::) 或 n'th 参数（当与
-N）。 输入将删除扩展名。
要了解位置替换字符串，请参阅 {n}.
{n/} 输入源参数的基本名称 n 或者 n'第一个论点。 它是一个
的组合 {n} 和 {/}.
这个位置替换字符串将被来自 input 的输入替换
资源 n （当与 -a or ::::) 或 n'th 参数（当与
-N）。 输入将删除目录（如果有）。
要了解位置替换字符串，请参阅 {n}.
{n//} 来自输入源的参数的目录名 n 或者 n'第一个论点。 它是一个
的组合 {n} 和 {//}.
这个位置替换字符串将被输入的目录替换
输入源 n （当与 -a or ::::) 或 n'th 参数（当使用时
- -N）。 看到 目录名（1）。
要了解位置替换字符串，请参阅 {n}.
{n/.} 输入源参数的基本名称 n 或者 n'th 没有扩展名的参数。
它是一个组合 {n}, {/}和 {.}.
这个位置替换字符串将被来自 input 的输入替换
资源 n （当与 -a or ::::) 或 n'th 参数（当与
-N）。 输入将删除目录（如果有）和扩展名。
要了解位置替换字符串，请参阅 {n}.
{=perl的 表达=}
替换为计算 perl的 表达. $_ 将包含与 {}。 后
评估 perl的 表达 $_ 将用作值。 建议
只更改 $_ 但您可以完全访问所有 GNU 并行的内部
函数和数据结构。
这个 {=perl的 表达=} 必须作为单个字符串给出。
另见： --rpl --parens
{=n perl的 表达=}
位置相当于 {= perl的 表达 =}. 理解定位
替换字符串见 {n}.
另见： {= perl的 表达 =} {n}.
::: 参数
使用命令行中的参数作为输入源而不是标准输入（标准
输入）。 与 GNU 的其他选项不同 并行 ::: 放在 命令 和
在争论之前。
以下是等效的：
(echo file1; echo file2) | 并行 gzip
并行 gzip ::: file1 file2
并行 gzip {} ::: file1 file2
并行 --arg-sep ,, gzip {} ,, file1 file2
并行 --arg-sep ,, gzip ,, file1 file2
并行 ::: "gzip file1" "gzip file2"
为避免治疗 ::: 作为特殊用途 --arg-sep 将参数分隔符设置为
别的东西。 也可以看看 --arg-sep.
stdin（标准输入）将被传递到第一个进程运行。
如果多个 ::: 给定，每组将被视为输入源，并且所有
将生成输入源的组合。 例如 ::: 1 2 ::: abc 将
导致组合 (1,a) (1,b) (1,c) (2,a) (2,b) (2,c)。 这很有用
用于替换嵌套的 for 循环。
::: 和 :::: 可以混合。 所以这些是等价的：
并行回声 {1} {2} {3} ::: 6 7 :::: 4 5 ::: 1 2 3
并行回声 {1} {2} {3} :::: <(seq 6 7) <(seq 4 5) :::: <(seq 1 3)
并行 -a <(seq 6 7) echo {1} {2} {3} :::: <(seq 4 5) :::: <(seq 1 3)
并行 -a <(seq 6 7) -a <(seq 4 5) echo {1} {2} {3} :: 1 2 3
序列 6 7 | 并行 -a - -a <(seq 4 5) echo {1} {2} {3} :: 1 2 3
序列 4 5 | 并行回声 {1} {2} {3} :::: <(seq 6 7) - ::: 1 2 3
:::: 参数文件
另一种写法 -a 参数文件1 -a 参数文件2 ...
::: 和 :::: 可以混合。
参见 -a, ::: 和 --x申请.
- 空值
-0 使用 NUL 作为分隔符。 通常输入行将以\n（换行符）结尾。 如果他们结束
在 \0 (NUL) 中，然后使用此选项。 它对于处理可能的参数很有用
包含 \n（换行符）。
--arg-文件 输入文件
-a 输入文件
使用 VHDL 语言编写 输入文件 作为输入源。 如果使用此选项，则 stdin（标准输入）为
给第一个进程运行。 否则，stdin（标准输入）被重定向
来自 /dev/null。
如果多个 -a 给出，每个 输入文件 将被视为输入源，并且
将生成输入源的所有组合。 例如文件 FOO 包含 1
2， 文件 酒吧 包含 a b c. -a FOO -a 酒吧 将导致组合
(1,a) (1,b) (1,c) (2,a) (2,b) (2,c)。 这对于替换嵌套的 for- 很有用
循环。
参见 --x申请 和 {n}.
--arg-文件-sep 九月海峡
使用 VHDL 语言编写 九月海峡 而不是 :::: 作为命令和参数之间的分隔符字符串
文件。 有用的话 :::: 命令用于其他用途。
另见： ::::.
--arg-sep 九月海峡
使用 VHDL 语言编写 九月海峡 而不是 ::: 作为分隔符字符串。 有用的话 ::: 是用来
命令的其他东西。
如果您命令使用，也很有用 ::: 但你仍然想从
stdin（标准输入）：只需更改 --arg-sep 到一个不在字符串中的字符串
命令行。
另见： :::.
- 酒吧 将进度显示为进度条。 在栏中显示：完成的作业百分比，
估计剩余的秒数，以及开始的作业数。
与...兼容 善意:
seq 1000 | 并行 -j30 --bar '(echo {};sleep 0.1)' 2> >(zenity --progress
--auto-kill) | 厕所
--基本文件 文件
--男朋友 文件
文件 将在作业开始之前转移到每个 sshlogin。 这将是
删除如果 - 清理 活跃。 该文件可能是要运行的脚本或一些常见的
作业所需的基础数据。 多种的 --男朋友 可以指定转移更多
基本文件。 这 文件 将被转移到相同的方式 - 转移.
--basename 替换 替换-str
--BNR 替换-str
使用替换字符串 替换-str 而不是 {/} 用于输入行的基本名称。
--基本名称扩展名替换 替换-str
--bner 替换-str
使用替换字符串 替换-str 而不是 {/.} 用于输入行的基名
没有扩展。
--背景 在后台运行命令，因此 GNU 并行 不会等待完成
退出前的命令。 这是默认值，如果 - 信号 置。
另见： --fg, 男子 无.
暗示 - 信号.
--bibtex 打印 GNU 的 BibTeX 条目 并行 并禁用引用通知。
- 堵塞 尺寸
--块大小 尺寸
块的大小（以字节为单位）。 大小可以后缀K, M, G, T, P, k, m, g, t,
或 p 将大小乘以 1024、1048576、1073741824、1099511627776，
1125899906842624、1000、1000000、1000000000、1000000000000 或 1000000000000000
。
GNU 并行 尝试满足块大小，但可能会偏离 XNUMX 的长度
记录。 出于性能原因 尺寸 应该大于单个记录。
尺寸 默认为 1M。
参见 - 管道 为了使用这个。
- 猫 创建一个包含内容的临时文件。 一般 - 管道 将数据提供给
标准输入（标准输入）上的程序。 和 - 猫 GNU 并行 会创造一个
{} 中名称为临时文件，因此您可以执行以下操作： 并行 - 管道 - 猫 wc {}.
参见 --先进先出.
- 清理
删除传输的文件。 - 清理 将删除传输的文件
处理完成后的远程计算机。
查找日志名称 '*gz' | 平行线 \
--sshlogin server.example.com --transfer --return {.}.bz2 \
--cleanup "zcat {} | bzip -9 >{.}.bz2"
通过 - 转移 传输到远程计算机的文件将在
远程计算机。 创建的目录不会被删除 - 即使它们被删除
空的。
通过 - 返回 从远程计算机传输的文件将被删除
远程计算机。 创建的目录不会被删除 - 即使它们被删除
空的。
- 清理 不使用时被忽略 - 转移 or - 返回.
--科尔塞普 正则表达式
-C 正则表达式
列分隔符。 输入将被视为一个表 正则表达式 分开
列。 可以使用访问第 n 列 {n} or {n.}。 例如 3 {} 是 3 日
列。
--科尔塞普 暗示 - 修剪 rl.
正则表达式 是一个 Perl 正则表达式： http://perldoc.perl.org/perlre.html
- 压缩
压缩临时文件。 如果输出很大并且非常可压缩，这将
在 $TMPDIR 中占用更少的磁盘空间，并且由于更少的磁盘 I/O 可能会更快。
GNU 并行 会尝试 左旋, 猪, GZIP, 压缩包2, 压缩包, bzip2, 伊兹玛, 邮编, xz in
那个顺序，并使用第一个可用的。
--压缩程序 PRG
--解压程序 PRG
使用 VHDL 语言编写 PRG 用于（解）压缩临时文件。 假设 PRG -直流 将
将 stdin（标准输入）解压为 stdout（标准输出），除非
--解压程序 给出。
--ctrlc 将 SIGINT 发送到在远程计算机上运行的任务，从而杀死它们。
--定界符 DELIM
-d DELIM 输入项以指定的字符结束。 引号和反斜杠是
不特别; 输入中的每个字符都是按字面意思处理的。 禁用结束 -
of-file 字符串，它被视为任何其他参数。 这可以在以下情况下使用
输入由简单的换行分隔项组成，尽管它几乎是
最好将您的程序设计为在可能的情况下使用 --null 。 这
指定的分隔符可以是单个字符、C 风格的字符转义，例如
\n，或八进制或十六进制转义码。 八进制和十六进制转义码
被理解为 printf 命令。 多字节字符不是
支持的。
--目录名替换 替换-str
--DNR 替换-str
使用替换字符串 替换-str 而不是 {//} 用于输入行的目录名。
-E eof-str
将文件字符串的结尾设置为 eof-str。 如果文件字符串的结尾作为
输入行，其余输入将被忽略。 如果两者都没有 -E 也不 -e 用来，
不使用文件字符串结尾。
- 延迟 秒
延迟开始下一份工作 秒 秒。 GNU 并行 会暂停 秒 秒后
开始每项工作。 秒 可以少于 1 秒。
--试运行
打印要在 stdout（标准输出）上运行的作业，但不运行该作业。 利用 -v
-v 如果作业将在远程运行，则包含 ssh/rsync 包装
计算机。 不过，不要指望这个字面意思，因为工作可能会安排在
另一台计算机或本地计算机，如果 : 在列表中。
--eof[=eof-str]
-e[eof-str]
此选项是 -E 选项。 用 -E 相反，因为它是 POSIX
符合 参数 而这个选项不是。 如果 eof-str 被省略，没有
文件字符串的结尾。 如果两者都没有 -E 也不 -e 使用，不使用文件字符串结尾。
--env VAR （阿尔法测试）
复制环境变量 VAR。 这将复制 VAR 到环境
命令运行。这对于远程执行特别有用。
在 Bash 中 VAR 也可以是 Bash 函数 - 请记住 出口 -f 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。
功能，见 命令.
变量“_”是特殊的。 它将复制所有环境变量，除了
中提到的 ~/.parallel/ignored_vars。
要复制 Bash 数组，您需要一个导入函数，因为 Bash 数组不能
出口：
进口阵列（）{
本地功能=$1; 转移;
出口 $func='() {
'"$(for arr in $@; do
声明 -p $arr|sed '1s/declare -./&g/'
完毕）”'
}'
}
声明 -A assoc='([one]="1" [two]="2")'
声明 -a indexed='([0]="one" [1]="two")'
import_array my_importer 关联索引
并行 --env my_importer \
'my_importer; echo "{}" "${indexed[{}]}" "${assoc[${indexed[{}]}]}"' ::: "${!indexed[@]}"
要复制完整环境，请使用此功能（例如，将其放入 .bashrc）：
env_parallel() {
导出parallel_bash_environment='（）{
'"$(echo "shopt -s expand_aliases 2>/dev/null"; alias;typeset -p | grep -vFf <(readonly; echo GROUPS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_;排版 -f)"'
}'
# 运行方式：env_parallel [普通并行选项]
`which 平行` "$@"
取消设置parallel_bash_environment
}
# 调用为：
env_parallel [普通并行选项]
另见： --记录环境.
——埃塔 显示完成前的估计秒数。 这迫使 GNU 并行
在开始查找作业数量之前阅读所有作业。 GNU 并行
通常只读取下一个要运行的作业。 暗示 - 进展.
--fg 在前台运行命令，因此 GNU 并行 将等待完成
退出前的命令。
参见 --背景, 男子 无.
暗示 - 信号.
--先进先出 创建一个包含内容的临时 fifo。 一般 - 管道 将数据提供给
标准输入（标准输入）上的程序。 和 --先进先出 GNU 并行 会创造一个
名称在 {} 中的临时 fifo，因此您可以执行以下操作： 并行 - 管道 --先进先出 wc {}.
注意：如果没有从 fifo 中读取数据，作业将永远阻塞。
参见 - 猫.
--过滤主机
删除主机。 对于每个远程主机：检查通过 ssh 登录是否有效。 如果
not：不使用此主机。
目前你可以 而不去 放 --过滤主机 在配置文件中，$PARALLEL，
/etc/parallel/config 或类似的。 这是因为 GNU 并行 使用 GNU 并行
计算这个，所以你会得到一个无限循环。 这可能会在一个
稍后发布。
--gnu 表现得像 GNU 并行. 此选项历来优先于 --托勒夫.
这个 --托勒夫 选项现已停用，因此可能无法使用。 --gnu 保持
为了兼容性。
- 团体 组输出。 每个作业的输出组合在一起，仅在以下情况下打印
命令完成。 stderr（标准错误）先是 stdout
（标准输出）。 这需要一些 CPU 时间。 在极少数情况下 GNU 并行
占用大量 CPU 时间，如果可以接受来自不同的输出
命令混合在一起，然后禁用分组 -u 可以加速 GNU
并行 乘以10。
- 团体 是默认值。 可以反转 -u.
另见： --行缓冲区 --取消分组
- 帮帮我
-h 向 GNU 打印选项摘要 并行 并退出。
--出错时停止 VAL
- 停止 VAL
GNU 应该如何 并行 如果多个作业之一失败则终止？
0 如果作业失败，不要停止。 退出状态将是失败的作业数。
这是默认设置。
1 如果作业失败，不要启动新作业，而是完成正在运行的作业
包括清理。 退出状态将是最后一次的退出状态
失败的工作。
2 立即终止所有作业并退出而不进行清理。 退出状态
将是失败作业的退出状态。
1-99% 如果 VAL% 的工作失败且至少为 3：不要开始新工作，但是
完成正在运行的作业，包括清理。 退出状态将是
上次失败作业的退出状态。
--标题 正则表达式
使用正则表达式作为标题。 对于正常使用，匹配的标头（通常是第一个
线： --标题 '.*\n') 将使用拆分 --科尔塞普 （默认为 '\t'）
和列名可以用作替换变量： {柱子 名称}.
对于 - 管道 匹配的标头将附加到每个输出。
--标题 : 是的别名 --标题 '.*\n'.
If 正则表达式 是一个数字，它将匹配那么多行。
-I 替换-str
使用替换字符串 替换-str 代替 {}。
- 代替[=替换-str]
-i[替换-str]
这个选项是同义词 -I替换-str if 替换-str 被指定，并且对于
-I{} 否则。 此选项已弃用； 利用 -I 代替。
--作业日志 日志文件
已执行作业的日志文件。 将已执行作业的列表保存到 日志文件 ，在
以下 TAB 分隔格式：序列号、sshlogin、以秒为单位的开始时间
自纪元以来，以秒为单位的运行时间，传输的文件中的字节数，文件中的字节数
返回、退出状态、信号和命令运行。
要将时间转换为严格的 ISO-8601，请执行以下操作：
perl的 -a -F"\t" - 是 'chomp($F[2]=`日期 -d \@$F[2] +%FT%T`); 打印 加入("\t",@F)'
参见 - 恢复.
- 工作 N
-j N
--最大进程 N
-P N 职位数量。 最多并行运行 N 个作业。 0 表示尽可能多。
默认为 100%，每个 CPU 核心运行一项作业。
If - 信号 设置默认值为 1 从而创建互斥锁。
- 工作 +N
-j +N
--最大进程 +N
-P +N 将 N 添加到 CPU 内核数。 并行运行这么多作业。 也可以看看
--使用 cpu 代替核心.
- 工作 -N
-j -N
--最大进程 -N
-P -N 从 CPU 内核数中减去 N。 并行运行这么多作业。 如果
评估的数字小于 1，则将使用 1。 也可以看看
--使用 cpu 代替核心.
- 工作 N%
-j N%
--最大进程 N%
-P N% 将 N% 乘以 CPU 内核数。 并行运行这么多作业。 看
还 --使用 cpu 代替核心.
- 工作 进程文件
-j 进程文件
--最大进程 进程文件
-P 进程文件
从文件中读取参数。 使用内容 进程文件 作为参数 -j。 例如
进程文件 可以包含字符串 100% 或 +2 或 10。如果 进程文件 当一个
工作完成， 进程文件 再次读取并计算新的作业数。 如果
数量比以前少，正在运行的作业将被允许完成但新的
在达到所需的作业数量之前，不会启动作业。 这
可以在 GNU 时更改同时运行的作业数量
并行 在跑。
- 维持秩序
-k 保持输出顺序与输入顺序相同。 通常是作业的输出
将在作业完成后立即打印。 试试这个看看区别：
并行-j4睡眠{}\； 回声 {} ::: 2 1 4 3
并行-j4 -k 睡眠{}\; 回声 {} ::: 2 1 4 3
如果与 - 所有 or --nonall 输出将按 sshlogin 分组
秩序。
-L 最大行数
当与 - 管道: 读取记录 最大行数.
否则使用时：最多使用 最大行数 每个命令行的非空白输入行。
尾随空白导致输入行在下一个输入上逻辑上继续
线。
-L 0 表示读取一行，但在命令行上插入 0 个参数。
暗示 -X 除非 -m, --xargs或 - 管道 置。
--最大行数[=最大行数]
-l[最大行数]
当与 - 管道: 读取记录 最大行数.
否则使用时：同义词 -L 选项。 不像 -L， 最大行数
参数是可选的。 如果 最大行数 未指定，默认为一。 这 -l
选项已弃用，因为 POSIX 标准指定 -L 代替。
-l 0 是的别名 -l 1.
暗示 -X 除非 -m, --xargs或 - 管道 置。
--行缓冲区
基于行的缓冲输出。 - 团体 将整个输出保持在一起
工作。 --取消分组 允许输出与来自一项工作的半行混合
半行来自另一份工作。 --行缓冲区 介于这两者之间：GNU
并行 将打印整行，但允许混合不同的行
工作。
--行缓冲区 比两者都需要更多的 CPU 能力 - 团体 和 --取消分组，但是可以
比 - 团体 如果 CPU 不是限制因素。
另见： - 团体 --取消分组
- 加载 最大负荷
不要在给定的计算机上启动新作业，除非正在运行的进程数
在计算机上小于 最大负荷. 最大负荷 使用相同的语法 - 工作,
so 100% 每个 CPU 一个是有效设置。 唯一的区别是 0
解释为 0.01。
--控制主
-M 使用 ssh 的 ControlMaster 使 ssh 连接更快。 如果作业远程运行，则很有用
并且运行速度非常快。 这对于指定自己的 sshlogins 是禁用的
ssh 命令。
--xargs 多个参数。 在命令行长度允许的情况下插入尽可能多的参数。
If {} 不使用参数将被附加到该行。 如果 {} 用来
每次多次 {} 将替换为所有参数。
经验 --xargs - --ssh登录 是有限的，可能会失败。
参见 -X 用于上下文替换。 如果有疑问，请使用 -X 因为那很可能会
需要什么。
-m 多个参数。 在命令行长度允许的情况下插入尽可能多的参数。
如果多个作业并行运行：将参数平均分配给
工作。 利用 -j1 避免这种情况。
If {} 不使用参数将被附加到该行。 如果 {} 用来
每次多次 {} 将替换为所有参数。
经验 -m - --ssh登录 是有限的，可能会失败。
参见 -X 用于上下文替换。 如果有疑问，请使用 -X 因为那很可能会
需要什么。
--最小版本 版本
打印版本 GNU 并行 并退出。 如果当前版本的 GNU 并行
小于 版本 退出代码为 255。否则为 0。
这对于依赖于特定功能的脚本很有用
版本的 GNU 并行.
--nonall （测试版）
- 所有 没有任何争论。 在给出的所有计算机上运行命令 --ssh登录
但不要争论。 GNU 并行 将登录 - 工作 计算机的数量
并行并在计算机上运行作业。 -j 调整要登录的计算机数量
并行进。
这对于在服务器列表上运行相同的命令（例如 uptime）很有用。
- 所有 （测试版）
在给定的所有计算机上运行所有作业 --ssh登录。 GNU 并行 会登录
成 - 工作 并行的计算机数量并一次运行一项工作
计算机。 作业的顺序不会改变，但有些计算机可能会
在别人之前完成。 -j 调整并行登录的计算机数量。
使用时 - 团体 输出将按每个服务器分组，因此所有输出
从一台服务器将被组合在一起。
--输出文件
--输出文件
--文件 而不是将输出打印到 stdout（标准输出）每个作业的输出
保存在一个文件中，然后打印文件名。
- 管道
--spreadstdin
将输入传播到 stdin（标准输入）上的作业。 从标准输入读取数据块
（标准输入）并将一个数据块作为一项工作的输入。
块大小由 - 堵塞. 字符串 --重新启动 和 --重新开始 展示
GNU 并行 记录如何开始和/或结束。 块读取将具有最终
在块传递给作业之前删除部分记录。 部分
记录将被添加到下一个块。
If --重新启动 给出这将用于在记录开始时拆分。
If --重新开始 给出这将用于在记录结束时拆分。
如果两者 --重新启动 和 --重新开始 两者都必须匹配才能找到拆分
位置。
如果两者都不是 --重新启动 也不 --重新开始 给出 --重新开始 默认为“\n”。 具有
不使用记录分隔符 --重新开始 "".
--文件 经常与 - 管道.
另见： --重新启动, --重新开始, --先进先出, - 猫, --管道部分.
--管道部分 （测试版）
物理文件的管道部分。 --管道部分 类似于 - 管道，但是很多
快点。 它有一些限制：
* 该文件必须是物理（可查找）文件，并且必须使用 -a or
::::.
* 记录计数 (-N) 和行计数 (-L/-l） 不工作。
- 清楚的 忽略任何 - 轮廓, $PARALLEL, 和 ~/.parallel/配置 完全控制
命令行（由 GNU 使用 并行 在内部调用时 --ssh登录).
- 加 激活额外的替换字符串：{+/} {+.} {+..} {+...} {..} {...} {/ ..}
{/...}。 这个想法是 '{+foo}' 匹配 '{foo}' 和 {} =
{+/}/{/} = {.}.{+.} = {+/}/{/.}.{+.} = {..}.{+..} = {+/}/{/ ..}.{+..} =
{...}.{+...} = {+/}/{/...}.{+...}
- 进展
显示计算进度。 列出参与任务的计算机
检测到的 CPU 内核数和要运行的最大作业数。 在那场演出之后
每台计算机的进度：正在运行的作业数、已完成的作业数和
这台计算机完成的所有工作的百分比。 百分比只会是
在所有作业都被安排为 GNU 后可用 并行 只阅读下一个
准备好安排它的工作 - 这是为了避免浪费时间和内存
在启动时阅读所有内容。
通过发送 GNU 并行 SIGUSR2 您可以切换打开/关闭 - 进展 上
运行 GNU 并行 的过程。
参见 ——埃塔.
--最大参数=最大参数
-n 最大参数
最多使用 最大参数 每个命令行的参数。 少于 最大参数 参数
如果大小（请参阅 -s 选项）被超过，除非 -x 选项是
给定，在这种情况下 GNU 并行 将退出。
-n 0 表示读取一个参数，但在命令行中插入 0 个参数。
暗示 -X 除非 -m 置。
--最大替换参数=最大参数
-N 最大参数
最多使用 最大参数 每个命令行的参数。 喜欢 -n 但也让
替换字符串 1 {} .. {最大参数} 代表论点 1 .. 最大参数。 如果
args 太少了 {n} 将是空的。
-N 0 表示读取一个参数，但在命令行中插入 0 个参数。
这会将 homedir 的所有者设置为用户：
tr ':' '\n' < / etc / passwd文件 | 并行 -N7 乔恩 1 {} 6 {}
暗示 -X 除非 -m or - 管道 置。
当与 - 管道 -N 是要读取的记录数。 这有点
慢于 - 堵塞.
--允许的最大行长
打印命令行上允许的最大字符数并退出（使用
由 GNU 并行 本身来确定远程计算机上的线路长度）。
--CPU 数量
打印物理 CPU 的数量并退出（由 GNU 并行 本身
确定远程计算机上物理 CPU 的数量）。
--核心数
打印 CPU 内核数并退出（由 GNU 使用 并行 自己来确定
远程计算机上的 CPU 内核数）。
--无通知
不显示引用通知。 引用通知印在标准错误上（标准
error) 仅当 stderr（标准错误）是终端时，用户未指定
--无通知，并且用户还没有运行 --bibtex 一旦。
- 好的 善良
以这种方式运行命令。 对于简单的命令，您只需添加 不错 in
命令的前面。 但是如果命令包含更多子命令（例如：
ls|wc) 然后在前面 不错 不会总是有效。 - 好的 将确保所有子
命令很好。
- 交互的
-p 提示用户是否运行每个命令行并从命令行读取一行
终端。 仅当响应以“y”或“Y”开头时才运行命令行。
暗示 -t.
--parens 父字符串
用于定义开始和结束括号 {= perl的 表达 =}. 左边和
右括号可以是多个字符，并且假定是相同的
长度。 默认是 {==} 给予 {= 作为开始括号和 =} 作为结束
插入语。
另一个有用的设置是 ,,,, 这将使两个括号 ,,:
并行 --parens ,,,, echo foo is ,,s/I/O/g,, ::: FII
另见： --rpl {= perl的 表达 =}
- 轮廓 个人资料名称
-J 个人资料名称
使用配置文件 个人资料名称 对于选项。 如果您想拥有多个
个人资料。 您可以拥有一个用于在本地并行运行作业的配置文件
计算机和用于在远程计算机上运行作业的不同配置文件。 见
部分配置文件示例。
个人资料名称 对应文件 ~/.并行/个人资料名称.
您可以通过重复提供多个配置文件 - 轮廓. 如果配置文件的部分
冲突，后面的会用到。
默认值：配置
- 引用
-q 报价 命令. 这将引用命令行，所以特殊字符不是
由外壳解释。 请参阅引用部分。 大多数人永远不需要
这。 默认情况下禁用引用。
--如果为空则不运行
-r 如果 stdin（标准输入）仅包含空格，请不要运行该命令。
如果与 - 管道 这很慢。
--noswap 如果同时存在换入和换出，则不要在给定的计算机上启动新作业
活性。
交换活动仅每 10 秒采样一次，因为采样需要 1 秒
做。
交换活动被计算为 (swap-in)*(swap-out) 这在实践中是一个很好的
价值：换出不是问题，换入不是问题，但两者兼而有之
换入和换出通常表示有问题。
--记录环境
记录当前环境变量 ~/.parallel/ignored_vars。 这很有用
使用前 --env _.
参见 --env.
--重新启动 起始字符串
--重新开始 尾弦
If --重新启动 给出 起始字符串 将用于在记录开始时拆分。
If --重新开始 给出 尾弦 将用于在记录结束时拆分。
如果两者 --重新启动 和 --重新开始 给出组合字符串
结束字符串开始字符串 必须匹配才能找到拆分位置。 这很有用
如果要么 起始字符串 or 尾弦 在记录的中间匹配。
如果两者都不是 --重新启动 也不 --重新开始 然后给出 --重新开始 默认为“\n”。 到
没有记录分隔符使用 --重新开始 "".
--重新启动 和 --重新开始 与 - 管道.
使用 VHDL 语言编写 --正则表达式 解释 --重新启动 和 --重新开始 作为正则表达式。 这是
缓慢，但是。
--正则表达式 使用 VHDL 语言编写 --正则表达式 解释 --重新启动 和 --重新开始 作为正则表达式。 这是
缓慢，但是。
--删除-rec-sep
--removerecsep
--rrs 删除匹配的文本 --重新启动 和 --重新开始 在用管道输送到
命令。
仅与 - 管道.
- 结果 字首
--res 字首
将输出保存到文件中。 这些文件将存储在一个以目录树为根的目录树中
at 字首. 在这个目录树中，每个命令都会产生两个文件：
字首/ /标准输出和 字首/ /stderr，哪里是一个序列
表示输入源标题的目录（如果使用 --标题 :），或
输入源的编号和对应的值。
例如：
并行 --header : --results foo echo {a} {b} ::: a I II :::: b III IIII
将生成文件：
foo/a/I/b/III/标准错误
foo/a/I/b/III/标准输出
foo/a/I/b/IIII/标准错误
foo/a/I/b/IIII/标准输出
foo/a/II/b/III/标准错误
foo/a/II/b/III/标准输出
foo/a/II/b/IIII/stderr
foo/a/II/b/IIII/标准输出
和
并行 --results foo echo {1} {2} ::: I II ::: III IIII
将生成文件：
foo/1/I/2/III/标准错误
foo/1/I/2/III/标准输出
foo/1/I/2/IIII/标准错误
foo/1/I/2/IIII/标准输出
foo/1/II/2/III/标准错误
foo/1/II/2/III/标准输出
foo/1/II/2/IIII/标准错误
foo/1/II/2/IIII/标准输出
参见 --文件, --标题, --作业日志.
- 恢复 从上一个未完成的工作中恢复。 通过阅读 --作业日志 或者 - 结果 DIR
GNU 并行 将找出最后一个未完成的工作并从那里继续。 作为
GNU 并行 只看序列号 --作业日志 然后输入，
命令，和 --作业日志 一切都必须保持不变； 否则 GNU 并行 五月
运行错误的命令。
参见 --作业日志, - 结果, --简历失败.
--简历失败
重试全部失败并从上次未完成的工作中恢复。 通过阅读 --作业日志 GNU
并行 将找出失败的作业并再次运行它们。 之后它会
恢复上一个未完成的工作并从那里继续。 作为 GNU 并行 只看
中的序列号 --作业日志 然后是输入、命令和 --作业日志 所有
必须保持不变； 否则 GNU 并行 可能会运行错误的命令。
参见 --作业日志, - 恢复.
--重试 n
如果作业失败，请在另一台没有失败的计算机上重试。 做这个
n 次。 如果少于 n 计算机 --ssh登录 GNU 并行 将重新
使用所有计算机。 如果某些作业无缘无故失败，这很有用
（如网络故障）。
- 返回 文件名
从远程计算机传输文件。 - 返回 用于 --ssh登录 当
参数是远程计算机上的文件。 处理完成后文件
文件名 将从远程计算机传输使用 rsync的 并将被放置
相对于默认登录目录。 例如
回声 foo/bar.txt | 平行线 \
--sshlogin server.example.com --return {.}.out touch {.}.out
这将传输文件 $HOME/foo/bar.out 从计算机
服务器.example.com 到文件 foo/bar.out 跑步后 触摸 foo/bar.out on
服务器.example.com.
echo /tmp/foo/bar.txt | 平行线 \
--sshlogin server.example.com --return {.}.out touch {.}.out
这将传输文件 /tmp/foo/bar.out 从计算机 服务器.example.com
到文件 /tmp/foo/bar.out 跑步后 触摸 /tmp/foo/bar.out on
服务器.example.com.
可以通过多次重复选项来传输多个文件：
回声/tmp/foo/bar.txt | \
并行 --sshlogin server.example.com \
--return {.}.out --return {.}.out2 触摸 {.}.out {.}.out2
- 返回 经常与 - 转移 和 - 清理.
- 返回 与一起使用时被忽略 --ssh登录 : 或当不与 --ssh登录.
--循环
- 圆形的 通常情况下 - 管道 将为命令的每个实例提供一个块。 和
--循环 所有块将随机写入已经运行的命令。
如果命令需要很长时间来初始化，这很有用。
- 维持秩序 不会与 --循环 因为无法追踪哪个
输入块对应于哪个输出。
--rpl '行李牌 perl的 表达'
使用 VHDL 语言编写 行李牌 作为替换字符串 perl的 表达。这使得可以
定义您自己的替换字符串。 GNU 并行的 7 个替换字符串是
实现为：
--rpl '{} '
--rpl '{#} 1 $_=$job->seq()'
--rpl '{%} 1 $_=$job->slot()'
--rpl '{/} s:.*/::'
--rpl '{//} $Global::use{"File::Basename"} ||= eval "use File::Basename; 1;"; $_ = 目录名($_);'
--rpl'{/.s:.*/::; s:\.[^/.]+$::;'
--rpl '{.} s:\.[^/.]+$::'
如果用户定义的替换字符串以 '{' 开头，它也可以用作
位置替换字符串（如 {2。}).
建议只更改 $_ 但您可以完全访问所有 GNU
并行的内部函数和数据结构。
这里有几个例子：
删除 2 个扩展名（例如 .tar.gz）
--rpl '{..} s:\.[^/.]+$::;s:\.[^/.]+$::;'
只保留扩展名
--rpl '{ext} s:.*\.::'
作业顺序是偶数还是奇数？
--rpl '{odd} $_=$job->seq()%2?"odd":"even"'
另见： {= perl的 表达 =} --parens
--最大字符数=最大字符数
-s 最大字符数
最多使用 最大字符数 每个命令行的字符，包括命令和
初始参数和参数字符串末尾的终止空值。
最大允许值取决于系统，并作为参数计算
exec 的长度限制，小于您的环境大小。 默认值为
最大值。
暗示 -X 除非 -m 置。
--显示限制
显示由操作施加的命令行长度限制
系统和 -s 选项。 从 /dev/null 管道输入（并且可能指定
--no-run-if-empty) 如果你不想要 GNU 并行 做任何事。
- 信号
作为计数信号量工作。 - 信号 会导致 GNU 并行 开始
命令 在背景中。 当达到并发作业的数量时，GNU
并行 在启动另一个命令之前，将等待其中一个完成。
- 信号 暗示 --背景 除非 --fg 已指定。
- 信号 暗示 --信号量名称 `tty` 除非 --信号量名称 已指定。
用于 --fg, - 等待和 --信号量名称.
命令 无 是的别名 并行 - 信号.
参见 男子 无.
--信号量名称 姓名
- ID 姓名
使用 VHDL 语言编写 姓名 作为信号量的名称。 默认是控制 tty 的名称
（输出来自 TTY).
当交互使用时，默认值通常按预期工作，但在
一个脚本 姓名 应该设置。 $$ or 我的任务名称 通常是一个很好的价值。
信号量存储在 ~/.parallel/信号量/
暗示 - 信号.
参见 男子 无.
--信号量超时 秒
如果信号量没有在 secs 秒内释放，无论如何都要接受它。
暗示 - 信号.
参见 男子 无.
--seqreplace 替换-str
使用替换字符串 替换-str 而不是 {#} 用于作业序列号。
——舍邦
--哈希邦
GNU 并行 可以作为shebang (#!) 命令作为a 的第一行调用
脚本。 文件的内容将被视为输入源。
喜欢此页 :
#!/usr/bin/parallel --shebang -r 跟踪路由
foss.org.my
debian 网站
freenetproject.org
——舍邦 必须设置为第一个选项。
在 FreeBSD 上 ENV 需要：
#!/usr/bin/环境 -S 并行 --shebang -r traceroute
foss.org.my
debian 网站
freenetproject.org
--shebang-包装
GNU 并行 可以通过包装 shebang 行来并行化脚本。 如果程序
可以这样运行：
猫参数| 并行 the_program
那么脚本可以改为：
#!/usr/bin/parallel --shebang-wrap /the/original/parser --with-options
例如
#!/usr/bin/parallel --shebang-wrap /usr/bin/python
如果程序可以这样运行：
猫数据| 并行 --pipe the_program
那么脚本可以改为：
#!/usr/bin/parallel --shebang-wrap --pipe /the/original/parser --with-options
例如
#!/usr/bin/parallel --shebang-wrap --pipe /usr/bin/perl -w
--shebang-包装 必须设置为第一个选项。
--shell引用
不运行命令而是引用它。 用于制作引用组合
GNU 命令 并行.
--跳过第一行
不要使用输入的第一行（由 GNU 并行 调用时本身
——舍邦).
--ssh延迟 秒
延迟启动下一个 ssh 秒 秒。 GNU 并行 会暂停 秒 秒
在启动每个 ssh 之后。 秒 可以少于 1 秒。
-S [ncpu/]sshlogin[,[ncpu/]sshlogin[,...]]
--ssh登录 [ncpu/]sshlogin[,[ncpu/]sshlogin[,...]]
将作业分发到远程计算机。 作业将在远程列表上运行
电脑。 GNU 并行 将确定遥控器上的 CPU 内核数
计算机并运行指定的作业数量 -j. 如果数 中央处理器 is
给定 GNU 并行 将使用此数字作为主机上的 CPU 内核数。
通常情况下 中央处理器 将不需要。
An 登录 是以下形式：
[sshcommand [选项]] [用户名@] 主机名
sshlogin 必须不需要密码。
sshlogin ':' 是特殊的，它意味着 'no ssh'，因此将在
本地计算机。
sshlogin '..' 很特别，它从 ~/.parallel/sshlogin文件
sshlogin '-' 也很特别，它从 stdin（标准输入）读取 sshlogins。
要指定更多 sshlogins，请用逗号分隔 sshlogins 或重复选项
多次。
例如：见 --ssh登录文件.
远程主机必须有 GNU 并行 安装。
--ssh登录 已知会导致问题 -m 和 -X.
--ssh登录 经常与 - 转移, - 返回, - 清理和 --trc.
--ssh登录文件 文件名 （测试版）
--slf 文件名 （测试版）
带有 sshlogins 的文件。 该文件由不同行的 sshlogins 组成。 空的
以“#”开头的行和行将被忽略。 例子：
服务器.example.com
[email protected]
8/my-8-core-server.example.com
2/[email protected]
# 此服务器在端口 2222 上运行 SSH
ssh -p 2222 server.example.net
4/ssh -p 2222quadserver.example.net
# 使用不同的 ssh 程序
myssh -p 2222 -l 我的用户名 hexacpu.example.net
# 使用具有默认内核数的不同 ssh 程序
//usr/local/bin/myssh -p 2222 -l 我的用户名 hexacpu.example.net
# 使用不同的 6 核 ssh 程序
6//usr/local/bin/myssh -p 2222 -l myusername hexcpu.example.net
# 假设本地计算机有 16 个内核
16/：
当使用不同的 ssh 程序时，最后一个参数必须是主机名。
多 --ssh登录文件 被允许。
GNU 并行 将首先在当前目录中查找文件； 如果失败了，它看起来
对于文件 ~/.并行。
sshloginfile '..' 很特别，它从 ~/.parallel/sshlogin文件
sshloginfile '.' 很特别，它从
/etc/并行/sshloginfile
sshloginfile '-' 也很特别，它从标准输入（标准
输入）。
如果 sshloginfile 被更改，它将在作业完成时重新读取
大多数每秒一次。 这使得添加和删除主机成为可能
运行。
这可用于拥有一个守护进程，将 sshloginfile 更新为仅包含
已启动的服务器：
cp 原始.slf tmp2.slf
而[1]; 做
漂亮的并行 --nonall -j0 -k --slf original.slf --tag echo | perl 's/\t$//' > tmp.slf
如果差异 tmp.slf tmp2.slf; 然后
mv tmp.slf tmp2.slf
fi
睡10
完毕 ＆
并行 --slf tmp2.slf ...
--插槽替换 替换-str
使用替换字符串 替换-str 而不是 {%} 职位编号。
- 沉默的 沉默的。 将不会打印要运行的作业。 这是默认设置。 可
与 -v.
--tty 打开终端 tty。 如果 GNU 并行 用于启动交互式程序
那么可能需要这个选项。 它一次只会启动一项工作（即 -j1),
不缓冲输出（即 -u)，它将为作业打开一个 tty。 当工作
完成后，下一个工作将获得 tty。
- 标签 带有参数的标记行。 每个输出行都将带有参数
和制表符 (\t)。 当与 - 所有 or --nonall 行将被预先考虑
用 sshlogin 代替。
- 标签 使用时被忽略 -u.
--标签字符串 STR
用字符串标记行。 每个输出行都将加上 STR 和选项卡
(\t)。 STR 可以包含替换字符串，例如 {}。
--标签字符串 使用时被忽略 -u, - 所有和 --nonall.
--tmpdir 目录名
临时文件的目录。 GNU 并行 通常将输出缓冲到
/tmp 中的临时文件。 通过设置 --tmpdir 您可以使用不同的目录
文件。 环境 --tmpdir 相当于设置 $TMPDIR。
--tmux 使用 VHDL 语言编写 TMUX 为输出。 开始一个 TMUX 会话并在该窗口中运行每个作业
会议。 不会产生其他输出。
- 暂停 VAL
命令超时。 如果命令运行时间超过 VAL 秒会得到
用 SIGTERM 杀死，然后是 SIGTERM 200 毫秒，然后是 SIGKILL 200 毫秒
后来。
If VAL 后跟一个 % 然后超时将动态计算为
中位数平均运行时间的百分比。 只有 > 100% 的值才有意义。
--详细
-t 打印要在 stderr 上运行的作业（标准错误）。
参见 -v, -p.
- 转移
将文件传输到远程计算机。 - 转移 用于 --ssh登录 当
参数是文件，应该传输到远程计算机。 文件
将使用 rsync的 并将相对于默认工作目录放置。
如果路径包含 /./ 剩余的路径将相对于工作目录。
例如
回声 foo/bar.txt | 平行线 \
--sshlogin server.example.com --transfer wc
这将传输文件 foo/bar.txt 到电脑 服务器.example.com 以及
文件 $HOME/foo/bar.txt 跑步前 wc foo/bar.txt on 服务器.example.com.
echo /tmp/foo/bar.txt | 平行线 \
--sshlogin server.example.com --transfer wc
这将传输文件 foo/bar.txt 到电脑 服务器.example.com 以及
文件 /tmp/foo/bar.txt 跑步前 wc /tmp/foo/bar.txt on 服务器.example.com.
- 转移 经常与 - 返回 和 - 清理.
- 转移 与一起使用时被忽略 --ssh登录 : 或当不与
--ssh登录.
--trc 文件名
转移，返回，清理。 简写：
- 转移 - 返回 文件名 - 清理
- 修剪
修剪输入中的空白。
n 没有修剪。 输入未修改。 这是默认设置。
l 左修剪。 从输入的开头删除空格。 例如“a bc”->“a bc”。
r 右装饰。 从输入末尾删除空格。 例如“a bc”->“a bc”。
lr
rl 都修剪。 从输入的开头和结尾删除空格。 例如“a bc”
-> “公元前”。 这是默认值，如果 --科尔塞普 用来。
--取消分组
-u 取消分组输出。 输出被尽快打印出来，并通过 GNU 并行
内部处理。 这可能会导致不同命令的输出混合
因此只应在您不关心输出时使用。 比较这些：
并行 -j0 '睡觉 {};回声 -n 开始{};睡眠 {};回声 {}结尾' ::: 1 2 3 4
并行 -u -j0 '睡觉 {};回声 -n 开始{};睡眠 {};回声 {}结尾' ::: 1 2 3 4
它也禁用 - 标签。 GNU 并行 输出更快 -u. 比较速度
这些：
并行序列 ::: 300000000 >/dev/null
并行-u seq ::: 300000000 >/dev/null
并行 --line-buffer seq ::: 300000000 >/dev/null
可以反转 - 团体.
另见： --行缓冲区 - 团体
--扩展替换 替换-str
--呃 替换-str
使用替换字符串 替换-str 而不是 {.} 输入行没有
延期。
--使用 cpu 代替核心
计算物理 CPU 的数量而不是 CPU 内核数。 在计算多少
相对于您可以询问 GNU 的 CPU 内核数量，同时运行的作业
并行 而是查看物理 CPU 的数量。 这对
将超线程作为在一个 CPU 上运行的两个作业的计算机
超线程的运行速度将比在两个物理 CPU 上运行的两个作业慢。 一些
如果每个物理 CPU 只运行一个线程，则多核 CPU 可以运行得更快。
大多数用户不需要此选项。
-v 冗长。 打印要在 stdout（标准输出）上运行的作业。 可以反转
- - 沉默的要了解在年少时习得第二语言的各种好处的完整摘要，请参考： -t.
使用 VHDL 语言编写 -v -v 在远程运行时打印包装 ssh 命令。
- 版
-V 打印版本 GNU 并行 并退出。
--工作目录 目录
--wd 目录
文件传输使用 - 转移 和 - 返回 将相对于 目录 on
远程计算机，命令将在目录中执行 目录.
特别的 目录 折扣值 ... 将在下面创建工作目录 〜/.parallel/tmp/ on
远程计算机。 如果 - 清理 给出这些目录将被删除。
特别的 目录 折扣值 . 使用当前工作目录。 如果当前工作
dir 在你的 home dir 之下，值 . 被视为您的相对路径
家庭目录。 这意味着如果您的主目录在远程计算机上不同（例如
如果您的登录名不同）相对路径仍将相对于您的家
天。
要查看差异，请尝试：
并行 -S 服务器 PWD ::: ""
并行 --wd . -S 服务器 PWD ::: ""
并行 --wd ... -S 服务器 PWD ::: ""
- 等待 等待所有命令完成。
暗示 - 信号.
参见 男子 无.
-X 带有上下文替换的多个参数。 插入与命令一样多的参数
线长允许。 如果多个作业并行运行：分发
在作业之间均匀地争论。 利用 -j1 避免这种情况。
If {} 不使用参数将被附加到该行。 如果 {} 用作
单词的一部分（例如 图片{}.jpg) 那么整个单词将被重复。 如果 {} is
每次使用多次 {} 将被替换为参数。
通常情况下 -X 会做正确的事，而 -m 可能会产生意想不到的结果，如果 {}
用作单词的一部分。
经验 -X - --ssh登录 是有限的，可能会失败。
参见 -m.
- 出口
-x 退出，如果大小（见 -s 选项）被超过。
--x申请 读取多个输入源，如 应用. 如果给出多个输入源，则一个
将从每个输入源读取参数。 参数可以是
在命令中访问为 1 {} .. {n}，所以 1 {} 将是第一个输入的一行
来源，和 6 {} 将引用第 6 行起相同行号的行
输入源。
比较这两个：
并行回声 {1} {2} ::: 1 2 3 ::: abc
并行 --xapply echo {1} {2} ::: 1 2 3 ::: abc
如果一个输入源的参数多于输入源的参数，则参数将被回收
其他：
并行 --xapply echo {1} {2} {3} ::: 1 2 :::: I II III ::: abcdefg
参见 --标题.
例： 工进 as 参数 -n1。 争论 附加
GNU 并行 可以工作类似于 参数 -n1.
使用压缩所有 html 文件 GZIP 跑：
发现 . -芋头 '*.html' | 并行 GZIP - 最好的事物
如果文件名可能包含换行符，请使用 -0. 在所有文件中用 FUBAR 替换 FOO BAR
在这个目录和子目录中：
发现 . -类型 f -打印0 | 并行 -q0 perl的 -i -pe 的/FOO BAR/FUBAR/g'
备注 -q 由于“FOO BAR”中的空间，因此需要。
例： 阅读 参数 ， 命令 线
GNU 并行 可以从命令行而不是标准输入（标准输入）获取参数。
使用以下命令压缩当前目录中的所有 html 文件 GZIP 跑：
并行 GZIP - 最好的事物 ::: *.html
要使用每个 CPU 内核运行一个进程的 LAME 将 *.wav 转换为 *.mp3：
并行 瘫子 {} -o {.}.mp3 ::: * .wav
例： 插入 多 参数
像这样移动很多文件时： mv *。日志 目标目录 您有时会收到错误消息：
重击： /bin/mv: 争论 名单 也有 长
因为文件太多。 你可以这样做：
ls | grep的 -E '\.log$' | 并行 mv {} 目标目录
这将运行 mv 对于每个文件。 如果它可以更快地完成 mv 得到尽可能多的参数
将适合该行：
ls | grep的 -E '\.log$' | 并行 -m mv {} 目标目录
例： 语境 更换
删除文件 图片0000.jpg .. 图片9999.jpg 你可以做：
以次 -w 0 9999 | 并行 rm 图片{}.jpg
你也可以这样做：
以次 -w 0 9999 | perl的 -pe 's/(.*)/pict$1.jpg/' | 并行 -m rm
第一个将运行 rm 10000 次，而最后一次只会运行 rm 需要多少次
保持命令行长度足够短以避免 争论 名单 也有 长 （它通常
运行 1-2 次）。
你也可以运行：
以次 -w 0 9999 | 并行 -X rm 图片{}.jpg
这也只会运行 rm 保持命令行长度较短所需的次数
够了。
例： 计算 集约 工作 和 代换
如果安装了 ImageMagick，这将生成一个 jpg 文件的缩略图：
兑换 -几何学 120 文件.jpg 大拇指_foo.jpg
对于目录中的所有 jpg 文件，这将与 CPU 核心数的作业并行运行：
ls * .jpg | 并行 兑换 -几何学 120 {} 拇指_{}
要递归地使用 发现:
发现 . -芋头 '*.jpg' | 并行 兑换 -几何学 120 {} {}_thumb.jpg
注意参数是如何开始的 {} as {} 将包括路径（例如运行 兑换
-几何学 120 ./foo/bar.jpg 拇指_./foo/bar.jpg 显然是错误的）。 该命令将
生成像 ./foo/bar.jpg_thumb.jpg 这样的文件。
使用 VHDL 语言编写 {.} 避免文件名中出现额外的 .jpg。 这个命令将使文件像
./foo/bar_thumb.jpg：
发现 . -芋头 '*.jpg' | 并行 兑换 -几何学 120 {} {.}_thumb.jpg
例： 换人 和 重定向
这将在 .gz 文件旁边生成一个未压缩版本的 .gz 文件：
并行 cat猫 {} ">“{.} ::: *.gz
需要引用 > 来推迟重定向。 另一种解决方案是引用
整个命令：
并行 "zcat {} >{.}” ::: *.gz
其他特殊的 shell 字符（如 * ; $ > < | >> <<）也需要放在引号中，
因为它们可能会被 shell 解释而不会提供给 GNU 并行.
例： 由 命令
一个作业可以由多个命令组成。 这将打印每个文件中的文件数
目录：
ls | 并行 '回声 -n {}” "; ls {}|厕所 -l'
将输出放在名为的文件中.dir:
ls | 并行 '（回声 -n {}” "; ls {}|厕所 -l) > {}.dir'
即使是小的 shell 脚本也可以由 GNU 运行 并行:
发现 . | 并行 'a={}; 名称=${a##*/}; 上=$（回声 “$姓名” | tr “[：降低：]”
“[：上：]”）; 回音 "$姓名 - $上"'
ls | 并行 'mv {} "$(回声 {} | tr “[：上：]” “[：降低：]”）”'
给定一个 URL 列表，列出所有下载失败的 URL。 打印行号和
网址。
猫 网址文件 | 并行 "wget {} 2>的/ dev / null的 || grep的 -n {} 网址文件”
使用相同的文件名创建一个镜像目录，但所有文件和符号链接都为空
文件。
cp -rs /该/源/目录 镜像目录； 发现 镜像目录 -类型 l | 并行 -m rm {} '&&' 触摸
{}
查找列表中不存在的文件
猫 文件列表 | 并行 '如果 [ ! -e {} ] ; 然后 回音 {}； 菲'
例： 调用 揍 功能
如果组合的命令比一行长，就会变得难以阅读。 在 Bash 中，您可以
使用函数。 只记得 出口 -f 功能。
做（）{
echo 只需 1 美元
睡2
echo 用 $1 完成
}
导出 -f doit
平行 doit ::: 1 2 3
双倍（）{
echo 只需 1 美元 2 美元
睡2
echo 用 $1 $2 完成
}
导出 -f 双列
并行 doubleit ::: 1 2 3 ::: ab
要在远程服务器上执行此操作，您需要使用 --env:
并行 --env doit -S 服务器 doit ::: 1 2 3
并行 --env doubleit -S 服务器 doubleit ::: 1 2 3 ::: ab
如果您的环境（别名、变量和函数）很小，您可以复制完整的
环境而不必 出口 -f 任何事物。 首先运行这个：
env_parallel() {
导出parallel_bash_environment='（）{
'"$(echo "shopt -s expand_aliases 2>/dev/null"; alias;typeset -p | grep -vFf <(readonly; echo GROUPS; echo FUNCNAME; echo DIRSTACK; echo _; echo PIPESTATUS; echo USERNAME) | grep -v BASH_;排版 -f)"'
}'
# 运行方式：env_parallel parallel_bash_environment "2>/dev/null;" ...
`which 平行` "$@"
取消设置parallel_bash_environment
}
然后调用为：
env_parallel doit ::: 1 2 3
env_parallel doubleit ::: 1 2 3 ::: ab
env_parallel -S 服务器 doit ::: 1 2 3
env_parallel -S server doubleit ::: 1 2 3 ::: ab
例： 功能 测试仪
要测试具有不同参数的程序：
测试员（）{
if (eval "$@") >&/dev/null; 然后
perl -e 'printf "\033[30;102m[ OK ]\033[0m @ARGV\n"' "$@"
其他
perl -e 'printf "\033[30;101m[FAIL]\033[0m @ARGV\n"' "$@"
fi
}
导出 -f 测试器
并行测试器 my_program ::: arg1 arg2
并行测试器退出 ::: 1 0 2 0
If 我的程序 失败会打印一个红色的 FAIL，然后是失败的命令； 否则
将打印绿色 OK，然后是命令。
例： 删除 文件 延期 ，尤其是 加工 档
处理文件时使用删除文件扩展名 {.} 经常有用。
为每个 zip 文件创建一个目录并将其解压缩到该目录中：
并行 'mkdir {.}； cd {.}； 拉开拉链 ../{}' ::: *。压缩
使用重新压缩当前目录中的所有 .gz 文件 bzip2 每个 CPU 内核运行 1 个作业
平行线：
并行 "zcat {} | bzip2 >{.}.bz2 && rm {}” ::: *.gz
使用 LAME 将所有 WAV 文件转换为 MP3：
发现 声音目录 -类型 f -芋头 '*.wav' | 并行 瘫子 {} -o {.}.mp3
将所有转换后的文件放在同一目录中：
发现 声音目录 -类型 f -芋头 '*.wav' | 并行 瘫子 {} -o 目录/{/.}.mp3
例： 删除 二 文件 扩展 ，尤其是 加工 档
如果您有包含 tar.gz 文件的目录并希望将这些文件提取到相应的目录中
（例如 foo.tar.gz 将被提取到目录 foo 中）您可以执行以下操作：
并行 - 加 'mkdir {..}； 焦油 -C {..} -xf {}' ::: *.tar.gz
例： 下载 10 图片 HPMC胶囊 每 of 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 过去 30 天
让我们假设一个网站存储如下图像：
http://www.example.com/path/to/YYYYMMDD_##。jpg
其中 YYYYMMDD 是日期，## 是数字 01-10。 这将下载图像
过去 30 天：
并行 wget的 http://www.example.com/path/to/'$(日期 -d “今天 -{1} 天”
+%Y%m%d)_{2}.jpg' ::: $(序列 30） ::: $(序列 -w 10）
$(日期 -d “今天 -{1} 天” +%Y%m%d) 将在 YYYYMMDD 中给出 {1} 天的日期
减去。
例： 复制 档 as 最后 改性 日期 （ISO8601） - 添加 随机 数字
发现 . | 并行 'cp {} ../目标目录/{= $a = 整数（10000*兰特）； $_ = `日期 -r “$_”
+%FT%T"$a"`; 咀嚼; =}'
例： 数码 时钟 - “闪烁” :
数字时钟中的 : 闪烁。 使其他每一行都有一个 ':' 而其余的有一个 ' ' a
perl 表达式用于查看第三个输入源。 如果值 modudo 3 为 2：使用
":" 否则使用 " ":
并行 -k 回音 {1}'{=3 $_=$_%2?":":" "==}'{2}{3} ::: {0..12} ::: {0..5} ::: {0..9}
例： 汇总 内容 of 档
这个：
并行 --header : echo x{X}y{Y}z{Z} \> x{X}y{Y}z{Z} \
::: X {1..5} ::: Y {01..10} ::: Z {1..5}
将生成文件 x1y01z1 .. x5y10z5。 如果要聚合输出分组
在 x 和 z 上你可以这样做：
并行 eval 'cat {=s/y01/y*/=} > {=s/y01//=}' ::: *y01*
对于 x 和 z 的所有值，它运行如下命令：
猫 x1y*z1 > x1z1
所以你最终得到 x1z1 .. x1z5 每个都包含 y 的所有值的内容。
例： 宽 第一 并行 卷筒纸 爬虫/镜像
下面的这个脚本将并行抓取和镜像 URL。 它下载第一页
是 1 次点击，然后是 2 次点击，然后是 3 次； 而不是正常的深度优先，其中
首先获取每个页面上的第一个链接链接。
像这样运行：
并行=-j100 ./并行爬行 http://gatt.org.yeslab.org/
取出 wget的 如果你只想要一个网络爬虫。
它的工作原理是从 URL 列表中获取一个页面并在该页面中查找链接
位于相同的起始 URL 内并且尚未被看到。 这些链接是
添加到新队列中。 当列表中的所有页面都完成后，新队列被移动到
URL 列表和过程重新开始，直到找不到看不见的链接。
#!/ bin / bash
# 例如 http://gatt.org.yeslab.org/
网址=$1
# 留在起始目录中
BASEURL=$(echo $URL | perl -pe 's:#.*::; s:(//.*/)[^/]*:$1:')
URLLIST=$(mktemp urllist.XXXX)
URLLIST2=$(mktemp urllist.XXXX)
SEEN=$(mktemp 看到.XXXX)
# Spider 获取 URL
回声 $URL >$URLLIST
cp $URLLIST $SEEN
而 [ -s $URLLIST ] ; 做
猫 $URLLIST |
并行lynx -listonly -image_links -dump {} \; wget -qm -l1 -Q1 {} \; 回声蜘蛛：{} \>\&2 |
perl -ne 's/#.*//; s/\s+\d+.\s(\S+)$/$1/ 并执行 { $seen{$1}++ 或 print }' |
grep -F $BASEURL | | grep -F $BASEURL |
grep -v -x -F -f $SEEN | tee -a $SEEN > $URLLIST2
MV $URLLIST2 $URLLIST
完成
rm -f $URLLIST $URLLIST2 $SEEN
例： 流程 档 ， a 焦油 文件 而 开箱
如果要处理的文件在 tar 文件中，则解压一个文件并进行处理
立即可能比首先解压所有文件更快。
焦油 西弗 脚.tgz | perl的 - 是 '打印 $l;$l=$_;END{打印 $l}' | 并行 回音
需要 Perl one-liner 以避免竞争条件。
例： 重写 a 循环 和 a 读循环
像这样的for循环：
（对于 `cat list` 中的 x ；做
做某事 $x
完成) | 进程输出
和 while-read-loops 像这样：
猫名单| （同时读取 x ; 做
做某事 $x
完成) | 进程输出
可以这样写：
猫 名单 | 并行 做一点事 | 进程输出
例如：查找列表中哪个主机名的 IP 地址为 1.2.3 4：
猫 HOSTS.TXT | 并行 -P 100 主持人 | grep的 1.2.3.4
如果处理需要更多步骤，则像这样的 for 循环：
（对于 `cat list` 中的 x ；做
no_extension=${x%.*};
do_something $x 比例 $no_extension.jpg
do_step2 <$x $no_extension
完成) | 进程输出
和像这样的while循环：
猫名单| （同时读取 x ; 做
no_extension=${x%.*};
do_something $x 比例 $no_extension.jpg
do_step2 <$x $no_extension
完成) | 进程输出
可以这样写：
猫 名单 | 并行 “做一点事 {} 由于平均内核尺寸较大，西米棕榈的加工比类似作物简单。然而，西米棕榈的相对稀缺性降低了潜在的加工规模。 {.}.jpg ; 做_step2 <{} {.}” | 进程输出
例： 重写 嵌套 for循环
像这样的嵌套 for 循环：
（对于 `cat xlist` 中的 x ；做
对于`cat ylist`中的y； 做
做某事 $x $y
完成
完成) | 进程输出
可以这样写：
并行 做一点事 1 {} 2 {} :::: 列表 列表 | 进程输出
像这样的嵌套 for 循环：
（对于 MF 中的性别；做
适用于 SML XL XXL 尺码； 做
回声 $gender $size
完成
完成) | 种类
可以这样写：
并行 回音 1 {} 2 {} ::: M F ::: S M L XL XXL | 分类
例： 查找 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 最低 差异 之间 档
差异 适合查找文本文件中的差异。 差异 | wc -l 给出了一个指示
差异的大小。 查找当前目录中所有文件之间的差异
做：
并行 - 标签 '差异 1 {} 2 {} | wc -l' ::: * ::: * | 分类 -nk3
这样就可以查看某些文件是否与其他文件更接近。
例： for循环 - 栏 名称
当执行多个嵌套的 for 循环时，跟踪循环变量会更容易
if is 被命名而不仅仅是一个数字。 利用 --标题 : 让第一个论点
是位置替换字符串的命名别名：
并行 --header : echo {gender} {size} ::: 性别 MF ::: size SML XL XXL
如果输入文件是带有列的文件，这也适用：
cat addressbook.tsv | 并行 --colsep '\t' --header : echo {Name} {E-mail address}
例： 计数 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 差异 之间 所有 档 in a DIR
运用 - 结果 结果保存在 /tmp/diffcount* 中。
并行 --results /tmp/diffcount "diff -U 0 {1} {2} |tail -n +3 |grep -v '^@'|wc -l" ::: * ::: *
要查看文件 A 和文件 B 之间的区别，请查看文件“/tmp/diffcount/1/A/2/B”。
例： 超速 up 来迅速 工作
在本地机器上启动作业大约需要 10 毫秒。 如果
作业只需很少的毫秒即可运行。 通常，您可以使用以下方法将小作业组合在一起 -X 会的
使开销不那么重要。 比较这些速度：
seq -w 0 9999 | 平行触摸图片{}.jpg
seq -w 0 9999 | 并行 -X 触摸图片{}.jpg
如果您的程序不能接受多个参数，那么您可以使用 GNU 并行 产卵
多个 GNU 并行s:
seq -w 0 999999 | 并行 -j10 --pipe 并行 -j0 触摸图片{}.jpg
If -j0 通常会产生 252 个工作，然后上面将尝试产生 2520 个工作。 在正常情况下
在 GNU/Linux 系统中，您可以使用这种技术毫无问题地生成 32000 个作业。 募集
32000个工作岗位限制提高 /proc/sys/内核/pid_max 到4194303。
例： 运用 壳 变量
使用 shell 变量时，您需要正确引用它们，否则它们可能会被拆分
在空间上。
请注意以下区别：
V=("我哥哥的12\"唱片值<\$\$\$>"'!' Foo Bar)
parallel echo ::: ${V[@]} # 这可能不是你想要的
和：
V=("我哥哥的12\"唱片值<\$\$\$>"'!' Foo Bar)
并行回声 ::: "${V[@]}"
在实际命令中使用包含特殊字符（例如空格）的变量时
你可以引用他们使用 '"$VAR"' 或使用“的和 -q:
V="这里有两个"
并行回声 "'$V'" ::: 空格
并行 -q echo "$V" ::: 空格
例： 团队 产量 生产线
在运行输出数据的作业时，您通常不希望多个作业的输出
一起跑。 GNU 并行 默认对每个作业的输出进行分组，因此输出为
作业完成时打印。 如果您希望在作业完成时打印整行
运行你可以使用 --行缓冲区. 如果您希望尽快打印输出
您可以使用 -u.
比较输出：
并行 跟踪路由 ::: foss.org.my debian 网站 freenetproject.org
到输出：
并行 --行缓冲区 跟踪路由 ::: foss.org.my debian 网站 freenetproject.org
和：
并行 -u 跟踪路由 ::: foss.org.my debian 网站 freenetproject.org
例： 标签 产量 生产线
GNU 并行 将输出行分组，但很难看出不同作业的位置
开始。 - 标签 将参数放在前面以使其更明显：
并行 - 标签 跟踪路由 ::: foss.org.my debian 网站 freenetproject.org
- 标签 作品 --行缓冲区 但不是 -u:
并行 - 标签 --行缓冲区 跟踪路由 ::: foss.org.my debian 网站 freenetproject.org
检查服务器的正常运行时间 ~/.parallel/sshlogin文件:
并行 - 标签 -S .. --nonall 正常运行时间
例： 保持 秩序 of 产量 同 as 秩序 of 输入
通常，作业的输出将在完成后立即打印。 有时你想要
输出的顺序与输入的顺序保持一致。 这是经常
重要的是，如果输出用作另一个系统的输入。 -k 将确保订单
即使较晚的作业在较早的作业之前结束，输出的顺序也与输入的顺序相同。
将一个字符串附加到文本文件中的每一行：
猫 文本文件 | 并行 -k 回音 {} 追加字符串
如果删除 -k 某些行可能以错误的顺序出现。
另一个例子是 跟踪路由:
并行 跟踪路由 ::: foss.org.my debian 网站 freenetproject.org
将提供 foss.org.my、debian.org 和 freenetproject.org 的跟踪路由，但它将是
根据哪个作业先完成排序。
要保持顺序与输入运行相同：
并行 -k 跟踪路由 ::: foss.org.my debian 网站 freenetproject.org
这将确保首先打印到 foss.org.my 的 traceroute。
一个更复杂的例子是并行下载一个大文件：一些互联网
如果您并行下载文件，连接将提供更多数据。 下载用
并行文件参见：“示例：为过去 10 天的每一天下载 30 张图像”。 但是如果
您正在下载一个大文件，您可以并行分块下载该文件。
要下载字节 10000000-19999999，您可以使用 卷曲:
卷曲 -r 10000000-19999999 http://example.com/the/big/file > 文件部分
要下载 1 GB 的文件，我们需要下载 100 个 10MB 的块并正确组合
秩序。
以次 0 99 | 并行 -k 卷曲 -r \
{}0000000-{}9999999 http://example.com/the/big/file > 文件
例： 并行 grep的
grep的 -r grep 递归遍历目录。 在多核 CPU 上 GNU 并行 往往能
加快速度。
发现 . -类型 f | 并行 -k -j150% -n 1000 -m grep的 -H -n STRING {}
这将为每个核心运行 1.5 个作业，并提供 1000 个参数 grep的.
例： 格雷普 n 生产线 HPMC胶囊 m 定期 表达式。
为大量正则表达式 grep 大文件的最简单解决方案是：
grep -f regexps.txt 大文件
或者，如果正则表达式是固定字符串：
grep -F -f regexps.txt 大文件
有两个限制因素：CPU 和磁盘 I/O。 CPU很容易衡量：如果grep需要
>90% CPU（例如运行top时），那么CPU是一个限制因素，并行化
将加快这一进程。 如果不是，则磁盘 I/O 是限制因素，具体取决于
磁盘系统并行化可能更快或更慢。 确定的唯一方法是
测量。
如果 CPU 是限制因素，则应在正则表达式上进行并行化：
猫正则表达式.txt | 并行 --pipe -L1000 --round-robin grep -f - bigfile
如果一行匹配多个正则表达式，则该行可能会重复。 该命令将启动一个
每个 CPU grep 并每个 CPU 读取一次大文件，但由于这是并行完成的，所有读取
除了第一个将缓存在 RAM 中。 根据 regexp.txt 的大小，它可能是
更快地使用 --block 10m 而不是 -L1000。 如果 regexp.txt 太大而无法放入 RAM，
删除 --round-robin 并调整 -L1000。 这将导致 bigfile 被读取更多次。
一些存储系统在并行读取多个块时性能更好。 这是真实的
对于某些 RAID 系统和某些网络文件系统。 并行读取
大文件：
并行 --pipepart --block 100M -a bigfile -k grep -f regexp.txt
这会将 bigfile 拆分为 100MB 的块并在每个块上运行 grep。 到
并行读取 bigfile 和 regexp.txt 使用 --fifo 将两者结合起来：
并行 --pipepart --block 100M -a bigfile --fifo cat regexp.txt \
\| 并行 --pipe -L1000 --round-robin grep -f - {}
如果一行匹配多个正则表达式，则该行可能会重复。
例： 运用 远程 电脑
要在远程计算机上运行命令，需要设置 SSH 并且您必须能够登录
无需输入密码（命令 ssh 复制 ID 和 SSH代理 可能会帮助你做到这一点）。
如果您需要登录整个集群，您通常不想接受主机密钥
对于每个主机。 你想第一次接受他们，如果他们曾经被警告过
改变了。 要做到这一点：
# 将服务器添加到 sshloginfile
(echo servera; echo serverb) > .parallel/my_cluster
# 确保 .ssh/config 存在
触摸 .ssh/config
cp .ssh/配置 .ssh/配置.备份
# 暂时禁用 StrictHostKeyChecking
(echo 'Host *'; echo StrictHostKeyChecking no) >> .ssh/config
并行 --slf my_cluster --nonall true
# 移除 StrictHostKeyChecking 的禁用
mv .ssh/config.backup .ssh/配置
中的服务器 .parallel/my_cluster 现在加入 .ssh/已知主机.
跑步 回音 on 服务器.example.com:
序列 10 | 并行 --sshlogin server.example.com echo
要在多台远程计算机上运行命令，请运行：
序列 10 | 并行 --sshlogin server.example.com,server2.example.net echo
或：
序列 10 | 并行 --sshlogin server.example.com \
--sshlogin server2.example.net 回显
如果登录用户名是 FOO on server2.example.net 使用：
序列 10 | 并行 --sshlogin server.example.com \
--ssh登录 [email protected] 回音
如果您的主机列表是 server1-88.example.net 登录 FOO:
序列 10 | 并行 -Sfoo@server{1..88}.example.net echo
要将命令分发到计算机列表，请创建一个文件 我的电脑 与所有
电脑：
服务器.example.com
[email protected]
server3.example.com
然后运行：
序列 10 | 并行 --sshloginfile mycomputers echo
要包括本地计算机，请将特殊的 sshlogin ':' 添加到列表中：
服务器.example.com
[email protected]
server3.example.com
:
GNU 并行 将尝试确定每个遥控器上的 CPU 内核数
计算机，并为每个 CPU 内核运行一项作业 - 即使远程计算机没有
相同数量的 CPU 内核。
如果未正确识别远程计算机上的 CPU 内核数
可以在前面添加 CPU 核心数。 这里的计算机有 8 个 CPU 内核。
序列 10 | 并行 --sshlogin 8/server.example.com echo
例： 传输 of 档
使用以下命令重新压缩 gzip 文件 bzip2 使用远程计算机运行：
查找日志/ -name '*.gz' | \
并行 --sshlogin server.example.com \
--transfer "zcat {} | bzip2 -9 >{.}.bz2"
这将列出 .gz 文件中的 日志 目录和下面的所有目录。 然后它会
将文件传输到 服务器.example.com 到相应目录中 $HOME/日志。 上
服务器.example.com 该文件将使用重新压缩 cat猫 和 bzip2 导致
对应的文件 。广州 替换为 Bz2。.
如果您希望将生成的 bz2 文件传输回本地计算机，请添加
- 返回 {.}.bz2:
查找日志/ -name '*.gz' | \
并行 --sshlogin server.example.com \
--transfer --return {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"
重新压缩完成后 Bz2。-file 传输回本地计算机
并放在原件旁边 。广州-文件。
如果要删除远程计算机上传输的文件，请添加 - 清理。 这
将删除传输到远程计算机的文件和传输的文件
从远程计算机：
查找日志/ -name '*.gz' | \
并行 --sshlogin server.example.com \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"
如果要在多台计算机上运行，请将计算机添加到 --ssh登录 使用“，”或
多 --ssh登录:
查找日志/ -name '*.gz' | \
并行 --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"
您可以使用添加本地计算机 --ssh登录 :. 这将禁用删除和
只为本地计算机传输：
查找日志/ -name '*.gz' | \
并行 --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--sshlogin：\
--transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"
经常 - 转移, - 返回 和 - 清理 一起使用。 它们可以缩短为
--trc:
查找日志/ -name '*.gz' | \
并行 --sshlogin server.example.com,server2.example.com \
--sshlogin server3.example.com \
--sshlogin：\
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"
随着文件 我的电脑 包含计算机列表，它变成：
查找日志/ -name '*.gz' | 并行 --sshloginfile mycomputers \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"
如果文件 ~/.parallel/sshlogin文件 包含计算机列表的特殊简写
-S .. 可以使用：
查找日志/ -name '*.gz' | 并行 -S .. \
--trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"
例： 分发 工作 至 本地 和 远程 电脑
将 *.mp3 转换为 *.ogg，在本地计算机和 server2 上每个 CPU 内核运行一个进程：
并行 --trc {.}.ogg -S server2,: \
'mpg321 -w - {} | oggenc -q0 - -o {.}.ogg' :: *.mp3
例： 运行 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 同 命令 on 远程 电脑
运行命令 正常运行时间 在远程计算机上，您可以执行以下操作：
并行 - 标签 --nonall -S 服务器1，服务器2 正常运行时间
--nonall 读取没有参数。 如果您有一份要在每台计算机上运行的作业列表，
可以做：
并行 - 标签 - 所有 -S 服务器1，服务器2 回音 ::: 1 2 3
删除 - 标签 如果您不想在输出之前添加 sshlogin。
如果您有很多主机，请使用“-j0”并行访问更多主机。
例： 并行化 rsync的
rsync的 是一个很好的工具，但有时它不会填满可用带宽。 这是
通过高速连接复制几个大文件时经常会出现问题。
下面将开始一个 rsync的 每个大文件 源目录 至 目标目录 在服务器上
服务器:
cd src目录； 发现 . -类型 f -尺寸 +100000 | 并行 -v SSH 服务器 MKDIR -p
/dest-dir/{//}\;rsync -s -哈维什 {} fooserver:/目标目录/{}
创建的目录可能会以错误的权限结束，并且较小的文件不会被
转移。 修复那些运行 rsync的 最后一次：
rsync的 -哈维什 源目录/ fooserver:/目标目录/
如果您无法推送数据，但需要拉它们并且文件名为digits.png
（例如 000000.png）你也许可以这样做：
以次 -w 0 99 | 并行 rsync的 -哈维什 fooserver:src 路径/*{}.png 目标目录/
例： 使用 VHDL 语言编写 多 输入 in 一种 命令
将 foo.es.ext 等文件复制到 foo.ext：
ls *.es.* | perl的 -pe '打印; s/\.es//' | 并行 -N2 cp 1 {} 2 {}
perl 命令为每个输入输出 2 行。 GNU 并行 需要 2 个输入（使用 -N2)
并用输入替换 {1} 和 {2}。
二进制计数：
并行 -k 回音 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1
在六面模具的相对面上打印数字：
并行 --x申请 -a <(seq 6) -a <(seq 6 -1 1) 回音
并行 --x申请 回音 :::: <(seq 6) <(seq 6 -1 1)
将文件从所有子目录转换为具有连续编号的 PNG 文件（用于制作
输入 PNG 的 ffmpeg的):
并行 --x申请 -a <(找到 . -类型 f | 分类） -a <(seq $(找到 . -类型 厕所|厕所 -l)) 兑换
1 {} {2}.png
替代版本：
发现 . -类型 f | 分类 | 并行 兑换 {} {#}.png
例： 使用 VHDL 语言编写 a 表 as 输入
table_file.tsv 的内容：
富酒吧
巴兹曲子
跑步：
cmd -o 栏 -i foo
cmd -o quux -i baz
你可以运行：
并行 -a 表文件.tsv --科尔塞普 '\t' CMD -o 2 {} -i 1 {}
注意：GNU 的默认值 并行 是删除列周围的空间。 为了保持
空格：
并行 -a 表文件.tsv - 修剪 n --科尔塞普 '\t' CMD -o 2 {} -i 1 {}
例： 运行 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 同 命令 10 时
如果您想并行运行具有相同参数的相同命令 10 次，您可以
做：
以次 10 | 并行 -n0 我的命令 我的参数
例： 工进 as 猫 | 嘘 更多相关资源 便宜 工作 和 评估
GNU 并行 可以工作类似于 猫 | sh.
资源廉价作业是占用很少 CPU、磁盘 I/O 和网络 I/O 的作业。
Ping 是资源廉价作业的一个示例。 wget 也是 - 如果网页很小。
文件jobs_to_run的内容：
平-c 1 10.0.0.1
wget的 http://example.com/status.cgiip=10.0.0.1
平-c 1 10.0.0.2
wget的 http://example.com/status.cgiip=10.0.0.2
...
平-c 1 10.0.0.255
wget的 http://example.com/status.cgiip=10.0.0.255
要同时运行 100 个进程，请执行以下操作：
并行 -j 100 < 作业运行
由于没有 命令 作业将由外壳评估。
例： 的解决方案 a 大 文件 运用 更多 颜色
要处理大文件或某些输出，您可以使用 - 管道 将数据分成块
并将块通过管道传输到处理程序中。
如果程序是 GZIP -9 你可以做：
猫 大文件 | 并行 - 管道 --重新开始 '' -k GZIP -9 >大文件.gz
这将分裂 大文件 成 1 MB 的块并将其传递给 GZIP -9 在平行下。 一 GZIP
将按每个 CPU 内核运行。 的输出 GZIP -9 将保持有序并保存到
大文件.gz
GZIP 如果附加了输出，则工作正常，但某些处理不会像那样工作 -
例如排序。 对于这个 GNU 并行 可以将每个命令的输出放入一个文件中。
这将并行排序一个大文件：
猫 大文件 | 并行 - 管道 --文件 分类 | 并行 -Xj1 分类 -m {} ';' rm {}
>大文件排序
服务 大文件 被分成大约 1MB 的块，每个块以 '\n' 结尾（这是
默认为 --重新开始）。 每个块都传递给 分类 和输出 分类 被保存到
文件。 这些文件被传递给第二个 并行 运行 分类 -m 在之前的文件上
它删除文件。 输出保存到 大文件排序.
GNU 并行's - 管道 最大速度约为 100 MB/s，因为每个字节都必须被复制
通过 GNU 并行。 但如果 大文件 是一个真实的（可搜索的）文件 GNU 并行 可以绕过
复制并将零件直接发送到程序：
并行 --管道部分 - 堵塞 100 m -a 大文件 --文件 分类 | 并行 -Xj1 分类 -m {} ';' rm
{} >大文件排序
例： 运行 更多 比 250 工作 解决方法
如果您需要并行运行大量作业，那么您可能会遇到
文件句柄限制，通常约为 250 个作业。 如果你是超级用户，你可以提高
限制在 /etc/security/limits.conf 但您也可以使用此解决方法。 文件句柄
限制是每个进程。 这意味着如果你只是产生更多的 GNU 并行s 然后每个
它们可以运行 250 个作业。 这将产生多达 2500 个工作：
猫 我的输入 | 并行 - 管道 -N 50 --循环 -j50 并行 -j50 你的程序
这将产生多达 62500 个作业（谨慎使用 - 您需要 64 GB RAM 才能执行此操作，并且
你可能需要增加 /proc/sys/内核/pid_max):
猫 我的输入 | 并行 - 管道 -N 250 --循环 -j250 并行 -j250 你的程序
例： 工进 as 互斥体 和 计数 信号
命令 无 是的别名 并行 - 信号.
计数信号量将允许在后台启动给定数量的作业。
当后台运行的作业数量较多时，GNU 无 将等待其中之一
在启动另一个命令之前完成。 无 - 等待 将等待所有作业
完成。
在后台同时运行 10 个作业：
对于我在 *.log ; 做
回声我
sem -j10 gzip $i ";" 回声完成
完成
sem --等待
互斥体是一种计数信号量，只允许运行一个作业。 这将编辑文件
我的档案 并在文件前面加上数字 1 到 3 的行。
序列 3 | 并行 sem sed -i -e 'i{}' myfile
As 我的档案 可能很大很重要只有一个进程同时编辑文件
时间。
将信号量命名为同时激活多个不同的信号量：
序列 3 | 并行 sem --id mymutex sed -i -e 'i{}' myfile
例： 开始 编辑 - 档名 ， 标准输入 （标准 输入）
你可以使用 GNU 并行 启动 emacs 或 vi 等交互式程序：
猫 文件列表 | 并行 --tty -X emacs的
猫 文件列表 | 并行 --tty -X vi
如果文件数量超过单个命令行的容量，则将启动编辑器
再次使用剩余的文件。
例： 运行 须藤
须藤 需要密码才能以 root 身份运行命令。 它缓存访问，所以你只需要
如果您没有使用过，请再次输入密码 须藤 一段时间。
命令：
并行 sudo echo ::: 这是一个坏主意
不好，因为系统会提示您输入每个作业的 sudo 密码。 你可以
要么做：
须藤回声这个
并行 sudo echo ::: 是个好主意
要么：
sudo parallel echo ::: 这是个好主意
这样您只需输入一次 sudo 密码。
例： GNU 并行 as 队列 系统/批次 经理
GNU 并行 可以用作简单的作业队列系统或批处理管理器。 这个想法是把
将作业写入文件并拥有 GNU 并行 从中不断地阅读。 作为 GNU 并行
将在我们使用的文件末尾停止 尾巴 继续阅读：
true >作业队列; 尾巴 -n+0 -f 作业队列 | 并行
要将您的作业提交到队列：
回音 我的命令 我的参数 >> 作业队列
你当然可以使用 -S 将作业分发到远程计算机：
true >作业队列; 尾巴 -f 作业队列 | 并行 -S ..
使用 GNU 时有一个小问题 并行 作为队列系统/批处理管理器：您有
在它们开始之前提交 JobSlot 作业数量，之后您可以提交一个
一次，如果有空闲插槽，作业将立即开始。 从输出
正在运行或已完成的作业被阻止，只有在 JobSlots 更多作业时才会打印
已启动（除非您使用 --ungroup 或 -u，在这种情况下，作业的输出
立即打印）。 例如，如果您有 10 个工作槽，那么第一个的输出
完成的作业只会在作业 11 开始时打印，第二个的输出
完成的作业只会在作业 12 开始时打印。
使用 --eof 使 GNU 并行 出口， 尾巴 还需要强制退出：
tail -n+0 -f 命令列表.txt |
(parallel --eof=EXIT {}; echo Parallel 现在完成了;
(seq 1000 >> command-list.txt &);
回声完成附加虚拟数据迫使尾部退出）
例： GNU 并行 as DIR 处理器
如果您有一个用户放置需要处理的文件的目录，您可以在
GNU/Linux（如果你知道 通知等待 在其他平台上调用文件错误报告）：
通知等待 -q -m -r -e 搬去 -e 关闭_写入 - 格式 %w%f 我的目录 | 并行 -u 回音
这将运行命令 回音 在放入的每个文件上 我的目录 或子目录 我的目录.
你当然可以使用 -S 将作业分发到远程计算机：
通知等待 -q -m -r -e 搬去 -e 关闭_写入 - 格式 %w%f 我的目录 | 并行 -S .. -u
回音
如果要处理的文件在 tar 文件中，则解压一个文件并进行处理
立即可能比首先解压所有文件更快。 将目录处理器设置为
并解压到目录中。
使用 GNU Parallel 作为 dir 处理器与使用 GNU Parallel 作为 dir 处理器具有相同的限制
队列系统/批处理管理器。
引用
GNU 并行 在引用方面非常自由。 您只需要引用具有
shell中的特殊含义：
( ) $ ` ' " < > ; | \
根据上下文，这些也需要引用：
〜＆＃！ ? 空间 * {
因此，大多数人永远不需要比在前面加上“\”更多的引用
特殊的角色。
通常，您可以简单地将 \' 放在每个 ' 周围：
perl -ne '/^\S+\s+\S+$/ 并打印 $ARGV,"\n"' 文件
可以引用：
并行 perl -ne \''/^\S+\s+\S+$/ 并打印 $ARGV,"\n"'\' ::: file
但是，当您想使用 shell 变量时，您需要引用 $-sign。 这是一个
使用 $PARALLEL_SEQ 的示例。 此变量由 GNU 设置 并行 本身，所以
对 $ 的评估必须由 GNU 启动的子 shell 完成 并行:
以次 10 | 并行 -N2 回音 序列：\$PARALLEL_SEQ 参数 1：{1} 参数 2：{2}
如果变量设置在 GNU 之前 并行 开始你可以这样做：
VAR=this_is_set_before_starting
回音 测试 | 并行 回音 {} $增值税
印刷品： 测试 this_is_set_before_starting
如果变量在一行中包含多个空格，那就有点棘手了：
VAR="两个 剩余名额 之间 每 单词”
回音 测试 | 并行 回音 {} \'"$VAR"\'
印刷品： 测试 二 剩余名额 之间 每 字
如果启动 GNU 的 shell 不应评估该变量 并行 但要
由 GNU 启动的子 shell 评估 并行，那么你需要引用它：
回音 测试 | 并行 VAR=this_is_set_after_starting \; 回音 {} \$变量
印刷品： 测试 this_is_set_after_starting
如果变量包含空格，那就有点棘手了：
回音 测试 | 并行 VAR=""两个 剩余名额 之间 每 单词”' 回音 {} \'"$VAR"\'
印刷品： 测试 二 剩余名额 之间 每 字
$$ 是包含 shell 进程 ID 的 shell 变量。 这将打印
运行 GNU 的 shell 的进程 ID 并行:
以次 10 | 并行 回音 $$
这将打印由 GNU 启动的子 shell 的进程 ID 并行.
以次 10 | 并行 回音 \$\$
如果子 shell 不应该评估特殊字符，那么您需要
保护它免受来自启动 GNU 的 shell 的评估 并行 和子外壳：
回音 测试 | 并行 回音 {} \\$VAR
印刷品： 测试 $增值税
GNU 并行 可以通过使用 -q 来防止子 shell 的评估：
回音 测试 | 并行 -q 回音 {} \$变量
印刷品： 测试 $增值税
如果您有大量引用，这将特别有用。 如果你想运行一个 perl 脚本
喜欢这个：
perl的 - 是 '/^\S+\s+\S+$/ 和 打印 $ARGV,"\n"' 文件
它需要像这样引用：
ls | 并行 perl的 - 是 '/^\\S+\\s+\\S+\$/\ 和\ 打印\ \$ARGV,\"\\n\"' ls | 并行 perl的
- 是 \''/^\S+\s+\S+$/ 和 打印 $ARGV,"\n"'\'
注意空格、\'s、"'s 和 $'s 需要如何引用。GNU 并行 可以做引用
使用选项 -q：
ls | 并行 -q perl的 - 是 '/^\S+\s+\S+$/ 和 打印 $ARGV,"\n"'
但是，这意味着您不能让子 shell 解释特殊字符。 为了
例如因为 -q 这将不起作用：
ls *.gz | 并行 -q "zcat {} >{.}”
ls *.gz | 并行 -q "zcat {} | bzip2 >{.}.bz2"
因为 > 和 | 需要由子shell解释。
如果您收到如下错误：
sh：-c：第 0 行：意外标记附近的语法错误
sh：语法错误：未终止的带引号的字符串
sh: -c: line 0: 寻找匹配的'''时出现意外的EOF
sh: -c: 第 1 行：语法错误：文件意外结束
那么你可以尝试使用 -q.
如果您在使用 打坏 过程替换如 <(猫 富） 那你可以试试 -q 和
前置 命令 - 打坏 -c:
ls | 并行 -q 打坏 -c '厕所 -c <(回声 {})'
或者用于替换输出：
ls | 并行 -q 打坏 -c '柏油 c {} | 开球 >(压缩包 >{}.tar.gz) | bzip2 >{}.tar.bz2'
结语: 为了避免处理引用问题，只写一个可能更容易
小脚本或函数（记住 出口 -f 函数）并拥有 GNU 并行 呼叫
那。
清单 跑步 JOBS
如果您想要当前正在运行的作业列表，您可以运行：
killall -USR1 并行
GNU 并行 然后将在 stderr 上打印当前正在运行的作业（标准错误）。
完成 跑步 JOBS 但 DO 不是 主页 新品 JOBS
如果你后悔开始了很多工作，你可以简单地破坏 GNU 并行，但如果你想
确保您没有半完成的工作，您应该发送信号 目标期限 到 GNU
并行:
killall -学期 并行
这将告诉 GNU 并行 不开始任何新工作，而是等到当前
正在运行的作业在退出之前已完成。
环境 变数
$PARALLEL_PID
环境变量 $PARALLEL_PID 由 GNU 设置 并行 并且是可见的
这些工作从 GNU 开始 并行. 这使得工作有可能
直接与 GNU 沟通 并行. 记得引用 $，所以它得到
由正确的外壳评估。
计费示例： 如果每个作业都测试一个解决方案并且其中一个作业找到了解决方案
这份工作可以告诉 GNU 并行 不通过以下方式开始更多工作： 杀 -学期
$PARALLEL_PID. 这仅适用于本地计算机。
$PARALLEL_SHELL（alpha 测试）
将这个 shell 用于 GNU Parallel 运行的命令的 shell：
· $PARALLEL_SHELL。 如果未定义使用：
· 启动 GNU Parallel 的 shell。 如果无法确定：
· $SHELL。 如果未定义使用：
· / bin / sh的
$PARALLEL_SEQ
$PARALLEL_SEQ 将设置为正在运行的作业的序列号。 记得
引用 $，所以它会被正确的 shell 评估。
计费示例：
以次 10 | 并行 -N2 回音 序列：'$'PARALLEL_SEQ 参数 1：{1} 参数 2：{2}
$TMPDIR 临时文件目录。 看： --tmpdir.
$并行
环境变量 $PARALLEL 将用作 GNU 的默认选项
并行. 如果变量包含特殊的 shell 字符（例如 $、* 或空格）
那么这些需要用\转义。
计费示例：
猫 名单 | 并行 -j1 -k -v ls
可以写成：
猫 名单 | 并行=“-kvj1” 并行 ls
猫 名单 | 并行 -j1 -k -v -S"myssh 用户@服务器" ls
可以写成：
猫 名单 | 并行='-kvj1 -S 我的ssh\ 用户@服务器' 并行 回音
注意中间的 \ 是必需的，因为 'myssh' 和 'user@server' 必须是
一个论点。
DEFAULT （配置 文件）
全局配置文件/etc/parallel/config，后面是用户配置文件
~/.parallel/配置 （以前称为 .parallelrc）如果存在，将依次读取。
以“#”开头的行将被忽略。 格式可以遵循环境的格式
变量 $PARALLEL，但通常更容易将每个选项放在单独的行中。
命令行上的选项优先，其次是环境变量
$PARALLEL，用户配置文件 ~/.parallel/配置，最后是全球
配置文件 /etc/parallel/config.
请注意，没有为选项读取的文件，也没有环境变量 $PARALLEL，可能
包含已停用的选项，例如 --托勒夫.
FILES
If - 轮廓 设置，GNU 并行 将从该文件而不是全局读取配置文件
或用户配置文件。 你可以有多个 --个人资料.
示例：在每个 sshlogin 上运行命令的配置文件 〜/.ssh/sshlogins 和前置
sshlogin 的输出：
echo --tag -S .. --nonall > ~/.平行/n
并行 -Jn 正常运行时间
示例：用于运行每个命令的配置文件 -j-1 和 不错
echo -j-1 不错> 〜/.parallel/nice_profile
并行 -J nice_profile bzip2 -9 ::: *
示例：在每个命令之前运行 perl 脚本的配置文件：
echo "perl -e '\$a=\$\$; 打印 \$a,\" \",'\$PARALLEL_SEQ',\" \";';" > 〜/.parallel/pre_perl
并行 -J pre_perl echo ::: *
请注意 $ 和 " 需要如何使用 \ 引用。
示例：用于运行分布式作业的配置文件 不错 在远程计算机上：
echo -S .. 不错> ~/.平行/距离
并行 -J dist --trc {.}.bz2 bzip2 -9 ::: *
退出 状态
If --出错时停止 0 或未指定：
0 所有作业均无错误运行。
1-253 某些作业失败。 退出状态给出了失败的作业数
254 超过 253 个作业失败。
255 其他错误。
If --出错时停止 1 或 2：失败作业的退出状态。
差异性 之间 GNU 并行 AND 备择方案
有很多程序具有 GNU 的某些功能 并行。 GNU 并行
力求在不牺牲易用性的情况下包含最好的功能。
概要 表
一些可比较的工具具有以下功能：
输入
I1。 参数可以从标准输入读取
I2。 可以从文件中读取参数
I3. 可以从多个文件中读取参数
I4. 可以从命令行读取参数
I5. 可以从表中读取参数
I6. 可以使用 #! 从同一个文件中读取参数。 (shebang)
I7. 默认为面向行的输入（不需要引用特殊字符）
输入操作
M1。 组合命令
M2。 多个参数可以填满一个执行行
M3。 参数可以放在执行行的任何位置
M4。 多个参数可以放在执行行的任何位置
M5。 参数可以替换为上下文
M6. 输入可以被视为完整的执行行
输出
O1。 对输出进行分组，以便不同工作的输出不会混合
氧气。 将 stderr（标准错误）发送到 stderr（标准错误）
O3。 将 stdout（标准输出）发送到 stdout（标准输出）
O4。 输出顺序可以与输入顺序相同
O5。 Stdout 仅包含来自命令的 stdout（标准输出）
O6。 Stderr 仅包含来自命令的 stderr（标准错误）
执行
E1。 并行运行作业
E2。 列出正在运行的作业
E3. 完成正在运行的作业，但不启动新作业
E4. 正在运行的作业数量取决于 CPU 数量
E5. 完成正在运行的作业，但在第一次失败后不启动新作业
E6. 运行时可以调整运行作业的数量
远程执行
R1。 作业可以在远程计算机上运行
R2。 可以传输基本文件
R3。 可以传输参数文件
R4。 结果文件可以传输
R5。 清理传输的文件
R6。 不需要配置文件
R7。 不要运行超过 SSHD 的 MaxStartups 可以处理的
R8。 可配置的 SSH 命令
R9。 如果连接偶尔中断，请重试
信号
S1。 可以作为互斥锁工作
S2。 可以作为计数信号量工作
传说
- = 没有
x = 不适用
ID = 是
由于程序的每个新版本都没有经过测试，因此该表可能已经过时。 请提交
如果发现错误，则报告错误（请参阅报告错误）。
并行：I1 I2 I3 I4 I5 I6 I7 M1 M2 M3 M4 M5 M6 O1 O2 O3 O4 O5 O6 E1 E2 E3 E4 E5 E6 R1 R2
R3 R4 R5 R6 R7 R8 R9 S1 S2
xargs: I1 I2 - - - - - - M2 M3 - - - - O2 O3 - O5 O6 E1 - - - - - - - - -
- X - - - - -
查找 -exec: - - - x - x - - M2 M3 - - - - - O2 O3 O4 O5 O6 - - - - - - -
- - - - - - - - - xx
使 -j: - - - - - - - - - - - - - O1 O2 O3 - x O6 E1 - - - E5 - - - -
- - - - - - - -
ppss: I1 I2 - - - - I7 M1 - M3 - - M6 O1 - - x - - E1 E2 ?E3 E4 - - R1 R2 R3 R4
- - ？R7？ ? - -
pexec: I1 I2 - I4 I5 - - M1 - M3 - - M6 O1 O2 O3 - O5 O6 E1 - - E4 - E6 R1 - -
- - R6 - - - S1 -
xjobs：待办事项 - 如果您知道 xjobs 支持哪些功能，请提交错误报告（请参阅
报告错误）。
prll: TODO - 如果您知道 prll 支持哪些功能，请提交错误报告（请参阅
报告错误）。
dxargs：TODO - 如果您知道 dxargs 支持哪些功能，请提交错误报告（请参阅
报告错误）。
mdm/middelman：TODO - 如果您知道 mdm/middelman 的功能，请提交错误报告
支持（请参阅报告错误）。
xapply：TODO - 如果您知道 xapply 支持哪些功能，请提交错误报告（请参阅
报告错误）。
paexec：待办事项 - 如果您知道 paexec 支持哪些功能，请提交错误报告（请参阅
报告错误）。
ladon：待办事项 - 如果您知道 ladon 支持哪些功能，请提交错误报告（请参阅
报告错误）。
ClusterSSH：待办事项 - 如果您知道 ClusterSSH 支持哪些功能，请提交错误报告
（请参阅报告错误）。
差异性 之间 参数 AND GNU 并行
参数 提供一些与 GNU 相同的可能性 并行.
参数 处理特殊字符（如空格、' 和 "）很糟糕。要查看问题，请尝试
这个：
触摸important_file
触摸“不重要的文件”
不是* | xargs rm
mkdir -p "我兄弟的 12\" 记录"
LS | xargs rmdir
您可以指定 -0 or -d "\n"，但许多输入生成器并未针对使用进行优化 NUL
作为分隔符，但针对 新队 作为分隔符。 例如 头, 尾巴, AWK, ls, 回音,
口渴, 焦油 -v, perl的 (-0 和 \0 而不是 \n), 定位 （需要使用 -0), 发现 （需要
运用 -打印0), grep的 （需要用户使用 -z or -Z), 分类 （需要使用 -z).
所以 GNU 并行的换行符分隔可以模拟为：
猫 | 参数 -d "\n" -n1 命令
参数 可以并行运行给定数量的作业，但不支持运行数量-
并行的 CPU 核心作业。
参数 不支持对输出进行分组，因此输出可以一起运行，例如
前半行来自一个进程，后半行来自另一个进程
过程。 这个例子 并行 grep的 不能可靠地完成 参数 因为这。 到
看到这个在行动尝试：
并行 perl -e '\$a=\"1{}\"x10000000\;print\ \$a,\"\\n\"' '>' {} ::: abcdef
ls -labcdef
并行 -kP4 -n1 grep 1 > out.par ::: abcdef
回声 abcdef | xargs -P4 -n1 grep 1 > out.xargs-unbuf
回声 abcdef | xargs -P4 -n1 grep --line-buffered 1 > out.xargs-linebuf
回声 abcdef | xargs -n1 grep 1 > out.xargs-serial
ls -l 输出*
md5sum 输出*
参数 不支持保持输出的顺序，因此如果在
并行使用 参数 第二份工作的产出不能推迟到第一份工作
已经完成了。
参数 不支持在远程计算机上运行作业。
参数 不支持上下文替换，因此您必须创建参数。
如果您使用替换字符串 参数 (-I) 你不能强迫 参数 使用多个
论据。
引用 参数 像 -q 在 GNU 并行. 这意味着组合命令和
重定向需要使用 打坏 -c.
ls | 并行 “厕所 {} > {}。厕所”
变为（假设您有 8 个内核）
ls | 参数 -d "\n" - P8 -I {} 打坏 -c “厕所 {} > {}。厕所”
和
ls | 并行 “回声 {}； ls {}|wc"
变为（假设您有 8 个内核）
ls | 参数 -d "\n" - P8 -I {} 打坏 -c “回声 {}； ls {}|wc"
差异性 之间 发现 执行 AND GNU 并行
发现 执行 提供一些与 GNU 相同的可能性 并行.
发现 执行 仅适用于文件。 因此，处理其他输入（例如主机或 URL）将
需要将这些输入创建为文件。 发现 执行 不支持运行命令
平行。
差异性 之间 使 -j AND GNU 并行
使 -j 可以并行运行作业，但需要精心制作的 Makefile 来执行此操作。 结果
在额外引用中获取包含换行符的文件名以正常工作。
使 -j 不支持对输出进行分组，因此输出可以一起运行，例如
一行的前半部分来自一个进程，而该行的后半部分来自另一个进程
过程。 这个例子 并行 grep的 不能可靠地完成 使 -j 因为这。
（早期版本的 GNU 并行 巧合的是使用 使 -j).
差异性 之间 pps AND GNU 并行
pps 也是并行运行作业的工具。
输出 pps 是状态信息，因此不能用作输入
另一个命令。 作业的输出被放入文件中。
无法更改参数替换字符串 ($ITEM)。 必须引用参数 - 因此
包含特殊字符（空格 '"&!*）的参数可能会导致问题。不止一个
不支持参数。 包含换行符的文件名未正确处理。
从文件中读取输入时，null 不能用作终止符。 pps 需要阅读
开始任何作业之前的整个输入文件。
输出和状态信息存储在 ppss_dir 中，因此需要在
完全的。 如果在运行之前没有删除目录 pps 再次它可能不会造成任何影响
发生为 pps 认为任务已经完成。 GNU 并行 通常不需要
如果在本地运行，则清理，只有在异常停止时才需要清理，并且
远程运行（- 清理 如果异常停止，则可能无法完成）。 这个例子 并行
grep的 如果使用编写，将需要额外的后处理 pps.
对于远程系统，PPSS 需要 3 个步骤：配置、部署和启动。 GNU 并行 仅由
需要一步。
示例 从 pps 说明书
以下是来自的例子 pps使用 GNU 的等效手册页 并行:
1 ./ppss.sh 独立 -d /path/to/files -c 'gzip'
1 find /path/to/files -type f | 并行 gzip
2 ./ppss.sh 独立 -d /path/to/files -c 'cp "$ITEM" /destination/dir '
2 find /path/to/files -type f | 并行 cp {} /destination/dir
3 ./ppss.sh 独立 -f list-of-urls.txt -c 'wget -q '
3 并行 -a list-of-urls.txt wget -q
4 ./ppss.sh 独立 -f list-of-urls.txt -c 'wget -q "$ITEM"'
4 并行 -a list-of-urls.txt wget -q {}
5 ./ppss config -C config.cfg -c 'encode.sh' -d /source/dir -m 192.168.1.100 -u ppss -k
ppss-key.key -S ./encode.sh -n paths.txt -o /some/output/dir --upload --download ; ./ppss
部署 -C config.cfg ; ./ppss 开始 -C 配置
5 # parallel 不使用配置。 如果你想要一个不同的用户名，把它放在 node.txt 中：
用户@主机名
5 find source/dir -type f | 并行 --sshloginfile nodes.txt --trc {.}.mp3 lame -a {} -o
{.}.mp3 --preset 标准 --quiet
6 ./ppss 停止 -C config.cfg
6 killall -TERM 并行
7 ./ppss 暂停 -C config.cfg
7 按：CTRL-Z 或 killall -SIGTSTP 并行
8 ./ppss 继续 -C config.cfg
8 输入：fg 或 killall -SIGCONT 并行
9 ./ppss.sh 状态 -C config.cfg
9 killall -SIGUSR2 并行
差异性 之间 执行 AND GNU 并行
执行 也是并行运行作业的工具。
示例 从 执行 说明书
以下是来自的例子 执行的信息页面，使用 GNU 等效 并行:
1 pexec -o sqrt-%s.dat -p "$(seq 10)" -e NUM -n 4 -c -- \
'echo "scale=10000;sqrt($NUM)" | 公元前'
1 序列 10 | 并行-j4 'echo "scale=10000;sqrt({})" | bc > sqrt-{}.dat'
2 pexec -p "$(ls myfiles*.ext)" -i %s -o %s.sort -- 排序
2 ls myfiles*.ext | 并行排序 {}">{}.sort"
3 pexec -f image.list -n auto -e B -u star.log -c --\
'fistar $B.fits -f 100 -F id,x,y,flux -o $B.star'
3 并行 -a image.list \
'fistar {}.fits -f 100 -F id,x,y,flux -o {}.star' 2>star.log
4 pexec -r *.png -e IMG -c -o - -- \
'转换 $IMG ${IMG%.png}.jpeg ; “回声 $IMG：完成”'
4 ls *.png | 并行'转换{} {.}.jpeg; 回声{}：完成'
5 pexec -r *.png -i %s -o %s.jpg -c 'pngtopnm | pnmtojpeg'
5 ls *.png | 并行'pngtopnm < {} | pnmtojpeg > {}.jpg'
6 对于 *.png 中的 p ； 做回声 ${p%.png} ; 完成 | \
pexec -f - -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'
6 ls *.png | 并行'pngtopnm < {} | pnmtojpeg > {.}.jpg'
7 LIST=$(for p in *.png ; 做 echo ${p%.png} ; 完成)
pexec -r $LIST -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'
7 ls *.png | 并行'pngtopnm < {} | pnmtojpeg > {.}.jpg'
8 pexec -n 8 -r *.jpg -y unix -e IMG -c \
'pexec -j -m blockread -d $IMG | \
jpegtopnm | 微米尺度 0.5 | pnmtojpeg | \
pexec -j -m blockwrite -s th_$IMG'
8 结合 GNU 并行 和 GNU 无.
8 ls *jpg | 并行-j8 'sem --id blockread cat {} | jpegtopnm |' \
'pnmscale 0.5 | pnmtojpeg | sem --id blockwrite cat > th_{}'
8 如果对同一个磁盘进行读写，这可能会更快，因为只有一个进程
将是阅读或写作：
8 ls *jpg | 并行-j8 'sem --id diskio cat {} | jpegtopnm |' \
'pnmscale 0.5 | pnmtojpeg | sem --id diskio cat > th_{}'
差异性 之间 工作 AND GNU 并行
工作 也是并行运行作业的工具。 它仅支持在您的计算机上运行作业
本地计算机。
工作 处理特殊字符就像 参数. 见章节 差异性
之间 参数 AND GNU 并行.
以下是来自的例子 工作的手册页与使用 GNU 的等效项 并行:
1 ls -1 *.zip | xjobs 解压
1 ls *.zip | 平行解压
2 ls -1 *.zip | xjobs -n 解压
2 ls *.zip | 并行解压 >/dev/null
3 寻找 。 -name '*.bak' | xjobs 压缩包
3 寻找 。 -name '*.bak' | 并行 gzip
4 ls -1 *.jar | sed 's/\(.*\)/\1 > \1.idx/' | xjobs jar tf
4 ls *.jar | 并行 jar tf {} '>' {}.idx
5 xjobs -s 脚本
5 猫脚本| 平行线
6 mkfifo /var/run/my_named_pipe; xjobs -s /var/run/my_named_pipe & echo unzip 1.zip >>
/var/run/my_named_pipe; echo tar cf /backup/myhome.tar /home/me >> /var/run/my_named_pipe
6 mkfifo /var/run/my_named_pipe; cat /var/run/my_named_pipe | 并行 & 回声解压缩 1.zip
>> /var/run/my_named_pipe; echo tar cf /backup/myhome.tar /home/me >>
/var/run/my_named_pipe
差异性 之间 prl AND GNU 并行
prl 也是并行运行作业的工具。 它不支持运行作业
远程计算机。
prl 鼓励使用 BASH 别名和 BASH 函数而不是脚本。 GNU 并行
永远不会支持运行别名（看看为什么
http://www.perlmonks.org/index.pl?node_id=484296）。 但是，脚本、组合命令或
导出的函数 出口 -f 工作很好。
prl 在 stderr（标准错误）上生成大量状态信息，这使得它
更难将作业的 stderr（标准错误）输出直接用作另一个作业的输入
程序。
这是来自的例子 prl的手册页与使用 GNU 的等效项 并行:
prll -s 'mogrify -flip $1' *.jpg
并行 mogrify -flip ::: *.jpg
差异性 之间 参数 AND GNU 并行
参数 也是并行运行作业的工具。
参数 与 SSHD 的 MaxStartups 相比，它不能很好地处理更多的并发作业。 参数 is
仅为远程运行作业构建，但不支持文件传输。
差异性 之间 mdm/中间人 AND GNU 并行
中间人(mdm) 也是并行运行作业的工具。
这里是shellscripts http://mdm.berlios.de/usage.html 移植到 GNU 并行:
以次 19 | 并行 布冯 -o - | 分类 -n > 导致
猫 档 | 并行 CMD
发现 DIR -执行目录 无 CMD {} \;
差异性 之间 应用 AND GNU 并行
应用 可以在本地计算机上并行运行作业。
以下是来自的例子 应用的手册页与使用 GNU 的等效项 并行:
1 xapply '(cd %1 && make all)' */
1 并行 'cd {} && make all' ::: */
2 xapply -f 'diff %1 ../version5/%1' 清单 | 更多的
2 并行差异 {} ../version5/{} < 清单 | 更多的
3 xapply -p/dev/null -f 'diff %1 %2' manifest1 checklist1
3 并行 --xapply diff {1} {2} :::: manifest1 checklist1
4 xapply '缩进' *.c
4 平行缩进 ::: *.c
5 找到 ~ksb/bin -type f ！ -perm -111 -print | xapply -f -v 'chmod a+x' -
5 找到 ~ksb/bin -type f ！ -perm -111 -print | 并行 -v chmod a+x
6 查找 */ -... | fmt 960 1024 | xapply -f -i /dev/tty 'vi' -
6 sh <(find */ -... | 并行 -s 1024 echo vi)
6 查找 */ -... | 并行 -s 1024 -Xuj1 vi
7 找到... | xapply -f -5 -i /dev/tty 'vi' - - - - -
7 sh <(find ... |parallel -n5 echo vi)
7 查找 ... |parallel -n5 -uj1 vi
8 xapply -fn "" / etc / passwd文件
8 并行 -k 回声 / etc / passwd文件
9 tr ':' '\012' / etc / passwd文件 | xapply -7 -nf 'chown %1 %6' - - - - - - -
9 tr ':' '\012' / etc / passwd文件 | 并行 -N7 chown {1} {6}
10 xapply '[ -d %1/RCS ] || 回声 %1' */
10 并行'[-d {}/RCS] || 回声 {}' ::: */
11 xapply -f '[ -f %1 ] && echo %1' 列表 | ...
11 并行 '[ -f {} ] && echo {}' < 列表 | ...
差异性 之间 执行 AND GNU 并行
执行 可以在本地和远程计算机上并行运行作业。
执行 需要命令打印一个空行作为最后一个输出。 这意味着您将
必须为大多数程序编写一个包装器。
执行 具有作业依赖设施，因此作业可以依赖于要执行的另一个作业
成功地。 有点像穷人 使.
以下是来自的例子 执行的示例目录与使用 GNU 的等价物
并行:
1_div_X_run：
../../paexec -s -l -c "`pwd`/1_div_X_cmd" -n +1 <
平行回声 {} '|' `pwd`/1_div_X_cmd <
all_substr_run：
../../paexec -lp -c "`pwd`/all_substr_cmd" -n +3 <
平行回声 {} '|' `pwd`/all_substr_cmd <
cc_wrapper_run：
../../paexec -c "env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd" \
-n '主机1主机2' \
-t'/usr/bin/ssh -x' <
平行回声 {} '|' “环境 CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd”\
-S 主机1,主机2 <
# 这不完全一样，但避免了包装器
并行 gcc -O2 -c -o {.}.o {} \
-S 主机1,主机2 <
toupper_run：
../../paexec -lp -c "`pwd`/toupper_cmd" -n +10 <
平行回声 {} '|' ./toupper_cmd <
# 没有包装器：
平行回声 {} '| awk {打印\ toupper\(\$0\)}' <
差异性 之间 地图 AND GNU 并行
地图 将其视为具有较少功能的功能，并且这样做还可以处理角落
案例不正确。 很多 GNU 并行的代码是正确处理极端情况
每个平台，因此如果用户例如保存文件，您将不会感到意外
称为： My 兄弟 12“ 记录.txt
地图的示例显示如何处理特殊字符在特殊字符上失败：
echo "The Cure" > My\brother\'s\ 12\"\ records
ls | map 'echo -n `gzip < "%" | wc -c`; 回声 -n '*100/'; wc -c < "%"' | 公元前
它适用于 GNU 并行:
ls | 并行 'echo -n `gzip < {} | wc -c`; 回声 -n '*100/'; wc -c < {}' | 公元前
你甚至可以得到前面的文件名：
ls | 并行 --tag '(echo -n `gzip < {} | wc -c`'*100/'; wc -c < {}) | 公元前'
地图 不支持分组。 所以这会给出错误的结果而没有任何警告：
并行 perl -e '\$a=\"1{}\"x10000000\;print\ \$a,\"\\n\"' '>' {} ::: abcdef
ls -labcdef
并行 -kP4 -n1 grep 1 > out.par ::: abcdef
map -p 4 'grep 1' abcdef > out.map-unbuf
map -p 4 'grep --line-buffered 1' abcdef > out.map-linebuf
map -p 1 'grep --line-buffered 1' abcdef > out.map-serial
ls -l 输出*
md5sum 输出*
该文档显示了一种解决方法，但不仅混合了标准输出（标准输出）
使用 stderr （标准错误），对于某些作业，它也会完全失败（甚至可能是
认为可读性较差）：
并行回声 -n {} ::: 1 2 3
地图 -p 4 '回声 -n % 2>&1 | sed -e "s/^/$$:/"' 1 2 3 | 排序 | 剪切-f2- -d：
地图 无法处理捆绑选项： 地图 -副总裁 0 回音 Free Introduction 失败
地图 命令行上没有参数分隔符，但使用第一个参数
作为命令。 这使得引用更加困难，这又可能影响可读性。 相比：
map -p 2 perl\\\ -ne\\\ \\\'/^\\\\S+\\\\s+\\\\S+\\\$/\\\ 和\\\ print\\\ \\\$ARGV,\\\"\\\\n\\\"\\\' *
并行 -q perl -ne '/^\S+\s+\S+$/ 并打印 $ARGV,"\n"' ::: *
地图 可以使用上下文替换执行多个参数，但不能没有上下文替换：
并行 --xargs echo 'BEGIN{'{}'}END' ::: 1 2 3
地图 不根据其中一项作业是否失败设置退出值：
平行假 ::: 1 || 回显作业失败
地图假 1 || echo 从不运行
地图 需要 Perl v5.10.0 使其更难在旧系统上使用。
地图 无法在命令中使用 % （GNU Parallel 有 -I 指定另一个
替换字符串而不是 {})。
按设计 地图 是选项不兼容 参数，它没有远程作业执行，一个
保存结果的结构化方式，多个输入源，进度指示器，可配置
记录定界符（仅字段定界符），记录运行的作业并有可能恢复，
保持输出与输入的顺序相同，--pipe 处理和动态
超时。
差异性 之间 拉登 AND GNU 并行
拉登 可以在文件上并行运行多个作业。
拉登 仅适用于文件，指定文件的唯一方法是使用带引号的 glob 字符串
（如 \*.jpg）。 无法手动列出文件。
作为替换字符串，它使用 FULLPATH DIRNAME BASENAME EXT RELDIR RELPATH
这些可以使用 GNU 进行模拟 并行 通过把这个 ~/.parallel/配置:
--rpl 'FULLPATH $_=::shell_quote($_);chomp($_=qx{readlink -f $_});'
--rpl 'DIRNAME $_=::shell_quote(::dirname($_));chomp($_=qx{readlink -f $_});'
--rpl 'BASENAME s:.*/::;s:\.[^/.]+$::;'
--rpl 'EXT s:.*\.::'
--rpl 'RELDIR $_=::shell_quote($_);chomp(($_,$c)=qx{readlink -f $_;pwd});s:\Q$c/\E::; $_=::目录名($_);'
--rpl 'RELPATH $_=::shell_quote($_);chomp(($_,$c)=qx{readlink -f $_;pwd});s:\Q$c/\E::; '
拉登 对包含 " 和换行符的文件名处理不好，并且输出更大失败
超过 200k：
ladon '*' -- seq 36000 | 厕所
示例 从 拉登 说明书
假设上面的'--rpl'被放入 ~/.parallel/配置 并且它正在运行
在支持 '**' 通配符的外壳下（例如 zsh的):
1 ladon "**/*.txt" -- 回显 RELPATH
1 并行回显 RELPATH ::: **/*.txt
2 拉登”~/文件/**/*.pdf" -- shasum FULLPATH >hashes.txt
2 并行 shasum FULLPATH ::: ~/文件/**/*.pdf >hashes.txt
3 ladon -m thumbs/RELDIR "**/*.jpg" loading="lazy" -- 转换 FULLPATH -thumbnail 100x100^ -gravity
center -extent 100x100 拇指/RELPATH
3 并行 mkdir -p thumbs/RELDIR\; 转换 FULLPATH -thumbnail 100x100^ -gravity center
-extent 100x100 拇指/RELPATH ::: **/*.jpg
4 拉登”〜/音乐/*.wav" -- 蹩脚 -V 2 FULLPATH DIRNAME/BASENAME.mp3
4 并行跛脚-V 2 FULLPATH DIRNAME/BASENAME.mp3 ::: 〜/音乐/* .wav
差异性 之间 集群SSH AND GNU 并行
ClusterSSH 解决了与 GNU 不同的问题 并行.
ClusterSSH 为每台计算机打开一个终端窗口，您可以使用主窗口运行
所有计算机上的相同命令。 这通常用于管理多个
几乎一模一样的电脑。
GNU 并行 并行运行具有不同参数的相同（或不同）命令
可能使用远程计算机来帮助计算。 如果列出了不止一台计算机
-S GNU 并行 只能使用其中之一（例如，如果要运行 8 个作业，而
计算机有 8 个内核）。
GNU 并行 可以作为ClusterSSH的穷人版：
并行 --nonall -S 服务器-a，服务器-b 做东西 FOO 酒吧
使用 onworks.net 服务在线使用并行
