Go 并发编程Goroutine的实现示例

package main

import "fmt"

func main() {

	// 使用go关键字使用goroutine调用hello函数
	go hello()
	for i := 0; i < 150000; i++ {
		//fmt.Println("main-", i)
	}
}

func hello() {
	for i := 0; i < 10; i++ {
		fmt.Println("hello-----------", i)
	}
}

/*
    此处代码可设置main协程for循环次数的大小观测go协程调用hello情况
*/

package main

import (
	"fmt"
	"runtime"
)

func main() {

	//获取系统信息
	fmt.Println("获取GOROOT目录", runtime.GOROOT())
	fmt.Println("获取操作系统", runtime.GOOS)
	fmt.Println("获取CPU", runtime.NumCPU())

	//Goroutine 调度
	go func() {
		for i := 0; i < 100; i++ {
			fmt.Println("Goroutine---", i)
		}
	}()

	for i := 0; i < 100; i++ {
		//让出时间片，让别的Goroutine先执行，不一定可以让成功
		runtime.Gosched()
		fmt.Println("main---", i)
	}
}

package main

import (
	"fmt"
	"runtime"
	"time"
)

func main() {
	/*
		因为goroutine2延时了一定时间，如果goroutine1不让出CPU时间片那么必先执行完成
	*/
	go func() {
		for i := 0; i < 5; i++ {
			runtime.Gosched() // 让出 CPU 时间片
			fmt.Println("Goroutine 1:", i)
		}
	}()

	go func() {
		for i := 0; i < 5; i++ {
			time.Sleep(100 * time.Millisecond)
			fmt.Println("Goroutine 2:", i)
		}
	}()

	time.Sleep(3 * time.Second) // 等待两个 goroutine 执行完毕
}

package main

import (
	"fmt"
	"runtime"
	"sync"
)

func main() {
	var wg sync.WaitGroup //创建并发组
	fmt.Printf("当前运行的goroutine数量: %d\n", runtime.NumGoroutine())
	//创建10个协程
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			fmt.Printf("第 %d 个协程在 running\n", id)
		}(i)
	}
	fmt.Printf("当前运行的goroutine数量: %d\n", runtime.NumGoroutine())
	wg.Wait()

	fmt.Printf("CPU核心数: %d\n", runtime.NumCPU())
}

package main

import (
	"fmt"
	"sync"
	"time"
)

// 定义全局变量 票库存为10张
var tickets int = 10

// 创建锁
var mutexs sync.Mutex

func main() {
	//三个窗口同时售票
	go saleTicket("售票口1")
	go saleTicket("售票口2")
	go saleTicket("售票口3")
	time.Sleep(time.Second * 15) //等待售票完

}

// 售票函数
func saleTicket(name string) {
	for {
		// 在检查之前上锁
		mutexs.Lock()
		if tickets > 0 {
			time.Sleep(time.Second)
			fmt.Printf("%s剩余的票数为：%d\n", name, tickets)
			tickets--
		} else {
			fmt.Println("票已售完")
			break
		}
		//操作结束后解锁
		mutexs.Unlock()
	}
}

package main

import (
	"fmt"
	"sync"
	"time"
)

var w sync.WaitGroup

func main() {
	// 公司最后关门的人   0
	// wg.Add(2) 判断还有几个线程、计数  num=2
	// wg.Done() 我告知我已经结束了  -1
	w.Add(2)

	go test11()
	go test22()

	fmt.Println("main等待ing")
	w.Wait() // 等待 wg 归零，才会继续向下执行
	fmt.Println("end")

	// 理想状态：所有协程执行完毕之后，自动停止。
	//time.Sleep(3 * time.Second)

}
func test11() {
	for i := 0; i < 5; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println("test1--", i)
	}
	w.Done()
}
func test22() {
	defer w.Done()
	for i := 0; i < 5; i++ {
		fmt.Println("test2--", i)
	}
}

close(ch)

v,ok := <- ch

package main

import (
	"fmt"
	"strconv"
	"time"
)

func main() {
	//定义通道可以写10个数据
	ch := make(chan string, 10)
	go test3(ch)

	for v := range ch {
		fmt.Println(v)
	}
}

func test3(ch chan string) {
	for i := 0; i < 5; i++ {
		time.Sleep(time.Second)
		fmt.Println("通道内写入数据", "tset--"+strconv.Itoa(i))
		ch <- "tset--" + strconv.Itoa(i)
	}
	close(ch)//如果不关闭协程，主协程的for循环一值阻塞，知道报错“fatal error: all goroutines are asleep - deadlock!”
}

package main

import (
	"fmt"
	"time"
)

func main() {
	ch := make(chan int)
	go writerOnly(ch)
	go readOnly(ch)

	time.Sleep(time.Second * 2)
}

// 只读，指只允许管道读入/写出数据
func writerOnly(ch chan<- int) {
	ch <- 10
}

// 只写，指指只允许管道读出/写入数据
func readOnly(ch <-chan int) {
	temp := <-ch
	fmt.Println(temp)
}

package main

import (
	"fmt"
	"time"
)

func main() {

	ch1 := make(chan int)
	ch2 := make(chan int)

	go func() {
		time.Sleep(time.Second * 2)
		ch1 <- 100
	}()

	go func() {
		time.Sleep(time.Second * 2)
		ch2 <- 200
	}()

	select {
	case num1 := <-ch1:
		fmt.Println("ch1--", num1)
	case num2 := <-ch2:
		fmt.Println("ch2--", num2)
	}
    //没有default，则等待通道(阻塞),因为select{}本身是阻塞的
}

package main

import (
	"fmt"
	"sync"
	"time"
)

// 定义全局chan，存储票总数
var totalTickets chan int
var wg sync.WaitGroup

func main() {

	// 初始化票数量：总票数10张
	totalTickets = make(chan int, 2)
	totalTickets <- 10

	wg.Add(3)

	go sell("售票口1")
	go sell("售票口2")
	go sell("售票口3")

	wg.Wait()

	fmt.Println("买完了，下班")

}

func sell(name string) {
	defer wg.Done()

	for { //for循环表示一直在卖，一直在营业
		residue, ok := <-totalTickets
		if !ok {
			fmt.Printf("%s: 关闭\n", name)
			break
		}
		if residue > 0 {
			time.Sleep(time.Second * 1)
			totalTickets <- residue - 1 //
			fmt.Println(name, "售出1张票，余票：", residue)
		} else {
			//进入此处时票已经买完了，因为for循环一进来售票窗口就检查是否还有票，假如最后卖完的是售票口3，那么销售窗口1跟2就会判断还有没有
			fmt.Printf("%s: 关闭\n", name)
			close(totalTickets)
			break
		}
	}
}