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
		}
	}
}