设计模式中学习golang高级特性(一)

package simplefactory

import (
	"fmt"
)

// interface代表接口类型，Fruit都有一个展示价格的函数
type Fruit interface {
	HowMuch()
}

func NewFruit(t int) Fruit {
	if t == 1 {
		return &Apple{}
	} else if t == 2 {
		return &Banana{}
	}
	return nil
}

type Apple struct{}

func (*Apple) HowMuch() {
	fmt.Printf("Hi, Apple 一块钱 一斤\n")
}

type Banana struct{}

func (*Banana) HowMuch() {
	fmt.Printf("Hi, Banana 九毛钱 一斤\n")
}

package test_private_and_public

const (
	PubicVar    = `大写变量开头，这是一个公开的常量`
	privateVar  = `小写变量开头，这是一个私有的常量`
	_privateVar = `下划线开头，  这是一个私有的常量`
)

func PubicFuc() {
	println(`这是一个公开的函数`)
}

func privateFuc() {
	println(`这是一个私有的函数`)
}

func _privateFuc() {
	println(`这也是一个私有的函数`)
}

// 不带缓冲的通道，它里面可以放字符串类型，进和出都会阻塞。
ch1 := make(chan string)

// 队列长度为5个的通道，它里面可以放字符串类型，如果通道内元素达到队列长度时，再进就会阻塞。
ch2 := make(chan string, 5)

// 只读通道
ch3 := make(<-chan string)

// 只写通道
ch4 := make(chan<- string)

package main

import (
    "fmt"
)

func main() {
    // 构建一个通道
    ch := make(chan int)
    // 开启一个并发匿名函数
    go func() {
        fmt.Println("start goroutine")
        // 通过通道通知main的goroutine，接受之前我阻塞在这里
        ch <- 0
        fmt.Println("exit goroutine")

    }()
    fmt.Println("wait goroutine")
    // 读取通道的值，如果没有就阻塞
    <-ch
    fmt.Println("all done")
}
//运行结果
PS D:\code\golang-design-pattern\03_singleton> go run .\2n.go
wait goroutine
start goroutine
exit goroutine
all done

//实现部分
package singleton

import (
	"fmt"
	"sync"
)

// 包私有,该结构体不能直接使用
type goldaxe struct{}

func (axe goldaxe) TellTruth() {
	fmt.Printf("小伙汁你太诚实啦，金斧子是你的了\n")
}

// 全局变量
var (
	axe  *goldaxe
	once sync.Once
)

// 由于单例类型不能在包外直接使用，用一个接口类型带出去
type GoldAxe interface {
	TellTruth()
}

// 用于获取单例模式对象,大家都是一样的斧子
func GetGoldAxe() GoldAxe {
	once.Do(func() {
		axe = &goldaxe{}
	})

	return axe
}

//测试部分
package singleton

import (
	"sync"
	"testing"
)

const axeCounts = 100

func Test1(t *testing.T) {
	ins1 := GetGoldAxe()
	ins1.TellTruth()
	ins2 := GetGoldAxe()
	if ins1 != ins2 {
		t.Fatal("instance is not equal")
	}
}

func Test2(t *testing.T) {
	start := make(chan struct{})
	//信号量初始化
	wg := sync.WaitGroup{}
	//信号量搞个100个
	wg.Add(axeCounts)
	//金斧子数组，并进行了列表初始化
        //这么写你紫定get了:var float_array = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
	instances := [axeCounts]GoldAxe{}
	for i := 0; i < axeCounts; i++ {
		//开启100个协程
		go func(index int) {
			//获取channel的值，由于没有协程只能阻塞
			<-start
			instances[index] = GetGoldAxe()
			wg.Done()
		}(i)
	}
	//关闭channel，所有协程同时GetGoldAxe，达到了并发创建实例的情况
	close(start)
	//等待大家都获得自己金斧子后，才到下一步
	wg.Wait()
	for i := 1; i < axeCounts; i++ {
		if instances[i] != instances[i-1] {
			t.Fatal("instance is not equal")
		}
	}
}