14 Prozesse und Job-Kontrolle

# Anzeige der PID des aktuellen Shell-Prozesses
echo $$

# Anzeige der PID des zuletzt gestarteten Hintergrundprozesses
echo $!

# Anzeige des Prozessbaums
pstree

# Alternative mit ps
ps -ef --forest

# Anzeige von Prozesszuständen
ps aux | head -n 10

# Grundlegende Prozessinformationen für alle Prozesse
ps -ef

# Detaillierte Informationen mit Ressourcennutzung
ps aux

# Prozesse eines bestimmten Benutzers anzeigen
ps -u username

# Prozesse nach CPU-Nutzung sortieren
ps aux --sort=-%cpu

# Dynamische Prozessüberwachung
top

# Benutzerfreundlichere Alternative (möglicherweise Installation erforderlich)
htop

# Offene Dateien eines Prozesses anzeigen
lsof -p PID

# Umgebungsvariablen eines Prozesses anzeigen
cat /proc/PID/environ | tr '\0' '\n'

# Arbeitsverzeichnis eines Prozesses anzeigen
readlink /proc/PID/cwd

# Alle Umgebungsvariablen anzeigen
env

# Eine spezifische Umgebungsvariable für einen Prozess setzen
VARIABLE=Wert command

# Aktuelle Ressourcenlimits anzeigen
ulimit -a

# Maximale Anzahl offener Dateien für den aktuellen Prozess setzen
ulimit -n 2048

# Starten eines Prozesses im Hintergrund
sleep 300 &

# Die Shell gibt die PID des Hintergrundprozesses zurück
[1] 12345

# Mehrere Hintergrundprozesse starten
long_task1 &
long_task2 &
long_task3 &

# Standardausgabe und Standardfehlerausgabe in eine Datei umleiten
long_task > output.log 2>&1 &

# Ausgaben verwerfen
long_task > /dev/null 2>&1 &

# Ausgaben in unterschiedliche Dateien umleiten
long_task > output.log 2> error.log &

# Alle Hintergrundprozesse anzeigen
jobs

# Ausgabe mit PIDs
jobs -l

# Nur laufende Jobs anzeigen
jobs -r

# Nur gestoppte Jobs anzeigen
jobs -s

# Alle eigenen Prozesse anzeigen
ps

# Prozess mit bestimmter PID anzeigen
ps -p 12345

# Alle Prozesse (auch die anderer Benutzer) anzeigen
ps aux

# Bestimmte Informationen filtern
ps -eo pid,ppid,cmd,%cpu,%mem --sort=-%cpu

# Standardüberwachung mit top
top

# Überwachung eines bestimmten Prozesses
top -p 12345

# Benutzerfreundlichere Alternative (möglicherweise Installation erforderlich)
htop

# Einen Hintergrundprozess in den Vordergrund holen
fg %1    # % gefolgt von der Job-Nummer

# Einen gestoppten Prozess im Hintergrund fortsetzen
bg %2

# Beispiel-Workflow
sleep 300    # Startet einen Prozess im Vordergrund
# [Drücke Ctrl+Z] -> Stoppt den Prozess
[1]+  Stopped                 sleep 300
bg    # Setzt den gestoppten Prozess im Hintergrund fort

# Prozess mit PID beenden
kill 12345

# Prozess mit Job-Nummer beenden
kill %1

# Verschiedene Signale verwenden
kill -TERM 12345    # Normales Beenden (gleichwertig mit kill 12345)
kill -KILL 12345    # Sofortiges Beenden, kann nicht abgefangen werden
kill -HUP 12345     # Sendet das Hangup-Signal, oft für Neukonfiguration verwendet

kill -9 12345    # Erzwingt die Beendigung

#!/bin/bash

# Starten mehrerer Hintergrundprozesse
process1 &
PID1=$!

process2 &
PID2=$!

process3 &
PID3=$!

# Auf Abschluss eines bestimmten Prozesses warten
wait $PID1
echo "Prozess 1 abgeschlossen"

# Auf Abschluss aller Hintergrundprozesse warten
wait
echo "Alle Prozesse abgeschlossen"

#!/bin/bash

# Prozess im Hintergrund starten
long_process &
PID=$!

# Timeout setzen (z.B. 60 Sekunden)
timeout=60
count=0

while kill -0 $PID 2>/dev/null; do
    if [ $count -ge $timeout ]; then
        echo "Zeitüberschreitung - Prozess wird beendet"
        kill -9 $PID
        break
    fi
    sleep 1
    ((count++))
done

#!/bin/bash

# Prozess im Hintergrund starten
some_command &
PID=$!

# Auf Abschluss warten
wait $PID
EXIT_STATUS=$?

if [ $EXIT_STATUS -eq 0 ]; then
    echo "Prozess erfolgreich abgeschlossen"
else
    echo "Prozess fehlgeschlagen mit Exitstatus $EXIT_STATUS"
fi

# Prozess starten, der das SIGHUP-Signal ignoriert
nohup long_process &

# Alternativ: Bestehenden Hintergrundprozess von der Shell "lösen"
long_process &
disown %1

# Prozess mit niedrigerer Priorität starten (höherer Nice-Wert)
nice -n 10 resource_intensive_command &

# Priorität eines laufenden Prozesses ändern
renice +10 -p 12345

# 4 parallele Instanzen ausführen
cat task_list.txt | xargs -P 4 -I {} ./process_task.sh {}

# Zombie-Prozesse identifizieren
ps aux | grep 'Z'

#!/bin/bash

# Korrekte Behandlung von Kindprozessen
child_process &
wait $!  # Verhindert Zombies

# Alternativ: Signal-Handler für SIGCHLD
trap 'wait $!' SIGCHLD

# Liste aller verfügbaren Signale anzeigen
kill -l

# SIGTERM (Standard) an einen Prozess senden
kill 1234

# Bestimmtes Signal an einen Prozess senden
kill -SIGINT 1234   # Oder: kill -2 1234

# Signal an alle Prozesse einer Prozessgruppe senden
kill -SIGTERM -1234  # Negative PID bezieht sich auf die Prozessgruppe

# Signal an alle Prozesse eines Benutzers senden
pkill -SIGTERM -u username

# Signal an Prozesse senden, die einem Muster entsprechen
pkill -SIGTERM firefox

#!/bin/bash

# Funktion zum Aufräumen bei Beendigung
cleanup() {
    echo "Aufräumen und Beenden..."
    rm -f /tmp/tempfile_$$
    exit 0
}

# Signal-Handler einrichten
trap cleanup SIGINT SIGTERM EXIT

# Temporäre Datei erstellen
touch /tmp/tempfile_$$

# Langwierige Operation simulieren
echo "Prozess läuft. PID: $$"
echo "Drücke Ctrl+C um zu beenden."
while true; do
    sleep 1
done

trap [Aktion] [Signalliste]

# Signal ignorieren
trap '' SIGINT

# Standardaktion wiederherstellen
trap - SIGINT

# Mehrere Befehle als Handler
trap 'echo "Abbruch!"; rm -f /tmp/tempfile_$$; exit 1' SIGINT

#!/bin/bash

TEMPFILES=()
TEMPFILES+=("$(mktemp)")
TEMPFILES+=("$(mktemp)")

cleanup() {
    echo "Temporäre Dateien entfernen..."
    for file in "${TEMPFILES[@]}"; do
        rm -f "$file"
    done
}

trap cleanup EXIT

#!/bin/bash

PID_FILE="/var/run/mydaemon.pid"

shutdown() {
    echo "Graceful Shutdown wird durchgeführt..."
    # Kindprozesse beenden
    pkill -P $$
    # PID-Datei entfernen
    rm -f "$PID_FILE"
    exit 0
}

# PID speichern
echo $$ > "$PID_FILE"

# Signal-Handler einrichten
trap shutdown SIGINT SIGTERM

# Daemon-Loop
while true; do
    # Hauptlogik hier
    sleep 10
done

#!/bin/bash

timeout_handler() {
    echo "Zeitlimit überschritten!"
    kill -9 $CHILD_PID 2>/dev/null
    exit 1
}

# SIGALRM-Handler einrichten
trap timeout_handler SIGALRM

# Timeout in Sekunden
TIMEOUT=30

# Alarm setzen
(sleep $TIMEOUT && kill -SIGALRM $$) &
ALARM_PID=$!

# Langwierige Operation starten
long_running_command &
CHILD_PID=$!

# Auf Abschluss warten
wait $CHILD_PID
RESULT=$?

# Alarm-Prozess beenden
kill $ALARM_PID 2>/dev/null

exit $RESULT

# Diese Signal-Handler werden nie ausgeführt
trap 'echo "Dies wird nie angezeigt"' SIGKILL SIGSTOP

#!/bin/bash

trap 'echo "Hauptskript fängt Signal ab"' SIGINT

# Dieser Subshell-Prozess erbt den Handler nicht
(
    # Eigenen Handler definieren
    trap 'echo "Subshell fängt Signal ab"; exit 1' SIGINT
    echo "Subshell läuft. Drücke Ctrl+C."
    sleep 30
)

# Warten auf Abschluss der Subshell
wait

#!/bin/bash

# Handler für das Hauptskript
trap 'echo "Hauptskript fängt Signal ab"' SIGINT

# Pipeline starten (alle Prozesse in einer Prozessgruppe)
cat /dev/urandom | head -c 100000 | sort | uniq | wc -l &

# PID der Prozessgruppe erhalten
pgid=$!

echo "Prozessgruppe läuft mit PGID: $pgid"
echo "Drücke Ctrl+C oder warte 10 Sekunden."

sleep 10

# Alternative: Signal nur an einen bestimmten Prozess in der Gruppe senden
# kill -SIGINT $(pgrep -P $pgid | head -1)

#!/bin/bash

# Prozess A: Signal-Empfänger
receiver() {
    echo "Empfänger gestartet. PID: $$"
    
    handle_usr1() {
        echo "Konfiguration neu laden..."
    }
    
    handle_usr2() {
        echo "Statusbericht generieren..."
    }
    
    trap handle_usr1 SIGUSR1
    trap handle_usr2 SIGUSR2
    
    echo "Warte auf Signale. Beende mit Ctrl+C."
    while true; do
        sleep 1
    done
}

# Prozess B: Signal-Sender
sender() {
    echo "Sender gestartet."
    echo "1) SIGUSR1 senden"
    echo "2) SIGUSR2 senden"
    echo "q) Beenden"
    
    while true; do
        read -p "Befehl: " cmd
        case $cmd in
            1) kill -SIGUSR1 $RECEIVER_PID ;;
            2) kill -SIGUSR2 $RECEIVER_PID ;;
            q) exit 0 ;;
            *) echo "Unbekannter Befehl" ;;
        esac
    done
}

# Empfänger im Hintergrund starten
receiver &
RECEIVER_PID=$!

# Sender im Vordergrund starten
sender

# Aufräumen
kill $RECEIVER_PID

#!/bin/bash

# Globaler Status
STATUS="Inaktiv"

# Signal-Handler
handle_event() {
    case $1 in
        start)
            STATUS="Aktiv"
            echo "Status: $STATUS"
            ;;
        stop)
            STATUS="Inaktiv"
            echo "Status: $STATUS"
            ;;
        status)
            echo "Status: $STATUS"
            ;;
    esac
}

# Signal-Handler zuweisen
trap 'handle_event start' SIGUSR1
trap 'handle_event stop' SIGUSR2
trap 'handle_event status' SIGHUP

echo "Event-Handler gestartet. PID: $$"
echo "Sende Signale mit:"
echo "  kill -SIGUSR1 $$ # Start"
echo "  kill -SIGUSR2 $$ # Stop"
echo "  kill -SIGHUP $$ # Status"

# Hauptloop
while true; do
    sleep 1
done

# Vordergrundausführung
sleep 60

# Hintergrundausführung
sleep 60 &

# Alle Jobs anzeigen
jobs

# Ausgabeformat:
# [1]  + Running                 sleep 100 &
# [2]  - Stopped                 nano testfile.txt

# Mit zusätzlichen Optionen
jobs -l    # Mit Process-IDs anzeigen
jobs -p    # Nur Process-IDs anzeigen
jobs -s    # Nur angehaltene Jobs anzeigen
jobs -r    # Nur laufende Jobs anzeigen

# Aktuellen Job in den Vordergrund bringen
fg

# Bestimmten Job in den Vordergrund bringen
fg %1     # Job mit Nummer 1
fg %vim   # Job, dessen Befehlsname mit "vim" beginnt
fg %%     # Aktueller Job (äquivalent zu fg)
fg %-     # Vorheriger Job

# Aktuellen angehaltenen Job im Hintergrund fortsetzen
bg

# Bestimmten angehaltenen Job im Hintergrund fortsetzen
bg %2

sleep 100  # Starte einen Vordergrundjob
# [Drücke Ctrl+Z]
# [1]+ Stopped                 sleep 100
bg         # Setze den angehaltenen Job im Hintergrund fort

sleep 100  # Starte einen Vordergrundjob
# [Drücke Ctrl+C]
# ^C

# Beispiele für Jobreferenzen
kill %1        # Sendet SIGTERM an Job 1
bg %?find      # Setzt Job fort, der "find" in der Befehlszeile enthält
fg %+          # Bringt den aktuellen Job in den Vordergrund

#!/bin/bash
# Job-Kontrolle aktivieren
set -m

# Jobs starten
process1 &
process2 &

# Jobs auflisten
jobs

# Auf einen bestimmten Job warten
fg %1

#!/bin/bash
set -m

# Funktion zur Wiederherstellung angehaltener Jobs
resume_stopped_jobs() {
    local stopped_jobs
    stopped_jobs=$(jobs -sp)
    
    if [ -n "$stopped_jobs" ]; then
        echo "Wiederherstellung angehaltener Jobs..."
        while read -r pid; do
            kill -CONT "$pid" 2>/dev/null
        done <<< "$stopped_jobs"
    fi
}

# Signal-Handler einrichten
trap resume_stopped_jobs EXIT

# Hauptlogik des Skripts
# ...

#!/bin/bash
set -m

# Neue Prozessgruppe starten
start_job_group() {
    # Subshell mit eigener Prozessgruppe
    (
        # Mehrere Prozesse starten
        process1 &
        process2 &
        process3 &
        
        # Auf alle warten
        wait
    ) &
    
    # PID der Prozessgruppe (= PID der Subshell)
    echo $!
}

# Job-Gruppe starten
group_pid=$(start_job_group)
echo "Job-Gruppe gestartet mit PID: $group_pid"

# Später: Ganze Gruppe beenden
kill -TERM -"$group_pid"  # Negative PID bezieht sich auf die Prozessgruppe

#!/bin/bash

# Co-Prozess starten
coproc SORTER {
    sort
}

# Daten an den Co-Prozess senden
echo -e "banana\napple\ncherry" >&${SORTER[1]}
# Eingabekanal schließen
exec {SORTER[1]}>&-

# Daten vom Co-Prozess lesen
sorted_output=$(cat <&${SORTER[0]})
echo "Sortierte Liste:"
echo "$sorted_output"

# Ausgabekanal schließen
exec {SORTER[0]}>&-

# Auf Beendigung des Co-Prozesses warten
wait $SORTER_PID

#!/bin/bash
set -m

# Assoziatives Array für Job-Tracking
declare -A jobs_map

# Funktion zum Starten eines Hintergrundjobs
start_job() {
    local job_name=$1
    local command=$2
    
    $command &
    local pid=$!
    jobs_map["$job_name"]=$pid
    echo "Job '$job_name' gestartet mit PID $pid"
}

# Funktion zum Beenden eines Jobs
stop_job() {
    local job_name=$1
    local pid=${jobs_map["$job_name"]}
    
    if [ -n "$pid" ] && kill -0 $pid 2>/dev/null; then
        echo "Beende Job '$job_name' (PID $pid)..."
        kill -TERM $pid
        wait $pid 2>/dev/null
        echo "Job '$job_name' beendet."
    else
        echo "Job '$job_name' existiert nicht oder läuft nicht."
    fi
}

# Funktion zum Auflisten aller Jobs
list_jobs() {
    echo "Aktive Jobs:"
    for job_name in "${!jobs_map[@]}"; do
        local pid=${jobs_map["$job_name"]}
        if kill -0 $pid 2>/dev/null; then
            echo "  $job_name (PID $pid): Aktiv"
        else
            echo "  $job_name (PID $pid): Beendet"
            unset jobs_map["$job_name"]
        fi
    done
}

# Beispielverwendung
start_job "logger" "tail -f /var/log/syslog"
start_job "counter" "for i in {1..100}; do echo \$i; sleep 1; done"

sleep 5
list_jobs

stop_job "counter"
list_jobs

# Vor dem Beenden alle Jobs stoppen
trap 'for job in "${!jobs_map[@]}"; do stop_job "$job"; done' EXIT

#!/bin/bash
set -m

# Maximal zulässige Anzahl gleichzeitiger Jobs
MAX_CONCURRENT_JOBS=4

# Warteschlange für ausstehende Aufgaben
task_queue=()

# Funktion zum Hinzufügen einer Aufgabe zur Warteschlange
add_task() {
    task_queue+=("$1")
    echo "Aufgabe zur Warteschlange hinzugefügt: $1"
    schedule_tasks
}

# Funktion zum Planen und Ausführen von Aufgaben
schedule_tasks() {
    # Anzahl aktiver Jobs ermitteln
    local active_jobs=$(jobs -r | wc -l)
    
    # Solange Platz für mehr Jobs und Aufgaben in der Warteschlange sind
    while [ $active_jobs -lt $MAX_CONCURRENT_JOBS ] && [ ${#task_queue[@]} -gt 0 ]; do
        # Nächste Aufgabe aus der Warteschlange nehmen
        local next_task=${task_queue[0]}
        task_queue=("${task_queue[@]:1}")  # Erste Aufgabe entfernen
        
        # Aufgabe im Hintergrund starten
        echo "Starte Aufgabe: $next_task"
        eval "$next_task" &
        
        # Anzahl aktiver Jobs aktualisieren
        active_jobs=$(jobs -r | wc -l)
    done
}

# Signal-Handler für beendete Hintergrundjobs
handle_job_completion() {
    schedule_tasks
}
trap handle_job_completion CHLD

# Beispielverwendung
for i in {1..10}; do
    add_task "echo 'Aufgabe $i gestartet'; sleep $((RANDOM % 5 + 1)); echo 'Aufgabe $i beendet'"
done

# Warten, bis alle Aufgaben abgearbeitet sind
wait
echo "Alle Aufgaben abgeschlossen."

#!/bin/bash

echo "Starte parallele Aufgaben..."

# Mehrere Befehle parallel ausführen
task1 &
task2 &
task3 &

# Auf Abschluss aller Hintergrundprozesse warten
wait

echo "Alle Aufgaben abgeschlossen."

#!/bin/bash

# Liste von Aufgaben
echo "Datei1 Datei2 Datei3 Datei4 Datei5 Datei6 Datei7 Datei8" | \
# Maximal 4 parallele Prozesse
xargs -P 4 -n 1 ./verarbeite_datei.sh

#!/bin/bash

# Alle JPG-Dateien finden und in PNG konvertieren, mit maximal 8 parallelen Prozessen
find . -name "*.jpg" -type f | \
xargs -P 8 -I {} convert {} {}.png

#!/bin/bash

# Sicherstellen, dass GNU Parallel installiert ist
if ! command -v parallel &> /dev/null; then
    echo "GNU Parallel ist nicht installiert. Bitte installieren Sie es mit:"
    echo "  apt-get install parallel  # Debian/Ubuntu"
    echo "  yum install parallel      # CentOS/RHEL"
    exit 1
fi

# Grundlegende Verwendung: Liste von Dateien verarbeiten
find . -name "*.log" | \
parallel --max-procs=8 ./analyze_log.sh {}

# Mit Jobnamen und Fortschrittsanzeige
find . -name "*.log" | \
parallel --max-procs=8 --joblog parallel.log --progress \
    './analyze_log.sh {} > {}.report'

# Automatische CPU-Kern-Erkennung
parallel --jobs 100% ./task.sh ::: input1 input2 input3

# Unterschiedliche Eingabequellen kombinieren
parallel ./process.sh {1} {2} ::: A B C ::: 1 2 3

# Ausgabe in der gleichen Reihenfolge wie die Eingabe
find . -name "*.txt" | parallel --keep-order 'wc -l {}'

# Ergebnisse in einer CSV-Datei speichern
parallel --results results.csv './test.sh {}' ::: input1 input2 input3

#!/bin/bash

# Maximale Anzahl gleichzeitiger Prozesse
MAX_PROCS=4

# Funktion zum Starten eines Prozesses mit Semaphor
run_with_semaphore() {
    # Aktuelle Anzahl laufender Hintergrundprozesse
    local running=$(jobs -r | wc -l)
    
    # Warten, bis ein Platz frei ist
    while [ $running -ge $MAX_PROCS ]; do
        sleep 0.5
        running=$(jobs -r | wc -l)
    done
    
    # Prozess starten
    "$@" &
}

# Beispielverwendung
for file in *.txt; do
    run_with_semaphore ./process_file.sh "$file"
done

# Auf Abschluss aller Hintergrundprozesse warten
wait

#!/bin/bash

# Maximale Anzahl gleichzeitiger Prozesse
MAX_PROCS=4
FIFO="/tmp/semaphore_$$"

# Aufräumen beim Beenden
cleanup() {
    rm -f "$FIFO"
}
trap cleanup EXIT

# FIFO erstellen
mkfifo "$FIFO"

# Semaphor initialisieren
for ((i=0; i<MAX_PROCS; i++)); do
    echo $i > "$FIFO" &
done

# Funktion zum Ausführen eines Befehls unter Semaphorkontrolle
run_with_semaphore() {
    local slot
    
    # Slot aus dem Semaphor lesen (blockiert, wenn keiner verfügbar)
    read slot < "$FIFO"
    
    # Befehl ausführen und Slot zurückgeben, wenn fertig
    ( "$@"; echo $slot > "$FIFO" ) &
}

# Beispielverwendung
for file in *.dat; do
    run_with_semaphore ./analyze.sh "$file"
done

# Auf Abschluss aller Prozesse warten
wait

#!/bin/bash

# Konfiguration
NUM_WORKERS=4
TASK_QUEUE="/tmp/task_queue_$$"
RESULT_QUEUE="/tmp/result_queue_$$"

# Aufräumen beim Beenden
cleanup() {
    rm -f "$TASK_QUEUE" "$RESULT_QUEUE"
    # Alle Worker-Prozesse beenden
    jobs -p | xargs -r kill
}
trap cleanup EXIT

# FIFOs erstellen
mkfifo "$TASK_QUEUE" "$RESULT_QUEUE"

# Worker-Funktion
worker() {
    local worker_id=$1
    local task
    
    echo "Worker $worker_id gestartet"
    
    # Auf Aufgaben aus der Warteschlange warten
    while read task; do
        # Beenden, wenn Terminierungssignal empfangen
        if [ "$task" = "TERMINATE" ]; then
            break
        fi
        
        echo "Worker $worker_id verarbeitet Aufgabe: $task"
        
        # Aufgabe ausführen und Ergebnis speichern
        local result=$(eval "$task" 2>&1)
        local status=$?
        
        # Ergebnis zurückmelden
        echo "$worker_id:$task:$status:$result" > "$RESULT_QUEUE"
    done < "$TASK_QUEUE"
    
    echo "Worker $worker_id beendet"
}

# Worker starten
for ((i=1; i<=NUM_WORKERS; i++)); do
    worker $i &
done

# Funktion zum Hinzufügen einer Aufgabe zur Warteschlange
add_task() {
    echo "$1" > "$TASK_QUEUE"
}

# Funktion zum Sammeln von Ergebnissen
collect_results() {
    local expected=$1
    local count=0
    local results=()
    
    while [ $count -lt $expected ]; do
        # Auf ein Ergebnis warten
        if read result < "$RESULT_QUEUE"; then
            results+=("$result")
            ((count++))
        fi
    done
    
    # Ergebnisse zurückgeben
    for result in "${results[@]}"; do
        echo "$result"
    done
}

# Beispielverwendung: Aufgaben zur Warteschlange hinzufügen
TASKS=(
    "sleep 2 && echo 'Aufgabe 1 abgeschlossen'"
    "sleep 1 && echo 'Aufgabe 2 abgeschlossen'"
    "sleep 3 && echo 'Aufgabe 3 abgeschlossen'"
    "sleep 1 && echo 'Aufgabe 4 abgeschlossen'"
    "sleep 2 && echo 'Aufgabe 5 abgeschlossen'"
    "sleep 1 && echo 'Aufgabe 6 abgeschlossen'"
)

# Aufgaben senden
for task in "${TASKS[@]}"; do
    add_task "$task"
done

# Ergebnisse sammeln
echo "Ergebnisse:"
collect_results ${#TASKS[@]} | sort

# Worker beenden
for ((i=1; i<=NUM_WORKERS; i++)); do
    add_task "TERMINATE"
done

# Warten, bis alle Worker beendet sind
wait
echo "Alle Worker beendet"

#!/bin/bash

# Funktion zur parallelen Verarbeitung von Teilen einer Aufgabe
fork_join() {
    local num_parts=$1
    local processor=$2
    local input=$3
    local output=$4
    
    # Verzeichnis für temporäre Dateien
    local temp_dir=$(mktemp -d)
    
    # Aufgabe in Teile aufteilen (Fork)
    split -n l/$num_parts "$input" "$temp_dir/part_"
    
    # Teile parallel verarbeiten
    ls "$temp_dir/part_"* | xargs -P "$num_parts" -I {} \
        bash -c "$processor {} {}.out"
    
    # Ergebnisse zusammenführen (Join)
    cat "$temp_dir"/part_*.out > "$output"
    
    # Aufräumen
    rm -rf "$temp_dir"
}

# Beispielverwendung für Textverarbeitung
processor="grep 'ERROR' | sort -u"
fork_join 4 "$processor" "große_logdatei.log" "fehler_zusammenfassung.txt"

#!/bin/bash

# Liste der verfügbaren Server
SERVERS=("server1" "server2" "server3" "server4")

# Funktion zum Ausführen eines Befehls auf einem Remote-Server
run_on_server() {
    local server=$1
    local command=$2
    
    echo "Führe aus auf $server: $command"
    ssh "$server" "$command"
}

# Funktion zum Verteilen von Aufgaben auf Server
distribute_tasks() {
    local tasks=("$@")
    local num_tasks=${#tasks[@]}
    local num_servers=${#SERVERS[@]}
    local pids=()
    
    # Aufgaben auf Server verteilen
    for ((i=0; i<num_tasks; i++)); do
        local server_idx=$((i % num_servers))
        local server=${SERVERS[$server_idx]}
        local task=${tasks[$i]}
        
        # Aufgabe im Hintergrund auf Server ausführen
        run_on_server "$server" "$task" &
        pids+=($!)
    done
    
    # Auf Abschluss aller Aufgaben warten
    for pid in "${pids[@]}"; do
        wait $pid
    done
}

# Beispielverwendung
TASKS=(
    "find /var/log -name '*.log' -type f -mtime -1 | xargs grep 'ERROR'"
    "find /var/log -name '*.log' -type f -mtime -1 | xargs grep 'WARNING'"
    "find /var/log -name '*.log' -type f -mtime -1 | xargs grep 'CRITICAL'"
    "find /var/log -name '*.log' -type f -mtime -1 | xargs grep 'FATAL'"
)

distribute_tasks "${TASKS[@]}"

parallel --sshlogin server1,server2,server3,server4 ./process.sh ::: input1 input2 input3 input4

#!/bin/bash

# Maximale Anzahl gleichzeitiger Aufgaben
MAX_CONCURRENT=10

# Zähler für laufende Aufgaben
declare -i running=0

# Funktion für asynchrone Ausführung
async_run() {
    local command=$1
    
    # Aufgabe starten
    {
        eval "$command"
        # Signal senden, wenn Aufgabe beendet ist
        kill -USR1 $$
    } &
    
    ((running++))
    
    # Warten, wenn maximale Anzahl erreicht ist
    if [ $running -ge $MAX_CONCURRENT ]; then
        wait -n  # Warten auf Beendigung eines beliebigen Prozesses
        ((running--))
    fi
}

# Signal-Handler für beendete Aufgaben
handle_task_completion() {
    ((running > 0)) && ((running--))
}
trap handle_task_completion USR1

# Beispielverwendung mit URL-Anfragen
URLS=(
    "https://example.com/api/resource1"
    "https://example.com/api/resource2"
    "https://example.com/api/resource3"
    # ...weitere URLs...
)

for url in "${URLS[@]}"; do
    async_run "curl -s '$url' > '$(basename "$url").json'"
done

# Auf Abschluss aller verbleibenden Aufgaben warten
wait

#!/bin/bash

# Funktion zur Bestimmung der optimalen Parallelität
get_optimal_parallelism() {
    # CPU-Kerne ermitteln
    local cpu_cores=$(nproc)
    
    # Verfügbaren Arbeitsspeicher in MB ermitteln
    local mem_available=$(free -m | awk '/^Mem:/ {print $7}')
    
    # Geschätzter Speicherbedarf pro Prozess in MB
    local mem_per_process=200
    
    # Maximale Prozesse basierend auf CPU und Speicher berechnen
    local max_by_cpu=$cpu_cores
    local max_by_mem=$((mem_available / mem_per_process))
    
    # Minimum wählen, aber mindestens 1
    local optimal=$(( max_by_cpu < max_by_mem ? max_by_cpu : max_by_mem ))
    echo $((optimal > 0 ? optimal : 1))
}

# Optimale Parallelität ermitteln
PARALLEL_JOBS=$(get_optimal_parallelism)
echo "Starte $PARALLEL_JOBS parallele Jobs basierend auf Systemressourcen"

# Mit xargs verwenden
find . -name "*.csv" | xargs -P $PARALLEL_JOBS -I {} ./process_file.sh {}

#!/bin/bash

# Prozesse im Hintergrund starten
process1 &
PID1=$!

process2 &
PID2=$!

# Auf einen bestimmten Prozess warten
wait $PID1
echo "Prozess 1 wurde abgeschlossen"

# Auf alle Hintergrundprozesse warten
wait
echo "Alle Prozesse wurden abgeschlossen"

process_data &
wait $!
if [ $? -eq 0 ]; then
    echo "Datenverarbeitung erfolgreich"
else
    echo "Fehler bei der Datenverarbeitung"
fi

#!/bin/bash

# Timeout-Funktion
wait_with_timeout() {
    local pid=$1
    local timeout=$2
    
    # Timeout-Prozess starten
    (
        sleep $timeout
        kill -0 $pid 2>/dev/null && kill -TERM $pid
    ) &
    local timeout_pid=$!
    
    # Auf den Hauptprozess warten
    wait $pid
    local exit_status=$?
    
    # Timeout-Prozess beenden
    kill $timeout_pid 2>/dev/null
    
    return $exit_status
}

# Beispielverwendung
long_running_process &
process_pid=$!

if wait_with_timeout $process_pid 60; then
    echo "Prozess erfolgreich abgeschlossen"
else
    echo "Prozess wurde nach Timeout beendet oder schlug fehl"
fi

#!/bin/bash

LOCKFILE="/tmp/myprocess.lock"

# Funktion zum Erwerben des Locks
acquire_lock() {
    # Atomares Erstellen der Lockdatei mit Shell-Umleitung
    if (set -o noclobber; echo "$$" > "$LOCKFILE") 2>/dev/null; then
        trap 'rm -f "$LOCKFILE"; exit $?' INT TERM EXIT
        return 0
    else
        return 1
    fi
}

# Funktion zum Freigeben des Locks
release_lock() {
    rm -f "$LOCKFILE"
    trap - INT TERM EXIT
}

# Versuchen, den Lock zu erwerben
if ! acquire_lock; then
    echo "Ein anderer Prozess läuft bereits (PID: $(cat "$LOCKFILE"))"
    exit 1
fi

echo "Lock erworben, kritischer Abschnitt beginnt"

# Kritischer Abschnitt
sleep 10
echo "Kritische Operation wird ausgeführt"

# Lock freigeben
release_lock
echo "Lock freigegeben, kritischer Abschnitt beendet"

#!/bin/bash

LOCKFILE="/tmp/myprocess.lock"

# Kritischen Abschnitt mit flock schützen
(
    # Versuchen, einen exklusiven Lock zu erwerben, ohne zu blockieren
    if ! flock -n 200; then
        echo "Lock konnte nicht erworben werden. Ein anderer Prozess läuft bereits."
        exit 1
    fi
    
    echo "Lock erworben, kritischer Abschnitt beginnt"
    sleep 10
    echo "Kritische Operation wird ausgeführt"
    echo "Lock wird freigegeben"
    
    # Lock wird automatisch beim Schließen des Filedeskriptors freigegeben
) 200>"$LOCKFILE"

#!/bin/bash

# Maximal 3 gleichzeitige Instanzen erlauben
MAX_INSTANCES=3

for i in {1..10}; do
    (
        # Versuchen, einen Lock auf Filedeskriptor 200 zu erwerben
        # -w 0: nicht warten, wenn kein Lock verfügbar
        flock -w 0 200 || { echo "Instance $i: Konnte keinen Lock erhalten"; exit 1; }
        
        echo "Instance $i: Lock erworben, Verarbeitung beginnt"
        sleep $((RANDOM % 5 + 1))
        echo "Instance $i: Verarbeitung abgeschlossen"
    ) 200>/tmp/limited_instances.lock.$((i % MAX_INSTANCES)) &
done

# Auf Abschluss aller Hintergrundprozesse warten
wait

#!/bin/bash

# Standard-Pipeline
ls -la | grep "^d" | sort -k 5 -n

# Pipeline in einer Variablen speichern
directories=$(ls -la | grep "^d" | sort -k 5 -n)
echo "Gefundene Verzeichnisse: $directories"

# Process Substitution für bidirektionale Kommunikation
diff <(ls -la dir1) <(ls -la dir2)

#!/bin/bash

# Producer-Consumer-Muster mit Pipes
producer() {
    for i in {1..10}; do
        echo "Daten $i"
        sleep 1
    done
}

consumer() {
    while read line; do
        echo "Verarbeite: $line"
        # Datenverarbeitung hier
    done
}

# Producer und Consumer über eine Pipe verbinden
producer | consumer

#!/bin/bash

FIFO_PATH="/tmp/myfifo"

# FIFO erstellen, falls sie nicht existiert
if [ ! -p "$FIFO_PATH" ]; then
    mkfifo "$FIFO_PATH"
fi

# Aufräumen beim Beenden
trap 'rm -f "$FIFO_PATH"' EXIT

# Beispiel: Einfacher Server mit Named Pipe
echo "Server gestartet. Senden Sie Nachrichten an $FIFO_PATH"
echo "Beenden mit Ctrl+C"

while true; do
    if read -r message < "$FIFO_PATH"; then
        echo "Empfangen: $message"
        
        # Echo-Antwort (muss in separater Shell erfolgen, um Blockierung zu vermeiden)
        (echo "ECHO: $message" > "$FIFO_PATH") &
    fi
done

#!/bin/bash

FIFO_PATH="/tmp/myfifo"

# Prüfen, ob FIFO existiert
if [ ! -p "$FIFO_PATH" ]; then
    echo "Server nicht aktiv (FIFO nicht gefunden)"
    exit 1
fi

# Nachricht senden
echo "Nachricht vom Client: $(date)" > "$FIFO_PATH"

# Auf Antwort warten (mit Timeout)
if read -t 5 response < "$FIFO_PATH"; then
    echo "Antwort vom Server: $response"
else
    echo "Timeout beim Warten auf Antwort"
fi

#!/bin/bash

# Server-Skript
SERVER_TO_CLIENT="/tmp/server_to_client"
CLIENT_TO_SERVER="/tmp/client_to_server"

# FIFOs erstellen
mkfifo "$SERVER_TO_CLIENT" "$CLIENT_TO_SERVER"

# Aufräumen beim Beenden
cleanup() {
    echo "Server wird beendet"
    rm -f "$SERVER_TO_CLIENT" "$CLIENT_TO_SERVER"
    exit 0
}
trap cleanup EXIT INT TERM

echo "Server gestartet"

# Hauptschleife für Anfragen
while true; do
    if read request < "$CLIENT_TO_SERVER"; then
        echo "Anfrage empfangen: $request"
        
        # Antwort verarbeiten und zurücksenden
        response="Server hat '$request' verarbeitet um $(date)"
        echo "$response" > "$SERVER_TO_CLIENT"
    fi
done

#!/bin/bash

# Client-Skript
SERVER_TO_CLIENT="/tmp/server_to_client"
CLIENT_TO_SERVER="/tmp/client_to_server"

# Prüfen, ob FIFOs existieren
if [ ! -p "$SERVER_TO_CLIENT" ] || [ ! -p "$CLIENT_TO_SERVER" ]; then
    echo "Server nicht aktiv (FIFOs nicht gefunden)"
    exit 1
fi

# Funktion zum Senden einer Anfrage und Empfangen der Antwort
send_request() {
    local request=$1
    
    # Anfrage senden
    echo "$request" > "$CLIENT_TO_SERVER"
    
    # Auf Antwort warten (mit Timeout)
    if read -t 5 response < "$SERVER_TO_CLIENT"; then
        echo "Antwort: $response"
    else
        echo "Timeout beim Warten auf Antwort"
    fi
}

# Beispielanfragen senden
send_request "Hallo Server"
send_request "Wie spät ist es?"

#!/bin/bash

# Temporäre Datei für die Kommunikation erstellen
TEMP_FILE=$(mktemp)

# Aufräumen beim Beenden
trap 'rm -f "$TEMP_FILE"' EXIT

# Prozess 1 schreibt in die temporäre Datei
{
    echo "Daten von Prozess 1" > "$TEMP_FILE"
    echo "Weitere Daten" >> "$TEMP_FILE"
    echo "FERTIG" >> "$TEMP_FILE"
} &

# Prozess 2 liest aus der temporären Datei
{
    # Warten, bis Daten verfügbar sind
    while [ ! -s "$TEMP_FILE" ]; do
        sleep 0.1
    done
    
    # Auf das Ende-Signal warten
    until grep -q "FERTIG" "$TEMP_FILE"; do
        sleep 0.1
    done
    
    # Daten verarbeiten (ohne die FERTIG-Zeile)
    grep -v "FERTIG" "$TEMP_FILE"
} &

# Auf beide Prozesse warten
wait

#!/bin/bash

# Signal-Handler für verschiedene Ereignisse
synchronize() {
    case $1 in
        start)
            echo "Start-Signal empfangen, beginne Verarbeitung"
            ;;
        pause)
            echo "Pause-Signal empfangen, pausiere Verarbeitung"
            ;;
        resume)
            echo "Resume-Signal empfangen, setze Verarbeitung fort"
            ;;
        stop)
            echo "Stop-Signal empfangen, beende Verarbeitung"
            exit 0
            ;;
    esac
}

# Signal-Handler einrichten
trap 'synchronize start' USR1
trap 'synchronize pause' USR2
trap 'synchronize resume' HUP
trap 'synchronize stop' TERM

echo "Prozess gestartet mit PID: $$"
echo "Steuern Sie diesen Prozess mit:"
echo "  kill -USR1 $$ # Start"
echo "  kill -USR2 $$ # Pause"
echo "  kill -HUP $$ # Resume"
echo "  kill -TERM $$ # Stop"

# Hauptschleife
while true; do
    sleep 1
done

#!/bin/bash

# Konfiguration
NUM_PROCESSES=4
BARRIER_FILE="/tmp/barrier_$$"

# Initialisierung der Barrier
echo "0" > "$BARRIER_FILE"

# Aufräumen beim Beenden
trap 'rm -f "$BARRIER_FILE"' EXIT

# Funktion für die Barrier-Synchronisation
barrier_wait() {
    local id=$1
    
    echo "Prozess $id erreicht die Barrier"
    
    # Atomare Inkrementierung des Zählers (mit flock für Thread-Sicherheit)
    (
        flock -x 200
        count=$(<"$BARRIER_FILE")
        count=$((count + 1))
        echo $count > "$BARRIER_FILE"
        
        if [ $count -eq $NUM_PROCESSES ]; then
            # Letzter Prozess erreicht die Barrier, Signal an alle senden
            echo "Alle Prozesse haben die Barrier erreicht"
            # Zähler zurücksetzen
            echo "0" > "$BARRIER_FILE"
            # Signal an die Prozessgruppe senden
            kill -USR1 -$$
        fi
    ) 200>"$BARRIER_FILE.lock"
    
    # Auf das Signal warten, sofern es nicht der letzte Prozess war
    if [ $count -lt $NUM_PROCESSES ]; then
        echo "Prozess $id wartet an der Barrier"
        # Warten auf das Signal
        trap 'echo "Prozess $id überschreitet die Barrier"; trap - USR1' USR1
        while true; do
            sleep 0.1
        done
    fi
}

# Beispielprozesse starten
for i in $(seq 1 $NUM_PROCESSES); do
    (
        # Phase 1 der Verarbeitung
        sleep $((RANDOM % 5 + 1))
        echo "Prozess $i hat Phase 1 abgeschlossen"
        
        # Auf alle Prozesse warten
        barrier_wait $i
        
        # Phase 2 der Verarbeitung
        sleep $((RANDOM % 3 + 1))
        echo "Prozess $i hat Phase 2 abgeschlossen"
    ) &
done

# Auf Abschluss aller Prozesse warten
wait

#!/bin/bash

# Server-Skript
server() {
    local port=8888
    
    echo "Server startet auf Port $port"
    
    # Einfacher Echo-Server mit netcat
    while true; do
        nc -l $port | while read line; do
            echo "Empfangen: $line"
            echo "ECHO: $line" | nc -l $port
        done
    done
}

# Client-Skript
client() {
    local host="localhost"
    local port=8888
    local message="Hallo vom Client: $(date)"
    
    echo "Sende Nachricht an $host:$port: $message"
    
    # Nachricht senden und Antwort empfangen
    response=$(echo "$message" | nc $host $port)
    
    echo "Antwort erhalten: $response"
}

# Verwendung:
# ./script.sh server  # Startet den Server
# ./script.sh client  # Sendet eine Nachricht als Client

case "$1" in
    server)
        server
        ;;
    client)
        client
        ;;
    *)
        echo "Verwendung: $0 {server|client}"
        exit 1
        ;;
esac

#!/bin/bash

# Beispiel: Benachrichtigung über DBus senden
send_notification() {
    local title="$1"
    local message="$2"
    
    gdbus call --session \
        --dest org.freedesktop.Notifications \
        --object-path /org/freedesktop/Notifications \
        --method org.freedesktop.Notifications.Notify \
        "Shell-Skript" 0 "dialog-information" \
        "$title" "$message" "[]" "{}" 5000
}

# Beispiel: System herunterfahren über DBus
shutdown_system() {
    gdbus call --system \
        --dest org.freedesktop.login1 \
        --object-path /org/freedesktop/login1 \
        --method org.freedesktop.login1.Manager.PowerOff \
        true
}

# Beispielverwendung
send_notification "Prozessabschluss" "Der langwierige Prozess wurde erfolgreich abgeschlossen."

# Shutdown-Beispiel (auskommentiert)
# shutdown_system

#!/bin/bash

# Gemeinsam genutzter Speicherbereich
SHM_FILE="/dev/shm/myshm_$$"

# Initialisierung
echo "0" > "$SHM_FILE"
chmod 600 "$SHM_FILE"

# Aufräumen beim Beenden
trap 'rm -f "$SHM_FILE"' EXIT

# Prozess 1: Inkrementiert den Zähler
(
    for i in {1..5}; do
        # Atomare Aktualisierung mit flock
        (
            flock -x 200
            current=$(cat "$SHM_FILE")
            echo "Prozess 1: Aktueller Wert: $current"
            echo $((current + 1)) > "$SHM_FILE"
        ) 200>"$SHM_FILE.lock"
        
        sleep 1
    done
) &

# Prozess 2: Liest und meldet den Zähler
(
    for i in {1..7}; do
        # Atomares Lesen mit flock
        (
            flock -s 200
            current=$(cat "$SHM_FILE")
            echo "Prozess 2: Lese Wert: $current"
        ) 200>"$SHM_FILE.lock"
        
        sleep 0.7
    done
) &

# Auf beide Prozesse warten
wait

#!/bin/bash

# Semaphor-Datei
SEM_FILE="/tmp/semaphore_$$"

# Semaphor initialisieren (Wert = Anzahl erlaubter gleichzeitiger Zugriffe)
echo "3" > "$SEM_FILE"
chmod 600 "$SEM_FILE"

# Aufräumen beim Beenden
trap 'rm -f "$SEM_FILE"' EXIT

# Funktion zum Erwerben des Semaphors
sem_acquire() {
    local timeout=${1:-30}  # Standardtimeout: 30 Sekunden
    local start_time=$(date +%s)
    
    while true; do
        # Atomarer Zugriff auf den Semaphor
        (
            flock -x 200
            
            # Aktuellen Wert lesen
            local count=$(cat "$SEM_FILE")
            
            if [ $count -gt 0 ]; then
                # Semaphor erfolgreich erworben
                echo $((count - 1)) > "$SEM_FILE"
                return 0
            fi
        ) 200>"$SEM_FILE.lock"
        
        # Prüfen, ob das Timeout erreicht wurde
        if [ $(($(date +%s) - start_time)) -ge $timeout ]; then
            return 1  # Timeout
        fi
        
        # Kurz warten, bevor erneut versucht wird
        sleep 0.1
    done
}

# Funktion zum Freigeben des Semaphors
sem_release() {
    # Atomare Inkrementierung
    (
        flock -x 200
        local count=$(cat "$SEM_FILE")
        echo $((count + 1)) > "$SEM_FILE"
    ) 200>"$SEM_FILE.lock"
}

# Beispiel: Mehrere Prozesse, die auf eine begrenzte Ressource zugreifen
for i in {1..10}; do
    (
        echo "Prozess $i versucht, den Semaphor zu erwerben"
        
        if sem_acquire 5; then
            echo "Prozess $i hat den Semaphor erworben"
            
            # Kritischer Abschnitt
            sleep $((RANDOM % 3 + 1))
            echo "Prozess $i arbeitet im kritischen Abschnitt"
            
            # Semaphor freigeben
            sem_release
            echo "Prozess $i hat den Semaphor freigegeben"
        else
            echo "Prozess $i: Timeout beim Erwerben des Semaphors"
        fi
    ) &
done

# Auf alle Prozesse warten
wait

#!/bin/bash

# Aktuelle Ressourcenlimits anzeigen
echo "Aktuelle Ressourcenlimits:"
ulimit -a

# Maximale Anzahl offener Dateien erhöhen
echo "Erhöhe das Limit für offene Dateien auf 4096"
ulimit -n 4096

# Maximale Dateigröße begrenzen (in Kilobytes)
echo "Begrenze die maximale Dateigröße auf 100 MB"
ulimit -f 102400

# Limitierte Core-Dump-Größe für besseres Debugging
echo "Setze Core-Dump-Größe auf 0"
ulimit -c 0

# Speicherbegrenzung (in Kilobytes)
echo "Begrenze virtuellen Speicher auf 2 GB"
ulimit -v 2097152

# CPU-Zeit begrenzen (in Sekunden)
echo "Begrenze CPU-Zeit auf 60 Sekunden"
ulimit -t 60

# Prozess mit diesen Limits starten
echo "Starte Prozess mit den konfigurierten Limits"
resource_intensive_command