Bash Coprocesses: 7 Powerful Tricks You’ll Love

Bash Coprocesses are one of the most underused yet powerful features in Linux scripting. A coprocess allows your script to communicate with a background process in real-time, improving efficiency, concurrency, and responsiveness in automation tasks.

What Are Bash Coprocesses?

A Bash coprocess is a background process that runs alongside your script, allowing two-way communication. Unlike subshells or pipelines, coprocesses stay alive, so you don’t need to repeatedly restart commands.

This persistence makes them especially useful for tasks requiring continuous interaction. Instead of starting a new process every time, you keep one running, saving system resources and execution time.

Why Use Bash Coprocesses?

Bash Coprocesses bring several benefits to Linux automation and scripting:

• Efficiency: Reduce process creation overhead by reusing a running process.
• Real-time Interaction: Exchange data with a process as it runs.
• Concurrency: Perform multiple operations simultaneously without blocking the main script.

By leveraging coprocesses, you can make your Bash scripts smarter, faster, and more responsive to data streams.

Creating Bash Coprocesses

You create a coprocess using the coproc command. Its basic syntax looks like this:

coproc [name] command [arguments]

coproc [name] command [arguments]

• name (optional): Assigns a variable name to the coprocess.
• command: The command or script you want to run in the background.

Once created, the coprocess exposes file descriptors you can use to read from and write to the process.

How Bash Coprocesses Work Internally

When you start a coprocess, Bash automatically creates an array called COPROC:

• COPROC[0] → File descriptor for reading the coprocess’s output.
• COPROC[1] → File descriptor for writing input to the coprocess.

Additionally, Bash sets the variable COPROC_PID with the process ID of the coprocess. This allows you to manage or terminate it when needed.

Example 1: Uppercase to Lowercase Conversion

Here’s a simple script that demonstrates how Bash Coprocesses work:

#!/bin/bash
# translate.sh
while read -r line; do
  declare -l lowercase="$line"
  echo "$lowercase"
done

#!/bin/bash
# translate.sh
while read -r line; do
  declare -l lowercase="$line"
  echo "$lowercase"
done

Run it with a coprocess:

coproc my_translate ./translate.sh
echo "HELLO, WORLD!" >& "${COPROC[1]}"
cat <& "${COPROC[0]}"

coproc my_translate ./translate.sh
echo "HELLO, WORLD!" >& "${COPROC[1]}"
cat <& "${COPROC[0]}"

Output:

hello, world!

hello, world!

This script launches a coprocess that converts uppercase text into lowercase and streams the result back to the main script.

Example 2: Named Coprocess for Sorting

Named coprocesses are handy for keeping scripts readable and organized:

coproc MYPROC { sort; }

cat unsorted.txt >& "${MYPROC[1]}"
cat <& "${MYPROC[0]}" > sorted.txt

coproc MYPROC { sort; }

cat unsorted.txt >& "${MYPROC[1]}"
cat <& "${MYPROC[0]}" > sorted.txt

Here, MYPROC sorts the contents of unsorted.txt in real time and outputs results into sorted.txt.

Example 3: Real-Time Log Monitoring

Coprocesses shine in monitoring tasks such as log watching:

coproc TAIL { tail -f /var/log/syslog; }

while read -r line <& "${TAIL[0]}"; do
  if [[ $line =~ "error" ]]; then
    echo "Error detected: $line"
  fi
done

coproc TAIL { tail -f /var/log/syslog; }

while read -r line <& "${TAIL[0]}"; do
  if [[ $line =~ "error" ]]; then
    echo "Error detected: $line"
  fi
done

This script continuously monitors system logs. Whenever the word “error” appears, the script immediately alerts the user.

Example 4: Coprocess for Network Communication

You can even use coprocesses for socket-based communication:

coproc NETCAT { nc -l 8080; }

echo "Hello from Bash Coprocess" >& "${NETCAT[1]}"
cat <& "${NETCAT[0]}"

coproc NETCAT { nc -l 8080; }

echo "Hello from Bash Coprocess" >& "${NETCAT[1]}"
cat <& "${NETCAT[0]}"

This sets up a basic TCP listener on port 8080 and interacts with incoming connections. It’s a simple way to test network scripts.

Example 5: Multiple Coprocesses

You’re not limited to one coprocess. You can run multiple in parallel:

coproc DATE1 { date; }
coproc DATE2 { date +"%T"; }

echo "Full date: $(cat <& "${DATE1[0]}")"
echo "Time only: $(cat <& "${DATE2[0]}")"

coproc DATE1 { date; }
coproc DATE2 { date +"%T"; }

echo "Full date: $(cat <& "${DATE1[0]}")"
echo "Time only: $(cat <& "${DATE2[0]}")"

This demonstrates how separate coprocesses can handle different tasks simultaneously, making scripts more powerful.

Example 6: Cleaning Up Coprocesses

Always manage coprocesses responsibly. Use COPROC_PID to terminate them when done:

coproc LONGTASK { sleep 1000; }
kill "$COPROC_PID"

coproc LONGTASK { sleep 1000; }
kill "$COPROC_PID"

Failing to clean up can leave unnecessary background processes consuming resources.

Example 7: Advanced Coprocess for Data Processing

Coprocesses are excellent for large data streams. Here’s an example that compresses files in real-time:

coproc GZIP { gzip -c > archive.gz; }

cat bigfile.txt >& "${GZIP[1]}"
exec {GZIP[1]}>&-   # Close input to finish compression
wait "$COPROC_PID"

coproc GZIP { gzip -c > archive.gz; }

cat bigfile.txt >& "${GZIP[1]}"
exec {GZIP[1]}>&-   # Close input to finish compression
wait "$COPROC_PID"

This script compresses a large file efficiently while the main script remains responsive.

Best Practices for Bash Coprocesses

1. Always close file descriptors when communication is complete.
2. Use named coprocesses for readability in larger scripts.
3. Monitor COPROC_PID to manage or terminate background processes.
4. Handle errors gracefully to avoid zombie processes.
5. Avoid overcomplication — coprocesses add power but also complexity.

Key Takeaways

• Bash Coprocesses allow persistent communication with background processes.
• They improve efficiency by avoiding repeated process creation.
• Useful in data processing, real-time monitoring, and concurrency.
• Require proper management of file descriptors and cleanup.

By integrating coprocesses into your Bash scripts, you unlock a more advanced and efficient scripting toolkit.

Frequently Asked Questions (FAQ)