标签：无法 html class memory \n add 阻塞 make done
//1. 低水平实现 生产者-消费者多线程
package main
import (
"container/list"
"fmt"
"math/rand"
"runtime"
"strconv"
"sync"
)
type (
Producer interface {
produceApple(s *superMakert) //生产苹果
}
Consumer interface {
buyApple(s *superMakert) //超市买苹果
}
superMakert struct {
//list包 实现了双向链表
apples *list.List
}
ProducerImpl struct {
Producer //实现生产苹果的接口
}
ConsumerImpl struct {
Consumer //实现消费苹果的接口
}
Apple struct {
weight float64 //重量
number int //编号
}
)
//实现接口里面的方法
func (p *ProducerImpl) produceApple(s *superMakert) {
for {
for s.apples.Len() > 0 {
//Gosched使当前go程放弃处理器，以让其它go程运行。
//它不会挂起当前go程，因此当前go程未来会恢复执行
runtime.Gosched()
}
apple := &Apple{
number: rand.Intn(10000),
weight: rand.Float64(),
}
s.apples.PushBack(apple)
fmt.Printf("生产了编号为%d,重量为%0.2f的苹果\r\n", strconv.Itoa(apple.number), apple.weight)
}
}
//实现接口里面的方法
func (c *ConsumerImpl) buyApple(s *superMakert) {
for {
if s.apples.Len() <= 0 {
runtime.Gosched()
}
element := s.apples.Back()
apple := element.Value.(*Apple)
fmt.Printf("买了编号为%d,重量为%0.2f的苹果\r\n", strconv.Itoa(apple.number), apple.weight)
s.apples.Remove(element)
}
}
func main() {
//WaitGroup用于等待一组线程的结束。父线程调用Add方法来设定应等待的线程的数量。
//每个被等待的线程在结束时应调用Done方法。同时，主线程里可以调用Wait方法阻塞至所有线程结束
wg := new(sync.WaitGroup)
p := new(ProducerImpl)
c := new(ConsumerImpl)
a := &superMakert{apples: list.New()}
wg.Add(2)
go func() { //goroutine
p.produceApple(a)
wg.Done()
}()
go func() {
c.buyApple(a)
wg.Done()
}()
wg.Wait()
}
运行程序报错: invalid memory address or nil pointer dereference
错误定位:
if s.apples.Len() <= 0 {
runtime.Gosched()
}
这里涉及到自旋锁的概念 这里参考 https://www.cnblogs.com/cyyljw/p/8006838.html
自旋锁可以使线程在没有取得锁的时候，不被挂起，而转去执行一个空循环，（即所谓的自旋，就是自己执行空循环），若在若干个空循环后，线程如果可以获得锁，则继续执行。若线程依然不能获得锁，才会被挂起。
使用自旋锁后，线程被挂起的几率相对减少，线程执行的连贯性相对加强。因此，对于那些锁竞争不是很激烈，锁占用时间很短的并发线程，具有一定的积极意义，但对于锁竞争激烈，单线程锁占用很长时间的并发程序，自旋锁在自旋等待后，往往毅然无法获得对应的锁，不仅仅白白浪费了CPU时间，最终还是免不了被挂起的操作 ，反而浪费了系统的资源。
错误的原因是 ： 空指针 。上面代码多个线程同时去访问，没有准确的判断 s.apple.Len() 是否是完全小于0的状态，也就是说在s.apples.Len()为0 的时候程序还是往下执行了导致了空指针。
优化代码为: 用循环一直去判断长度是否为空 但是使用这种方式 在单线程的时候没有意义而且非常消耗CPU的资源
for s.apples.Len() <= 0 {
runtime.Gosched()
}
运行结果如下: （两个线程同时运行）
总结: 这种方式实现太粗燥。
后续实现高级一点的go 多线程和channel通信
2. 使用channel 实现 多线程
package main
import (
"fmt"
"math/rand"
"strconv"
"sync"
)
//生产者-消费者 channel 实现 一边生产 一边消费
type (
Producer interface {
produceApple(s *superMakert) //生产苹果
}
Consumer interface {
buyApple(s *superMakert) //超市买苹果
}
superMakert struct {
//list包 实现了双向链表
//apples *list.List
apples chan Apple
}
ProducerImpl struct {
Producer //实现生产苹果的接口
}
ConsumerImpl struct {
Consumer //实现消费苹果的接口
}
Apple struct {
weight float64 //重量
number int //编号
}
)
//实现接口里面的方法
func (p *ProducerImpl) produceApple(s *superMakert) {
for {
apple := Apple{
number: rand.Intn(10000),
weight: rand.Float64(),
}
fmt.Printf("生产了编号为%s,重量为%0.2f的苹果\r\n", strconv.Itoa(apple.number), apple.weight)
s.apples <- apple
}
}
//实现接口里面的方法
func (c *ConsumerImpl) buyApple(s *superMakert) {
for {
element, _ := <-s.apples
fmt.Printf("买了编号为%s,重量为%0.2f的苹果\r\n", strconv.Itoa(element.number), element.weight)
}
}
func main() {
//WaitGroup用于等待一组线程的结束。父线程调用Add方法来设定应等待的线程的数量。
//每个被等待的线程在结束时应调用Done方法。同时，主线程里可以调用Wait方法阻塞至所有线程结束
wg := new(sync.WaitGroup)
p := new(ProducerImpl)
c := new(ConsumerImpl)
a := &superMakert{apples: make(chan Apple)}
wg.Add(2)
go func() { //goroutine
p.produceApple(a)
wg.Done()
}()
go func() {
c.buyApple(a)
wg.Done()
}()
wg.Wait()
}
3. 多生产多消费
package main
import (
"fmt"
"math/rand"
"strconv"
"sync"
)
//生产者-消费者 channel 实现 一边生产 一边消费
type (
Producer interface {
produceApple(s *superMakert) //生产苹果
}
Consumer interface {
buyApple(s *superMakert) //超市买苹果
}
superMakert struct {
//list包 实现了双向链表
//apples *list.List
apples chan Apple
}
ProducerImpl struct {
Producer //实现生产苹果的接口
}
ConsumerImpl struct {
Consumer //实现消费苹果的接口
}
Apple struct {
weight float64 //重量
number int //编号
}
)
//实现接口里面的方法
func (p *ProducerImpl) produceApple(s *superMakert) {
for {
apple := Apple{
number: rand.Intn(10000),
weight: rand.Float64(),
}
fmt.Printf("生产了编号为%s,重量为%0.2f的苹果\r\n", strconv.Itoa(apple.number), apple.weight)
s.apples <- apple
}
}
//实现接口里面的方法
func (c *ConsumerImpl) buyApple(s *superMakert) {
for {
element, ok := <-s.apples
if ok {
fmt.Printf("买了编号为%s,重量为%0.2f的苹果\r\n", strconv.Itoa(element.number), element.weight)
} else {
fmt.Printf("没有买到苹果")
}
}
}
func main() {
//WaitGroup用于等待一组线程的结束。父线程调用Add方法来设定应等待的线程的数量。
//每个被等待的线程在结束时应调用Done方法。同时，主线程里可以调用Wait方法阻塞至所有线程结束
wg := new(sync.WaitGroup)
p := new(ProducerImpl)
c := new(ConsumerImpl)
a := &superMakert{apples: make(chan Apple, 20)}
for i := 0; i < 20; i++ {
wg.Add(1)
go func() { //goroutine
p.produceApple(a)
wg.Done()
}()
}
for j := 0; j < 20; j++ {
wg.Add(1)
go func() {
c.buyApple(a)
wg.Done()
}()
}
wg.Wait()
}
标签：无法 html class memory \n add 阻塞 make done
原文地址：https://www.cnblogs.com/wpgraceii/p/10441036.html
