In the last lesson, we managed to set up our algorithm to make use of both an io.Pipe, passing it into our io.Reader, in order to have multiple readers at the same time from the same source without storing the data in memory.

Whilst this algorithm works, using the io.TeeReader this way can be hard to wrap your head around, especially when it comes to chaining across multiple io.TeeReaders.

Therefore, in this lesson, we're going to take a look at another function available in the io package, which can allow us to write to multiple writers at the same time. This is the io.MultiWriter function, which accepts a variadic array of writers—meaning we can pass in one or more—and creates a new writer that duplicates the writes to each of the provided writers. Again, this is actually very similar to the Unix tee command.

If we take a look at a quick example, you can see here that there are two strings.Builder values being passed into the io.MultiWriter. Then the actual strings.Reader is being copied over, which is allowing both of these strings.Builder values to have the same written data, albeit with one copy operation.

---

Refactoring to Use io.MultiWriter

To see how this works in our own code, let's go ahead and make use of it in our getCounts function. First, we'll refactor the code to be a bit more concise.

We'll start by defining three io.Reader variables:

var bytesReader io.Reader = nil
var wordsReader io.Reader = nil
var linesReader io.Reader = nil

Then let's go ahead and get rid of our existing pipes and any logic where we're using them.

Next, we want to create three different pipes—one for each of our count functions.

First, create the pipe for the bytes counter:

bytesReader, bytesWriter := io.Pipe()

Do the same for the words counter:

wordsReader, wordsWriter := io.Pipe()

And the same for the lines counter:

linesReader, linesWriter := io.Pipe()

---

Creating and Using the MultiWriter

Now we want to write to all three of these writers at the same time. This is where io.MultiWriter comes in.

w := io.MultiWriter(bytesWriter, wordsWriter, linesWriter)

Now that we have a single writer that writes to all three underlying pipes, we can copy data to it using io.Copy:

io.Copy(w, r)

However, if we try to use this directly, the code will deadlock.

This is because:

• The go routines that read from the pipes haven’t started yet.
• None of the writers are being closed.

io.MultiWriter itself doesn’t implement io.Closer, so we must manually close each individual writer after writing.

---

Fixing the Deadlock

We fix this by making sure to run our goroutines first, and then adding defer statements to close each writer individually once copying is complete:

defer bytesWriter.Close()
defer wordsWriter.Close()
defer linesWriter.Close()

Now when we rerun the code, everything works as expected.

---

Why io.MultiWriter Is Preferable

Personally, using io.MultiWriter to write to three different pipes at the same time is much easier to reason about than chaining multiple io.TeeReaders together.

And as you can see, it’s not that difficult to actually use. The only caveat is that we need to close each of the individual writers once we're done copying to them—but that’s not too bad.

It would be nice if something like an io.MultiCloser existed to simplify this, but it's understandable why it doesn’t.

---

Summary

We now have a new and improved function that makes use of constructs from the io package to solve the problem of separating concerns for:

• Counting words
• Counting lines
• Counting bytes

However, this algorithm is going to be slower than our single-pass version. Even though the three counts happen simultaneously, there are still three separate iterations of the data, plus goroutine overhead and thread synchronisation.

So while we can intuit that this approach is slower, it would be good to measure it and know for sure.

---

Next Step: Benchmarking

Being able to measure whether an algorithm is faster or slower is critical in software development. And while intuition helps, actual data is much better.

Fortunately, Go makes this easy—and we’ll take a look at how to do that in the next lesson.

Before moving on, let’s ensure our code is correct:

go test

✅ All tests pass!

Great.

Now go ahead and commit your changes:

git add .
git commit -m "added in new IO based algorithm"

With that, I’ll see you in the next lesson.