all: add mainthread.Go

Author: changkun

mainthread.go

@@ -1,6 +1,8 @@
-// Copyright 2020 The golang.design Initiative Authors.
+// Copyright 2021 The golang.design Initiative Authors.
 // All rights reserved. Use of this source code is governed
-// by a GNU GPLv3 license that can be found in the LICENSE file.
+// by a MIT license that can be found in the LICENSE file.
+//
+// Written by Changkun Ou <changkun.de>
 
 package mainthread // import "golang.design/x/mainthread"
 
@@ -9,21 +11,14 @@ import (
 	"sync"
 )
 
-var funcQ = make(chan funcData, runtime.GOMAXPROCS(0))
-
 func init() {
 	runtime.LockOSThread()
 }
 
-type funcData struct {
-	fn   func()
-	done chan struct{}
-}
-
-// Init initializes the functionality for running arbitrary subsequent
-// functions on a main system thread.
+// Init initializes the functionality of running arbitrary subsequent
+// functions be called on the main system thread.
 //
-// Init must be called in the main package.
+// Init must be called in the main.main function.
 func Init(main func()) {
 	done := donePool.Get().(chan struct{})
 	defer donePool.Put(done)
@@ -38,12 +33,14 @@ func Init(main func()) {
 	for {
 		select {
 		case f := <-funcQ:
-			func() {
-				defer func() {
-					f.done <- struct{}{}
-				}()
+			if f.fn != nil {
 				f.fn()
-			}()
+				if f.done != nil {
+					f.done <- struct{}{}
+				}
+			} else if f.fnv != nil {
+				f.ret <- f.fnv()
+			}
 		case <-done:
 			return
 		}
@@ -59,6 +56,24 @@ func Call(f func()) {
 	<-done
 }
 
-var donePool = sync.Pool{
-	New: func() interface{} { return make(chan struct{}) },
+// Go schedules f to be called on the main thread.
+func Go(f func()) {
+	funcQ <- funcData{fn: f}
+}
+
+var (
+	funcQ    = make(chan funcData, runtime.GOMAXPROCS(0))
+	donePool = sync.Pool{New: func() interface{} {
+		return make(chan struct{})
+	}}
+	retPool = sync.Pool{New: func() interface{} {
+		return make(chan interface{})
+	}}
+)
+
+type funcData struct {
+	fn   func()
+	done chan struct{}
+	fnv  func() interface{}
+	ret  chan interface{}
 }

mainthread_test.go

@@ -1,15 +1,22 @@
-// Copyright 2020 The golang.design Initiative Authors.
+// Copyright 2021 The golang.design Initiative Authors.
 // All rights reserved. Use of this source code is governed
-// by a GNU GPLv3 license that can be found in the LICENSE file.
+// by a MIT license that can be found in the LICENSE file.
+//
+// Written by Changkun Ou <changkun.de>
+
+//go:build linux
+// +build linux
 
 package mainthread_test
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"sync"
 	"sync/atomic"
 	"testing"
+	"time"
 
 	"golang.design/x/mainthread"
 	"golang.org/x/sys/unix"
@@ -22,11 +29,12 @@ func init() {
 }
 
 func TestMain(m *testing.M) {
-	mainthread.Init(func() {
-		os.Exit(m.Run())
-	})
+	mainthread.Init(func() { os.Exit(m.Run()) })
 }
 
+// TestMainThread is not designed to be executed on the main thread.
+// This test tests the a call from this function that is invoked by
+// mainthread.Call is either executed on the main thread or not.
 func TestMainThread(t *testing.T) {
 	var (
 		nummain uint64
@@ -39,11 +47,14 @@ func TestMainThread(t *testing.T) {
 		go func() {
 			defer wg.Done()
 			mainthread.Call(func() {
+				// Code inside this function is expecting to be executed
+				// on the mainthread, this means the thread id should be
+				// euqal to the initial process id.
 				tid := unix.Gettid()
 				if tid == initTid {
 					return
 				}
-				t.Logf("call is not executed on the main thread, want %d, got %d", initTid, tid)
+				t.Errorf("call is not executed on the main thread, want %d, got %d", initTid, tid)
 			})
 		}()
 		go func() {
@@ -60,6 +71,29 @@ func TestMainThread(t *testing.T) {
 	}
 }
 
+func TestGo(t *testing.T) {
+	done := make(chan struct{})
+	mainthread.Go(func() {
+		time.Sleep(time.Second)
+		done <- struct{}{}
+	})
+	ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond)
+	defer cancel()
+	select {
+	case <-ctx.Done():
+	case <-done:
+		t.Fatalf("mainthread.Go is not executing in parallel")
+	}
+
+	ctxx, cancell := context.WithTimeout(context.Background(), time.Second)
+	defer cancell()
+	select {
+	case <-ctxx.Done():
+		t.Fatalf("mainthread.Go never schedules the function")
+	case <-done:
+	}
+}
+
 func BenchmarkCall(b *testing.B) {
 	f := func() {}
 	mainthread.Init(func() {