Go语言系列三

package

• 1> 基本复用模块单元
  • 以首字母大写来表明可被包外代码访问
• 2> 代码的package可以和所在的目录不一致
• 3> 同一目录里的Go代码的package要保持一致

package

• 1> 通过go get来获取远程依赖

  • go get -u 强制从网络更新远程依赖

• 2> 注意代码在GitHub上的组织形式，以适应go get

  • 直接以代码路径开始，不要有src

  示例一

  示例二

  go get 下载的包保存在哪里呢？

  一般他会保存在这个目录：$GOPATH/src/import-path , 若你有多个GOPATH（工作区），

  则会保存在第一个工作区中。go env 查看go环境

init 方法

• 1> 在main被执行前，所有依赖的package的init方法都会被执行
• 2> 不同包的init函数按照包导入的依赖关系决定执行顺序
• 3> 每个包可以有多个init函数
• 4> 包的每个源文件也可以有多个init函数，这点比较特殊

依赖管理

Go未解决的依赖问题

• 1> 同一环境下，不同项目使用同一包的不同版本
• 2> 无法管理对包的特定版本的依赖

vendor路径

随着Go 1.5 release版本的发布，vendor目录被添加到除了GOPATH和GOROOT之外的依赖目录查找的解决方案

在Go1.6之前，你需要手动的设置环境变量

查找依赖包路径的解决方案如下：

• 1> 当前包下的vendor目录
• 2> 向上级目录查找，直到找到src下的vendor目录
• 3> 在GOPATH下面查找依赖包
• 4> 在GOROOT目录下查找

常用的依赖管理工具

godep https://github.com/tools/godep

glide https://github.com/Masterminds/glide

dep https://github.com/golang/dep

安装glide

• 1> sudo apt install golang-glide
• 2> glide init
• 3> glide install

Thead vs Groutine

• 1> 创建时默认的stack的大小

  • JDK5以后Java Thread stack 默认为1M
  • Groutine的Stack初始化大小为2K

• 2> 和KSE (Kernel Space Entity)的对应关系

  • Java Thread 是1 ：1
  • Groutine是M:N

  线程关系图
  

//错误写法，想想为什么？
func TestGroutine(t *testing.T) {
	for i := 0; i < 10; i++ {
		go func() {
			fmt.Println(i)
		}()
	}
	time.Sleep(time.Millisecond * 50)
}
/* !< output */
=== RUN   TestGroutine
10
10
10
10
10
10
10
10
10
10
--- PASS: TestGroutine (0.05s)

共享内存并发机制

Lock

Lock lock = ...;
lock.lock();
try{
    //process (thread-safe)
}catch(Exception ex){
}finally{
    lock.unlock();
}

Lock图

WaitGroup

var wg sync.WaitGroup
for i := 0; i < 5000; i++ {
    wg.Add(1)
    go func() {
        defer func() {
            wg.Done()
        }()
        ...
    }()
}
wg.Wait()

CSP并发机制

Communicating sequential processes

Actor Model

CSP vs Actor

• 1> 和Actor的直接通讯不同，CSP模式则是通过Channel进行通讯的，更松耦合一些

• 2> Go中channel是有容量限制并且独立于处理Groutine，而如Erlang，Actor模式中的mailbox容量是无限的

  ​ 接收进程也总是被动地处理消息

  图

Channel

异步返回

/* !< java */
private static FutureTask<String> service() {
    FutureTask<String> task = new FutureTask<String>(()->"Dosomething");
    new Thread(task).start();
    return task;
}

FutureTask<String> ret = service();
	System.out.println("Do something else");
	System.out.println(ret.get());

多路选择和超时控制

select

/* !< 多渠道的选择*/
select {
    case ret := <-retCh1:
    	t.Logf("result %s", ret)
    case ret := <-retCh2:
    	t.Logf("result %s", ret)
    default:
    	t.Error("No one returned")
}

/* !< 超时控制 */
select {
	case ret := <-retCh:
    	t.Logf("result %s", ret)
    case <-time.After(time.Second * 1):
    	t.Error("time out")
}

channel的关闭

• 1> 向关闭的channel发送数据，会导致panic
• 2> v, ok <- ch; ok为bool值，true表示正常接受，false表示通道关闭
• 3> 所有的channel接收者都会在channel关闭时，立刻从阻塞等待中返回且上述ok值为false，这个广播机制常被利用，进行向多个订阅者同时发送信号， eg： 退出信号

任务的取消

Context与任务取消

关联任务的取消

Context

• 1> 根Context：通过context.Background()创建
• 2> 子Context: context.WithCancel(parentContext)创建
  • ctx, cancel := context.WithCancel(context.Background())
• 3> 当前Context被取消时，基于它的子context都会被取消
• 4> 接收取消通知<-ctx.Done()

并发任务： 仅执行一次

单例模式(懒汉模式，线程安全)

/* !< java */
public class Singleton {
    private static Singleton INSTANCE = null;
    private Singleton(){}
    public static Singleton getlntance() {
        if (ISTANCE == null) {
            synchronized (Singleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

var once sync.Once
var obj *SingletonObj

func GetSingletonObj() *SingletonObj {
    once.Do(func() {
        fmt.Printl("Create Singleton obj.")
        obj = &SingletonObj{}
    })
    return obj
}