andreimerlescu/ackee

Hi there 👋,

I enjoy writing Go. Here's a fun micro-project that I did to explore what happens when you try to close a closed channel... what if I didn't want a panic to get thrown? Is it possible? Why yes it is!

safe_close.go

package main

func safeClose[T any](ch chan T) (closed bool) {
	// allow panic
	defer func() {
		if r := recover(); r != nil {
			closed = true
			return
		}
	}()
	_, chOpen := <-ch
	if chOpen {
		closed = true
		close(ch)
	} else {
		closed = false
	}
	return
}

safe_close_test.go

package main

import (
	"github.com/stretchr/testify/assert"
	"testing"
)

func Test_safeClose(t *testing.T) {
	type args[T any] struct {
		ch chan T
	}
	type testCase[T any] struct {
		name string
		args args[T]
		want bool
	}

	// open channel with bool in buffer
	ch1 := make(chan bool, 1)
	ch1 <- true

	// closed channel with bool in buffer
	ch2 := make(chan bool, 1)
	ch2 <- false
	close(ch2)

	// closed channel with empty buffer
	ch3 := make(chan bool, 1)
	close(ch3)

	tests := []testCase[bool]{
		{
			name: "open channel with bool in buffer",
			args: args[bool]{ch1},
			want: true,
		},
		{
			name: "closed channel with bool in buffer",
			args: args[bool]{ch2},
			want: true,
		},
		{
			name: "closed channel with empty buffer",
			args: args[bool]{ch3},
			want: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert.Equal(t, tt.want, safeClose(tt.args.ch))
		})
	}
}

Then go run it....

go test .

Which returns:

=== RUN   Test_safeClose
--- PASS: Test_safeClose (0.00s)
=== RUN   Test_safeClose/open_channel_with_bool_in_buffer
    --- PASS: Test_safeClose/open_channel_with_bool_in_buffer (0.00s)
=== RUN   Test_safeClose/closed_channel_with_bool_in_buffer
    --- PASS: Test_safeClose/closed_channel_with_bool_in_buffer (0.00s)
=== RUN   Test_safeClose/closed_channel_with_empty_buffer
    --- PASS: Test_safeClose/closed_channel_with_empty_buffer (0.00s)
PASS

Process finished with the exit code 0

Check it out in the Go Playground...

Why do I need this functionality? How does this for select statement look to you?

// wait for results
for {
	select {
	case <-ctx.Done(): // parent context canceled
		if ctx.Err() != nil {
			log.Println(ctx.Err()) // with error
		}
		closeEmAll(false)
		return ImportedAssetDownloadOutput{} // exit out of the func

	case d, chOk := <-documentResults: // documents finished!
		if chOk { // open channel
			dmu.Lock()
			documents = d                 // set documents
			documentsReceived.Store(true) // mark flag
			dmu.Unlock()
			closeAllDocuments(false)
		}

	case p, chOk := <-pageResults: // pages finished!
		if chOk { // open channel
			pmu.Lock()
			pages = p                 // set pages
			pagesReceived.Store(true) // mark flag
			pmu.Unlock()
			closeAllPages(false)
		}

	default: // when both aren't completed yet
		if documentsReceived.Load() && pagesReceived.Load() { // both received
			output := ImportedAssetDownloadOutput{ // structure the output
				ImportedDocumentsDownloadOutput: documents,
				ImportedPagesDownloadOutput:     pages,
			}

			log.Printf("total documents = %d\ntotal pages = %d\n", len(output.Documents), len(output.Pages))
			closeEmAll(true)
			return output
		}
	}
}