What will happen to a golang blocking function if the invoker of this function has done?

I wonder what will happen if the interruptable_call is uninterruptable and return after the context is done. The call stack would have been already destroyed. What would the return action perform? How would select perform when one case return while another case is still running. Would that case function call be terminated? in what way?

package main

import (
	"context"
	"fmt"
	"time"
)

func interruptable_call() <-chan time.Time {
	return time.After(1 * time.Second)
}

func A(ctx context.Context) int {
	for {
		select {
		case <-ctx.Done():
			fmt.Println("func done")
			return 1
		case <-interruptable_call():
			fmt.Println("blocking")
		}
	}
	return 0
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	fmt.Println("go A")
	go A(ctx)
	fmt.Println("go A done")
	select {
	case <-ctx.Done():
		fmt.Println("main done")
		break
	}
}

I am not sure what you mean by "synchronisation problem", since there is no synchronization here.. You need to synchronise your goroutines using channels, waitgroups or any other means if you want to be sure that your spawned goroutines performed their task.

It doesn't really matter what happens in the goroutine - if it's not synchronised with main gouroutine it will cease to exist after main exits.

Return value from function called asynchronously in goroutine won't be available to you anyway.

You can check out how blocking calls work for yourself:

package main

import (
	"context"
	"fmt"
	"time"
)

func interruptable_call(sleep time.Duration) <-chan time.Time {
	fmt.Println("sleeping for ", sleep*time.Second)
	time.Sleep(sleep * time.Second)
	return time.After(0 * time.Second)
}

func A(ctx context.Context) int {
	for {
		select {
		case <-ctx.Done():
			fmt.Println("func done")
			return 1
		case <-interruptable_call(2):
			fmt.Println("blocking")
		case <-interruptable_call(3):
			fmt.Println("blocking")
		case <-interruptable_call(4):
			fmt.Println("blocking")
		case <-interruptable_call(5):
			fmt.Println("blocking")
		}
	}
	return 0
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	fmt.Println("go A")
	go A(ctx)
	fmt.Println("go A done")
	select {
	case <-ctx.Done():
		fmt.Println("main done")
		break
	}
}