Externe Befehle meistern: Bash-Skript-Performance optimieren

Das schnellste Bash-Skript ist oft das, das weniger Programme startet.

Bash eignet sich gut für Klebearbeiten: eine Datei lesen, entscheiden, was zu tun ist, ein anderes Tool starten, den Exit-Status prüfen und weitermachen. Es ist keine Hochleistungs-Datenverarbeitungssprache. Die Falle besteht darin, Bash so zu verwenden, als ob jede winzige String-Operation sed benötigt, jeder Vergleich expr und jede Dateischleife ein neues grep. Dieser Stil funktioniert bei zehn Zeilen. Bei 200.000 Zeilen wird er schmerzhaft.

Die Kosten sind der Prozessstart. Wenn ein Skript grep, sed, awk, cut, tr, date oder basename ausführt, muss die Shell einen weiteren Prozess erstellen und darauf warten. Ein einzelner Aufruf ist kein Problem. Ein einzelner Aufruf innerhalb einer großen Schleife ist ein Muster, das es zu beheben lohnt.

Beginnen Sie damit, nach Befehlen innerhalb von Schleifen zu suchen:

grep -nE 'for |while ' script.sh
grep -nE 'grep|sed|awk|cut|tr|expr|basename|dirname|cat' script.sh

Das bedeutet nicht, dass jeder Treffer schlecht ist. Ein einzelnes awk über eine ganze Datei ist normalerweise in Ordnung. Ein sed, das einmal pro Zeile gestartet wird, ist die Art von Sache, die ein Wartungsskript während eines Deployments in einen mysteriösen Ausfall verwandelt.

Kleine externe Aufrufe durch Bash selbst ersetzen

Die einfachsten Erfolge sind Arithmetik, String-Länge, Präfixe, Suffixe und einfache Ersetzungen. Bash kann diese bereits.

Externe Arithmetik:

# Verwendet das externe Dienstprogramm 'expr'
RESULT=$(expr $A + $B)

Eingebaute Arithmetik:

RESULT=$((A + B))

Externe String-Ersetzung:

MY_STRING="hello world"
NEW_STRING=$(echo "$MY_STRING" | sed 's/world/universe/')

Parameterexpansion:

MY_STRING="hello world"
NEW_STRING=${MY_STRING/world/universe}
printf '%s\n' "$NEW_STRING"

Aufgabe	Ineffiziente Methode (Extern)	Effiziente Methode (Eingebaut)
Teilstring-Extraktion	`echo "$STR"	cut -c 1-5`
Längenprüfung	expr length "$STR"	${#STR}
Suffix entfernen	basename "$file" .log	${file%.log}
Pfad entfernen	basename "$path"	${path##*/}
Dateiname entfernen	dirname "$path"	${path%/*}
Erste Übereinstimmung ersetzen	sed 's/foo/bar/'	${value/foo/bar}
Alle Übereinstimmungen ersetzen	sed 's/foo/bar/g'	${value//foo/bar}

Bevorzugen Sie [[ ... ]] für Bash-Bedingungen. Es ist ein Shell-Schlüsselwort, behandelt Mustervergleiche sauber und vermeidet einige Überraschungen bei der Anführungszeichensetzung, die bei [ ... ] auftreten.

if [[ $name == *.log && -s $name ]]; then
  printf 'nicht-leeres Log: %s\n' "$name"
fi

Übertreiben Sie es nicht. Die Bash-Musterersetzung ist keine vollständige Regex-Engine. Wenn die Regel wirklich komplex ist, ist ein einzelner awk- oder perl-Durchlauf sauberer und normalerweise schneller als eine ausgeklügelte Shell-Expansion.

Batch-Verarbeitung statt Wiederholung

Wenn ein Tool viele Eingaben in einem Durchlauf verarbeiten kann, geben Sie ihm viele Eingaben. Dies ist am wichtigsten für grep, awk, sed, find, Komprimierungstools, Upload-Clients und alles, was eine Verbindung zu einem Netzwerkdienst herstellt.

Diese Schleife startet ein grep pro Datei:

for file in *.log; do
  grep "ERROR" "$file" > "${file}.errors"
done

Wenn Sie nur ein kombiniertes Ergebnis benötigen, verwenden Sie ein einziges grep:

grep "ERROR" *.log > all_errors.txt

Wenn Sie eine Ausgabe pro Datei benötigen, überlegen Sie, ob die Aufteilung wirklich erforderlich ist. Manchmal kann das nachgelagerte Tool ein Dateinamen-Präfix von grep -H lesen:

grep -H "ERROR" *.log > errors-with-filenames.txt

Für zeilenorientierte Transformationen fassen Sie einfache grep | awk-Ketten in einem einzigen awk-Programm zusammen:

awk '/data/ {print $1}' input.txt | sort > output.txt

Das führt immer noch sort aus, und das ist in Ordnung. Sortieren ist genau die Art von Aufgabe, die ein externes Tool erledigen sollte. Die nützliche Änderung ist das Entfernen des nutzlosen cat und des separaten grep.

Dateien ohne cat lesen

Die Standard-Zeilenleseschleife ist aus gutem Grund langweilig:

while IFS= read -r line; do
  printf 'Verarbeite: %s\n' "$line"
done < file.txt

IFS= bewahrt führende und nachfolgende Leerzeichen. -r verhindert, dass read Backslashes als Escapezeichen behandelt. Die Umleitung hält die Schleife in der aktuellen Shell, was wichtig ist, wenn die Schleife Variablen aktualisiert, die Sie später benötigen.

Diese Version sieht harmlos aus, ist aber normalerweise schlechter:

cat file.txt | while read -r line; do
  count=$((count + 1))
done
printf '%s\n' "$count"

In Bash läuft ein Pipeline-Segment üblicherweise in einer Subshell, sodass count möglicherweise nicht in der Eltern-Shell aktualisiert wird. Außerdem wird cat ohne Nutzen gestartet.

Verwenden Sie Prozesssubstitution, wenn die Eingabe tatsächlich von einem Befehl erzeugt wird:

while IFS= read -r file; do
  printf 'große Datei: %s\n' "$file"
done < <(find /var/log -type f -size +100M)

Hier leistet find echte Arbeit. Die Schleife in der aktuellen Shell zu halten, ist immer noch nützlich.

find -exec ... + und xargs sorgfältig verwenden

Dateischleifen sind eine häufige Quelle für versehentliche Langsamkeit:

for file in $(find . -name '*.tmp'); do
  rm "$file"
done

Das bricht bei Leerzeichen und startet rm wiederholt. Verwenden Sie Batch-Ausführung:

find . -name '*.tmp' -exec rm -f {} +

Die +-Form übergibt viele Pfade an jeden rm-Aufruf. Die ältere \;-Form führt den Befehl einmal pro Pfad aus.

Für Befehle, die von Parallelität profitieren, kann xargs -P die Wanduhrzeit reduzieren:

xargs -n 1 -P 4 curl -fsS -O < urls.txt

Verwenden Sie -0, wenn Dateinamen beteiligt sind:

find uploads -type f -print0 | xargs -0 -n 50 -P 4 ./process-file

Parallelität ist nicht kostenlos. Vier curl-Jobs können schneller sein als einer. Vierzig können von einer API gedrosselt werden oder einen kleinen Host sättigen.

Messen, bevor Sie alles umschreiben

Die richtige Optimierung hängt davon ab, wo die Zeit verbraucht wird. Verwenden Sie zuerst einfaches Timing:

time ./script.sh

Bei prozessintensiven Skripten kann strace -c unter Linux zeigen, ob das Skript Zeit mit dem Erstellen von Prozessen, dem Öffnen von Dateien oder dem Warten auf E/A verbringt:

strace -f -c ./script.sh

Shell-Tracing kann wiederholte Befehle aufdecken:

PS4='+ $SECONDS ${BASH_SOURCE}:${LINENO}: '
bash -x ./script.sh

Wenn das Skript 95 Prozent seiner Zeit mit dem Warten auf einen Datenbankexport verbringt, wird das Ersetzen von ${value/foo/bar} nichts bewirken. Wenn es sed 300.000 Mal ausführt, schon.

Wissen, wann externe Tools besser sind

Ziel	Bestes Tool (Allgemein)	Anmerkungen
Feldextraktion und -filterung	awk	Besser als Bash-Schleifen für tabellarischen Text.
Stream-Editing	sed	Gut für einen Durchlauf über eine Datei.
Dateidurchlauf	find	Sicherer als das Parsen von ls.
JSON	jq	JSON nicht mit cut parsen.
Parallele Jobs	xargs -P oder GNU parallel	Grenzen setzen und Fehler behandeln.
Große Textverarbeitung	awk, perl, Python	Oft klarer als heroisches Bash.

Bash-Built-ins sind schnell, aber die Wartbarkeit gewinnt trotzdem. Ich würde lieber ein klares awk-Skript warten als 40 Zeilen fragiler Parameterexpansion, die nur der ursprüngliche Autor versteht.

Eine praktische Überprüfungs-Checkliste

Wenn ein Bash-Skript sich langsam anfühlt, gehen Sie es in dieser Reihenfolge durch:

1. Finden Sie externe Befehle innerhalb von Schleifen.
2. Ersetzen Sie einfache Arithmetik- und String-Operationen durch Bash-Expansion.
3. Entfernen Sie nutzlose cat-Aufrufe.
4. Bündeln Sie Dateiargumente mit grep, awk, sed, find -exec ... + oder xargs.
5. Halten Sie Zeilenleseschleifen in der aktuellen Shell, wenn Variablen die Schleife überleben müssen.
6. Messen Sie erneut.

Sie müssen nicht jedes Skript in eine Benchmark-Übung verwandeln. Die großen Erfolge kommen normalerweise von ein paar offensichtlichen Stellen: ein Befehl pro Zeile, ein Befehl pro Datei oder ein Befehl pro API-Element. Beheben Sie diese, halten Sie das Skript lesbar und hören Sie auf, wenn die Laufzeit kein Problem mehr darstellt.