當前位置：首頁 > 运维知识 > linux >内容正文

linux

linux parallel 命令,Linux 并行处理神器 GNU Parallel 简明教程

發布時間：2023/12/10 linux 51 豆豆

生活随笔收集整理的這篇文章主要介紹了 linux parallel 命令,Linux 并行处理神器 GNU Parallel 简明教程小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

Bash命令通常單線程運行，這意味著所有的處理工作只在單個 CPU 上執行。隨著 CPU 規模的擴大以及核心數目的增加，這意味著只有一小部分的 CPU 資源用于處理任務，這樣就造成了很大的資源浪費。這種情況在進行多媒體轉換(比如：圖片和視頻轉換)以及數據壓縮中經常遇到。

本文我們將介紹如何使用 GNU Parallel 程序在所有 CPU 核上并行地執行計算任務。

Parallel 介紹GNU Parallel 是一種通用的并行化程序，可以在同一臺機器上或在您具有 SSH 訪問權限的多臺機器上輕松并行運行作業。

如果要在 4 個 CPU 上運行 32 個不同的作業，并行化的一種直接方法是在每個 CPU 上運行 8 個作業。

GNU Parallel 會在完成后生成一個新進程，并保持 CPU 處于活動狀態，從而節省時間。

Parallel 安裝

1. 通過包安裝

?CentOS / RHEL

$?yum?install?parallel

?Ubuntu / Debian

$?sudo?apt?install?parallel

2. 通過腳本安裝

$?(wget?-O?-?pi.dk/3?||?curl?pi.dk/3/)?|?bash

Parallel 使用

Parallel 語法簡介

Usage:parallel [options] [command [arguments]] < list_of_argumentsparallel [options] [command [arguments]] (::: arguments|:::: argfile(s))...cat ... | parallel --pipe [options] [command [arguments]]

?Parallel 常用選項

:::?后面接參數。::::?后面接文件。-j、--jobs???并行任務數，不想并行執行可以設為?1。若不加?-j，則預設為每個?CPU?執行一個?job。-N??每次輸入的參數數量。-L?N:?一次最多讀取?N?行。--xargs?會在一行中輸入盡可能多的參數。-xapply?從每一個源獲取一個參數(或文件一行)。--header??把每一行輸入中的第一個值做為參數名。-m???表示每個?job?不重復輸出“背景”(context)。-X???與?-m?相反，會重復輸出“背景文本”。-q??保護后面的命令。--trim?lr?去除參數兩頭的空格，只能去除空格，換行符和?tab?都不能去除。--keep-order/-k???強制使輸出與參數保持順序?--keep-order/-k。--tmpdir/?--results???都是保存文件，但是后者可以有結構的保存。--delay??延遲每個任務啟動時間。--halt??終止任務。--pipe????該參數使得我們可以將輸入(stdin)分為多塊(block)，再將?stdin?的資料分給各個?jobs。--block??參數可以指定每塊的大小。

Parallel 用法簡介

1. 輸入源

GNU Parallel 的輸入源支持文件、命令行和標準輸入( Stdin 或 Pipe)。

以命令行做為輸入源。

$?parallel?echo?:::?a?b?c?d?e?|?tee?a.txtabcde

以 Stdin(標準輸入)作為輸入源。

$?cat?a.txt?|?parallel?echoabcde

GNU Parallel 支持通過命令行指定多個輸入源，它會生成所有的組合。

$?parallel?echo?:::?A?B?C?:::?D?E?F?|?tee?b.txtA?DA?EA?FB?DB?EB?FC?DC?EC?F

多個文件作為輸入，此時多個文件中的內容也會像上面那樣進行組合。

$?parallel?-a?a.txt?-a?b.txt?echo

Stdin(標準輸入)作為文件源中的一個，使用 -，輸出結果同上。

$?cat?a.txt?|parallel?-a?-?-a?b.txt?echo

使用?::::?代替?-a，后面可接多個文件名。

$?cat?a.txt?|?parallel?echo?::::?-?b.txt

:::?和?::::?可以同時使用，同樣的輸出結果也會進行組合。

$?parallel?echo?:::?a?b?::::?b.txt

當然，若不想像上面那樣進行組合，可使用--xapply參數從每一個源獲取一個參數(或文件一行)，這個參數有些類似 R 中的函數，具有廣播作用。如果其中一個輸入源的長度比較短，它的值會被重復。

$ parallel --xapply echo ::: A B C ::: D E FA DB EC F$ parallel --xapply echo ::: A B C ::: D E F G H IA DB EC FA GB HC I

2. 改變參數分隔符

GNU Parallel 可以通過?--arg-sep?和?--arg-file-sep?指定分隔符替代?:::?或?::::，當這兩個符號被其它命令占用的時候會特別有用。

$parallel -k --arg-sep ,,, echo ,,, a b ,,, c d | tee c.txta ca db cb d$parallel?--xapply?--arg-file-sep?,,,,?echo?,,,,?a.txt??b.txta A Db A Ec A Fd B De B Ea B Fb C Dc C Ed C F

3. 改變輸入分隔符

GNU Parallel 默認把一行做為一個參數。使用?\n?做為參數定界符，可以使用?-d?改變。

$ parallel -d b echo :::: a.txtacde

4. 提前結束和跳過空行

GNU Parallel 支持通過?-E?參數指定一個值做為結束標志。

$?parallel?-E?stop?echo?:::?A?B?stop?C?DAB

GNU Parallel 使用?--no-run-if-empty?來跳過空行。

$?(echo?1;?echo;?echo?2)?|?parallel?--no-run-if-empty?echo12

5. 構建命令行

如果 Parallel 之后沒有給定命令，那么這些參數會被當做命令。

$?parallel?:::?ls?'echo?foo'?pwda.txtb.txtc.txtjianchenmypipescriptssnake_testWGS_snakefoo/home/sxuan

此外，命令還可以是一個腳本文件，一個二進制可執行文件或一個Bash的函數(須用export -f導出函數)。

$?echo?"echo?\$*"?>?s.sh$?parallel?./s.sh?:::?"a?b?c?f"?"1?2?3?4"a?b?c?f1?2?3?4

6. 替換字符串

GNU Parallel 支持多種替換字符串，默認使用 {}，使用?-I?改變替換字符串符號 {}。

其最常見的字符串替換包括以下幾種：

?{.}，去掉擴展名?{/},去掉路徑，只保留文件名?{//}，只保留路徑?{/.}，同時去掉路徑和擴展名?{#}，輸出任務編號

同時對于每一個字符串替換都可以自己指定符號：

?-I 對應{}?--extensionreplace 替換 {.}?--basenamereplace 替換 {/}?--dirnamereplace 替換 {//}?--basenameextensionreplace 替換 {/.}?--seqreplace 替換 {#}

$ parallel echo ::: A/B.C ; parallel echo {} ::: A/B.C ; parallel -I ,, echo ,, ::: A/B.CA/B.CA/B.CA/B.C$ parallel echo {.} ::: A/B.C ; parallel --extensionreplace ,, echo ,, ::: A/B.CA/BA/B$ parallel echo {/} ::: A/B.C ; parallel --basenamereplace ,, echo ,, ::: A/B.CB.CB.C$ parallel echo {//} ::: A/B.C ; parallel --dirnamereplace ,, echo ,, ::: A/B.CAA$ parallel echo {/.} ::: A/B.C ; parallel --basenameextensionreplace ,, echo ,, ::: A/B.CBB$ parallel echo {#} ::: A B C ; parallel --seqreplace ,, echo ,, ::: A B C123123

同時，如果有多個輸入源時，可以通過 {編號} 指定某一個輸入源的參數。

$?parallel?--xapply??echo?{1}?and?{2}?:::?A?B?:::?C?DA?and?CB?and?D

可以使用?/?//?/.?和?.?改變指定替換字符串。

$?parallel?echo?/={1/}?//={1//}?/.={1/.}?.={1.}?:::?A/B.C?D/E.F/=B.C?//=A?/.=B?.=A/B/=E.F?//=D?/.=E?.=D/E

位置可以是負數，表示倒著數。

$?parallel?echo?1={1}?2={2}?3={3}?-1={-1}?-2={-2}?-3={-3}?:::?A?B?:::?C?D?:::?E?F1=A?2=C?3=E?-1=E?-2=C?-3=A1=A?2=C?3=F?-1=F?-2=C?-3=A1=A?2=D?3=E?-1=E?-2=D?-3=A1=A?2=D?3=F?-1=F?-2=D?-3=A1=B?2=C?3=E?-1=E?-2=C?-3=B1=B?2=C?3=F?-1=F?-2=C?-3=B1=B?2=D?3=E?-1=E?-2=D?-3=B1=B?2=D?3=F?-1=F?-2=D?-3=B

7. 按列輸入和指定參數名

使用?--header?把每一行輸入中的第一個值做為參數名。

$?parallel?--xapply?--header?:?echo?f1={f1}?f2={f2}?:::?f1?A?B?:::?f2?C?D?|?tee?d.txtf1=A?f2=Cf1=B?f2=D

使用?--colsep?把文件中的行切分為列，做為輸入參數。

$?perl?-e?'printf?"f1\tf2\nA\tB\nC\tD\n"'?>?tsv-file.tsv$?parallel?--header?:?--colsep?'\t'?echo?f1={f1}?f2={f2}?::::?tsv-file.tsv?f1=A?f2=Bf1=C?f2=D

8. 多參數

--xargs?會在一行中輸入盡可能多的參數(與參數字符串長度有關)，通過?-s?可指定一行中參數的上限。

$ perl -e 'for(1..30000){print "$_\n"}' > num30000$ cat num30000 | parallel --xargs echo | wc -l3$ cat num30000 | parallel --xargs -s 10000 echo | wc -l17

為了獲得更好的并發性，GNU Parallel 會在文件讀取結束后再分發參數。

GNU Parallel 在讀取完最后一個參數之后，才開始第二個任務，此時會把所有的參數平均分配到 4 個任務(如果指定了4個任務)。

第一個任務與上面使用?--xargs?的例子一樣，但是第二個任務會被平均的分成 4 個任務，最終一共 5 個任務。

$?cat?num30000?|?parallel?--jobs?4?-m?echo?|?wc?-l5

將 1-10 分參數分配到4個任務可以看得更清晰。

$?parallel?--jobs?4?-m?echo?:::?{1..10}1?2?34?5?67?8?910

替換字符串可以是輸出字符的一部分，使用?-m?參數表示每個 job 不重復輸出 “背景”(context)，-X?則與?-m?相反，會重復輸出 “背景文本”，具體通過下面幾個例子進行理解。

$ parallel --jobs 4 echo pre-{}-post ::: A B C D E F Gpre-A-postpre-B-postpre-C-postpre-D-postpre-E-postpre-F-postpre-G-post$ parallel --jobs 4 -m echo pre-{}-post ::: A B C D E F Gpre-A B-postpre-C D-postpre-E F-postpre-G-post$ parallel --jobs 4 -X echo pre-{}-post ::: A B C D E F Gpre-A-post pre-B-postpre-C-post pre-D-postpre-E-post pre-F-postpre-G-post

使用?-N?限制每行參數的個數，其中?-N0?表示一次只讀取一個參數，且不輸入這個參數(作為計數器來使用)。

$ parallel -N4 echo 1={1} 2={2} 3={3} ::: A B C D E F G H1=A 2=B 3=C1=E 2=F 3=G$parallel -N0 echo foo ::: 1 2 3foofoofoo

9. 引用

如果命令行中包含特殊字符，就需要使用引號保護起來。

Perl 腳本?'print "@ARGV\n"'?與 Linux 的?echo?的功能一樣。

$?perl?-e?'print?"@ARGV\n"'?AA

使用 GNU Parallel 運行這條命令的時候，Perl 命令需要用引號包起來，也可以使用?-q?保護?Perl?命令。

$ parallel perl -e 'print "@ARGV\n"' ::: This wont work$parallel -q perl -e 'print "@ARGV\n"' ::: This worksThisworks$ parallel perl -e \''print "@ARGV\n"'\' ::: This works, tooThisworks,too

10. 去除空格

使用--trim去除參數兩頭的空格。

$ parallel --trim r echo pre-{}-post ::: ' A 'pre- A-post$ parallel --trim l echo pre-{}-post ::: ' A 'pre-A -post$ parallel --trim lr echo pre-{}-post ::: ' A 'pre-A-post

11. 控制輸出

使用?--tag?以參數做為輸出前綴，使用?--tagstring?修改輸出前綴。

$ parallel --tag echo foo-{} ::: A B CA ? foo-AB ? foo-BC ? foo-C$ parallel --tagstring {}-bar echo foo-{} ::: A B CA-bar ? foo-AB-bar ? foo-BC-bar ? foo-C

--dryrun?作用類似于 echo 。

$ parallel --dryrun echo {} ::: A B Cecho Aecho Becho C$ parallel echo {} ::: A B CABC

--verbose?則在運行之前先打印命令。

$?parallel?--verbose?echo?{}?:::?A?B?Cecho?Aecho?Becho?CABC

一般來說，GNU Parallel 會延遲輸出，直到一組命令執行完成。使用?--ungroup，可立刻打印輸出已完成部分。

$ parallel -j2 'printf "%s-start\n%s" {} {};sleep {};printf "%s\n" -middle;echo {}-end' ::: 4 2 12-start2-middle2-end1-start1-middle1-end4-start4-middle4-end$ parallel -j2 --ungroup 'printf "%s-start\n%s" {} {};sleep {};printf "%s\n" -middle;echo {}-end' ::: 4 2 14-start42-start2-middle2-end1-start1-middle1-end-middle4-end

使用?--ungroup?會很快，但會導致輸出錯亂，一個任務的行輸出可能會被另一個任務的輸出截斷。像上例所示，第二行輸出混合了兩個任務：'4-middle' '2-start'。使用?--linebuffer?避免這個問題(稍慢一點)。

4-start2-start2-middle2-end1-start1-middle1-end4-middle4-end

強制使輸出與參數保持順序?--keep-order/-k。

$?parallel?-j2?-k?'printf?"%s-start\n%s"?{}?{};sleep?{};printf?"%s\n"?-middle;echo?{}-end'?:::?4?2?14-start4-middle4-end2-start2-middle2-end1-start1-middle1-end

12. 將輸出保存到文件

GNU Parallel 可以把每一個任務的輸出保存到文件中，臨時文件默認保存在 /tmp 中，可以使用?--tmpdir?改變(或者修改 $TMPDIR)。

$ parallel --files ::: A B C/tmp/parfmNTJ.par/tmp/parmioFz.par/tmp/pargaTxf.par$ parallel --tmpdir ~ --files ::: A B C/home/sxuan/parLEXH7.par/home/sxuan/parXsKsR.par/home/sxuan/parZxytI.par$ TMPDIR=~ parallel --files ::: A B C/home/sxuan/par2tX6C.par/home/sxuan/parorPJy.par/home/sxuan/pari5TkI.par

輸出文件可以有結構的保存?--results，輸出文件不僅包含標準輸出(stdout)也會包含標準錯誤輸出(stderr)。

$ parallel --results outdir echo ::: A B CABC$ tree outdir/outdir/└── 1├── A│ ? ├── seq│ ? ├── stderr│ ? └── stdout├── B│ ? ├── seq│ ? ├── stderr│ ? └── stdout└── C├── seq├── stderr└── stdout4 directories, 9 files

在使用多個變量的時候會顯得很有用。

# --header : will take the first value as name and use that in the directory structure.$ parallel --header : --results outdir echo ::: f1 A B ::: f2 C DA CA DB CB D$ tree outdir/outdir/└── f1├── A│ ? └── f2│ ? ? ? ├── C│ ? ? ? │ ? ├── seq│ ? ? ? │ ? ├── stderr│ ? ? ? │ ? └── stdout│ ? ? ? └── D│ ? ? ? ? ? ├── seq│ ? ? ? ? ? ├── stderr│ ? ? ? ? ? └── stdout└── B└── f2├── C│ ? ├── seq│ ? ├── stderr│ ? └── stdout└── D├── seq├── stderr└── stdout9 directories, 12 files

13. 控制執行

使用?--jobs/-j?指定并行任務數。

使用 64 個任務執行 128 個休眠命令。

$ time parallel -N0 -j64 sleep 1 ::: {1..128}real ? ?0m2.759suser ? ?0m0.657ssys 0m1.345s

默認情況下并行任務數與 Cpu 核心數相同, 所以這條命令會比每個 Cpu 兩個任務的耗時多一倍。

$ time parallel -N0 sleep 1 ::: {1..128}real ? ?0m3.478suser ? ?0m0.656ssys 0m1.344s# 每個 Cpu 兩個任務$ time parallel -N0 --jobs 200% sleep 1 ::: {1..128}real ? ?0m2.659suser ? ?0m0.734ssys 0m1.423s

使用?--jobs 0?表示執行盡可能多的并行任務。

$ time parallel -N0 --jobs 0 sleep 1 ::: {1..128}real ? ?0m2.135suser ? ?0m0.651ssys 0m1.477s

除了基于 Cpu 使用率之外，也可以基于 Cpu 數。

$ time parallel --use-cpus-instead-of-cores -N0 sleep 1 ::: {1..128}real ? ?1m5.499suser ? ?0m0.950ssys 0m1.897s

14. 交互

通過使用?--interactive?在一個任務執行之前讓用戶決定是否執行。

$?parallel?--interactive?echo?:::?1?2?3echo?1??...yecho?2??...yecho?3??...y123

15. 耗時

當 job 有大量的 IO 操作時，為避免“驚群效應”，可使用?--delay?參數指定各個 job 開始的時間間隔。

$?parallel?--delay?2.5?echo?Starting?{}\;date?:::?1?2?3Starting?1Tue?Apr?17?15:21:41?CST?2018Starting?2Tue?Apr?17?15:21:44?CST?2018Starting?3Tue?Apr?17?15:21:46?CST?2018

若已知任務超過一定時間未反應則為失敗則可以通過?--timeout?指定等待時間避免無謂的等待。

GNU Parallel 能計算所有任務運行時間的中位數，因此可以指定時間為中位數的倍數關系。

$ parallel --timeout 4.1 sleep {}\; echo {} ::: 2 4 6 824$ parallel --timeout 200% sleep {}\; echo {} ::: 2.1 2.2 3 7 2.32.12.22.33

16. 顯示任務進度信息

GNU Parallel 有多種方式可用來動態的顯示任務進度信息，如：

$?parallel?--eta?sleep?:::?1?3?2?2?1?3?3?2?1$?parallel?--progress?sleep?:::?1?3?2?2?1?3?3?2?1$?seq?1000?|?parallel?-j10?--bar?'(echo?-n?{};sleep?0.1)'??2>?>(zenity?--progress?--auto-kill?--auto-close)

使用?--joblog?參數能夠生成各個任務的日志文件。

$?parallel?--joblog?/tmp/log?exit??:::?1?2?3?0$?cat?/tmp/log?Seq?Host????Starttime???JobRuntime??Send????Receive?Exitval?Signal??Command1???:???1523950890.344???????0.018??0???0???1???0???exit?12???:???1523950890.350???????0.014??0???0???2???0???exit?23???:???1523950890.357???????0.006??0???0???3???0???exit?34???:???1523950890.363???????0.006??0???0???0???0???exit?0

通過?--resume-failed?參數可以重新運行失敗的任務。

--retry-failed?的作用與?--resume-failed類似，只是?--resume-failed?從命令行讀取失敗任務，而?--retry-failed?則是從日志文件中讀取失敗任務。

$ parallel --resume-failed --joblog /tmp/log exit ?::: 1 2 3 0 0 0$ cat /tmp/logSeq Host ? ?Starttime ? JobRuntime ?Send ? ?Receive Exitval Signal ?Command1 ? : ? 1523950890.344 ? ? ? 0.018 ?0 ? 0 ? 1 ? 0 ? exit 12 ? : ? 1523950890.350 ? ? ? 0.014 ?0 ? 0 ? 2 ? 0 ? exit 23 ? : ? 1523950890.357 ? ? ? 0.006 ?0 ? 0 ? 3 ? 0 ? exit 34 ? : ? 1523950890.363 ? ? ? 0.006 ?0 ? 0 ? 0 ? 0 ? exit 01 ? : ? 1523951289.575 ? ? ? 0.029 ?0 ? 0 ? 1 ? 0 ? exit 12 ? : ? 1523951289.580 ? ? ? 0.025 ?0 ? 0 ? 2 ? 0 ? exit 23 ? : ? 1523951289.585 ? ? ? 0.019 ?0 ? 0 ? 3 ? 0 ? exit 35 ? : ? 1523951289.591 ? ? ? 0.013 ?0 ? 0 ? 0 ? 0 ? exit 06 ? : ? 1523951289.604 ? ? ? 0.004 ?0 ? 0 ? 0 ? 0 ? exit 0$ parallel --retry-failed --joblog /tmp/log$ cat /tmp/logSeq Host ? ?Starttime ? JobRuntime ?Send ? ?Receive Exitval Signal ?Command1 ? : ? 1523950890.344 ? ? ? 0.018 ?0 ? 0 ? 1 ? 0 ? exit 12 ? : ? 1523950890.350 ? ? ? 0.014 ?0 ? 0 ? 2 ? 0 ? exit 23 ? : ? 1523950890.357 ? ? ? 0.006 ?0 ? 0 ? 3 ? 0 ? exit 34 ? : ? 1523950890.363 ? ? ? 0.006 ?0 ? 0 ? 0 ? 0 ? exit 01 ? : ? 1523951289.575 ? ? ? 0.029 ?0 ? 0 ? 1 ? 0 ? exit 12 ? : ? 1523951289.580 ? ? ? 0.025 ?0 ? 0 ? 2 ? 0 ? exit 23 ? : ? 1523951289.585 ? ? ? 0.019 ?0 ? 0 ? 3 ? 0 ? exit 35 ? : ? 1523951289.591 ? ? ? 0.013 ?0 ? 0 ? 0 ? 0 ? exit 06 ? : ? 1523951289.604 ? ? ? 0.004 ?0 ? 0 ? 0 ? 0 ? exit 01 ? : ? 1523951445.089 ? ? ? 0.013 ?0 ? 0 ? 1 ? 0 ? exit 12 ? : ? 1523951445.094 ? ? ? 0.009 ?0 ? 0 ? 2 ? 0 ? exit 23 ? : ? 1523951445.102 ? ? ? 0.007 ?0 ? 0 ? 3 ? 0 ? exit 3

17.? 終止任務

GNU Parallel 支持在某一情況下(如第一個失敗或成功時，或者 20% 任務失敗時)終止任務。

終止任務又有兩種類型：

?其一為立即終止(通過?--halt now?指定)，殺死所有正在運行的任務并停止生成新的任務。?其二為稍后終止(通過?--halt soon?指定)，停止生成新任務并等待正在運行任務完成。

$ parallel -j2 --halt soon,fail=1 echo {}\; exit {} ::: 0 0 1 2 3001parallel: This job failed:echo 1; exit 1parallel: Starting no more jobs. Waiting for 1 jobs to finish.2parallel: This job failed:echo 2; exit 2$ parallel -j2 --halt now,fail=1 echo {}\; exit {} ::: 0 0 1 2 3001parallel: This job failed:echo 1; exit 1$ parallel -j2 --halt soon,fail=20% echo {}\; exit {} ::: 0 1 2 3 4 5 6 7 8 901parallel: This job failed:echo 1; exit 12parallel: This job failed:echo 2; exit 2parallel: Starting no more jobs. Waiting for 1 jobs to finish.3parallel: This job failed:echo 3; exit 3$ parallel -j2 --halt now,success=1 echo {}\; exit {} ::: 1 2 3 0 4 5 61230parallel: This job succeeded:echo 0; exit 0

GNU Parallel 還支持在任務失敗后重試運行?--retries。

$ parallel -k --retries 3 'echo tried {} >>/tmp/runs; echo completed {}; exit {}' ::: 1 2 0completed 1completed 2completed 0$ cat /tmp/runstried 1tried 2tried 0tried 1tried 2tried 1tried 2

關于終止信號的高級用法參考官方入門文檔。

18. 資源限制

GNU Parallel 能夠在開始一個新的任務前檢查系統的負載情況防止過載(通過?--load?可指定負載)，同時還能檢查系統是否使用了交換空間 Swap(通過?--noswap?限制使用 Swap)。

$ parallel --load 100% echo load is less than {} job per cpu ::: 1load is less than 1 job per cpu$ parallel --noswap echo the system is not swapping ::: nowthe system is not swapping now

同時，對于某些占用內存較多的程序，Parallel 會檢查內存只有內存滿足時才啟動任務(通過?--memfree?指定需要內存大小)，而且在啟動任務后內存不夠 50% 時會殺掉最新開始的任務，直到這個任務完成再重新開始那些殺死的任務。

$?parallel?--memfree?1G?echo?will?run?if?more?than?1?GB?is?:::?freewill?run?if?more?than?1?GB?is?free

還可以通過?--nice?來指定任務的優先級。

$?parallel?--nice?17?echo?this?is?being?run?with?nice?-n?:::?17this?is?being?run?with?nice?-n?17

19. 遠程操作

可使用?-S host來進行遠程登陸。

$?parallel?-S?username@$SERVER1?echo?running?on?:::?username@$SERVER1

20. 文件傳輸

GNU Parallel 文件傳輸使用的是 Rsync。

$?echo?This?is?input_file?>?input_file$?parallel?-S?$SERVER1?--transferfile?{}?cat?:::?input_file

更多遠程操作參見官方入門文檔。

21. --pipe

--pipe?參數使得我們可以將輸入(stdin)分為多塊(block)，然后分配給多個任務多個 Cpu 以達到負載均衡，最后的結果順序與原始順序一致。

使用?--block?參數可以指定每塊的大小，默認為 1M。

$?perl?-e?'for(1..1000000){print?"$_\n"}'?>?num1000000$?cat?num1000000?|?parallel?--pipe?wc?165668??165668?1048571?149796??149796?1048572?149796??149796?1048572?149796??149796?1048572?149796??149796?1048572?149796??149796?1048572??85352???85352??597465

如果不關心結果順序，只想要快速的得到結果，可使用?--round-robin?參數。

沒有這個參數時每塊文件都會啟動一個命令，使用這個參數后會將這些文件塊分配給 job 數任務(通過?--jobs?進行指定)。若想分配更為均勻還可同時指定?--block?參數。

$ cat num1000000 | parallel --pipe -j4 --round-robin wc299592 ?299592 2097144315464 ?315464 2097143149796 ?149796 1048572235148 ?235148 1646037$ cat num1000000 | parallel --pipe -j4 --block 2M --round-robin wc299593 ?299593 2097151315465 ?315465 2097150299593 ?299593 209715185349 ? 85349 ?597444

Parallel 使用實例

下面來看一個實際的使用 Parallel 的例子可能會更容易理解一些。

?使用 Parallel 來進行 JPEG 壓縮

下面是一個普通的?find?命令，用來找出當前目錄中的所有 .jpg 文件，然后通過 MozJPEG 包中提供的圖像壓縮工具?cjpeg?對其進行處理。

$?find?.?-type?f?-name?"*.jpg"?-exec?cjpeg?-outfile?LoRes/{}?{}?';'

總共耗時 0m44.114s。從 top 運行結果可以看到，雖然有 8 個核可用，但實際只有單個線程在用單個核。

下面用 Parallel 來運行相同的命令。

$?find?.?-type?f?-name?"*.jpg"?|?parallel?cjpeg?-outfile?LoRes/{}?{}

這次壓縮所有圖像的時間縮減到了 0m10.814s。從 top 運行結果可以看到，所有 CPU 核都滿負荷運行，有 8 個線程對應使用 8 個 CPU 核。

參考文檔

https://www.google.comhttp://t.cn/E6KnjtP

http://t.cn/E6KB5Rr

http://t.cn/E69yv3g

http://t.cn/Rm9X2WC

http://t.cn/E6Wr74r

今日思想

什么是成功?每個人眼里的成功都不一樣。我認為，成功不是別人覺得你成功就是成功，成功是一種內心深處的自我感受。我不認為自己是成功者，也不認為自己是失敗者，我只是在追求內心的一些東西，在路上！

——?雷軍

總結

以上是生活随笔為你收集整理的linux parallel 命令,Linux 并行处理神器 GNU Parallel 简明教程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：介绍最全的LVS负载均衡技术
下一篇：解析 Linux 中的 VFS 文件系统