Channel Synchronization

package main

import (
	"fmt"
	"time"
)

func worker(done chan bool) {
	fmt.Print("working...")
	time.Sleep(time.Second)
	fmt.Println("done")

	// Signal that we're done
	done <- true
}

func main() {
	// Create a channel for synchronization
	done := make(chan bool, 1)
	
	// Start the worker goroutine
	go worker(done)

	// Block until we receive notification
	<-done
}

done := make(chan bool, 1)

func task(done chan bool) {
	// Do work
	done <- true
}

func main() {
	done := make(chan bool)
	go task(done)
	<-done  // Wait for completion
}

func main() {
	done := make(chan bool)
	
	go task1(done)
	<-done  // Wait for task1
	
	go task2(done)
	<-done  // Wait for task2
}

func main() {
	done := make(chan bool)
	
	// Start all tasks
	for i := 0; i < 5; i++ {
		go task(i, done)
	}
	
	// Wait for all to complete
	for i := 0; i < 5; i++ {
		<-done
	}
}

done := make(chan struct{})

go func() {
	// Do work
	done <- struct{}{}  // Send signal
}()

<-done  // Receive signal

func fetchWithTimeout(url string, timeout time.Duration) (string, error) {
	result := make(chan string, 1)
	errors := make(chan error, 1)
	
	go func() {
		resp, err := http.Get(url)
		if err != nil {
			errors <- err
			return
		}
		defer resp.Body.Close()
		
		body, _ := io.ReadAll(resp.Body)
		result <- string(body)
	}()
	
	select {
	case data := <-result:
		return data, nil
	case err := <-errors:
		return "", err
	case <-time.After(timeout):
		return "", fmt.Errorf("timeout after %v", timeout)
	}
}

func worker(start, done chan bool) {
	<-start  // Wait for start signal
	fmt.Println("Working...")
	time.Sleep(time.Second)
	done <- true  // Signal completion
}

func main() {
	start := make(chan bool)
	done := make(chan bool)
	
	go worker(start, done)
	
	fmt.Println("Preparing...")
	time.Sleep(500 * time.Millisecond)
	
	start <- true  // Start the worker
	<-done        // Wait for completion
	
	fmt.Println("All done")
}

func stage1(out chan<- int) {
	for i := 0; i < 5; i++ {
		out <- i
	}
	close(out)
}

func stage2(in <-chan int, out chan<- int) {
	for num := range in {
		out <- num * 2
	}
	close(out)
}

func main() {
	ch1 := make(chan int)
	ch2 := make(chan int)
	
	go stage1(ch1)
	go stage2(ch1, ch2)
	
	// Synchronized by channel operations
	for result := range ch2 {
		fmt.Println(result)
	}
}

done := make(chan struct{})
go func() {
	defer close(done)  // Signal completion by closing
	// Do work
}()
<-done

shutdown := make(chan struct{})

go func() {
	for {
		select {
		case <-shutdown:
			return
		default:
			// Do work
		}
	}
}()

// Trigger shutdown
close(shutdown)

func fanOut(in <-chan int, workers int) []<-chan int {
	channels := make([]<-chan int, workers)
	for i := 0; i < workers; i++ {
		ch := make(chan int)
		channels[i] = ch
		go func(out chan<- int) {
			for num := range in {
				out <- process(num)
			}
			close(out)
		}(ch)
	}
	return channels
}