安装：

go get github.com/codyi/grabc

配置：

第一步：在你项目中的数据库中导入rabc.sql，生成对应数据表

第二步：在项目中引入grabc库（可以在项目中的main.go或router.go中引入）

在router.go或main.go中配置如下：

//引入grabc库
import "github.com/codyi/grabc"
func init() {
	//将路由注册到grabc，用于反射出对应的网址
	grabc.RegisterController(&controllers.SiteController{})
	grabc.RegisterController(&controllers.UserController{})
	//注册用户系统模型到grabc，用于用户ID和grabc插件绑定
	//注意：注册的这个用户模型，需要实现IUserModel中的方法
	grabc.RegisterUserModel(&models.User{})
	//增加忽律权限检查的页面
	grabc.AppendIgnoreRoute("site", "login")
	//403页面地址注册到grabc中，用于grabc插件禁止权限的页面跳转
	grabc.Http_403("/site/nopermission")
	//设置模板，为了让grabc更具有通用性，可以设置模板
	//目前设置模板只支持传入模板的内容
	grabc.SetLayout(libs.Grabc_layout, nil)
}

添加好上面的配置之后，剩下就是在controller中增加权限判了，个人建议做一个BaseController，然后每个controller都继承这个base，然后在BaseController中的方法中增加grabc的权限检查，这样每个controller在请求之前都会先检查权限~~

BaseController.go中Prepare方法中配置如下

//注册当前登录的用户，注意：user需要继承IUserIdentify接口
grabc.RegisterIdentify(user)

if !grabc.CheckAccess(this.controllerName, this.actionName) {
	this.redirect(this.URLFor("SiteController.NoPermission"))
}

到此grabc的功能都加完了，是不是很简单~~~

注意：增加完权限判断之后，会发现很多页面都不能访问了，那么就在router.go或main.go中增加如下代码

grabc.AppendIgnoreRoute("*", "*")

以上grabc将会忽律所有的权限检查，这时候需要去/route/index中增加路由，然后添加权限，角色和用户分配，都配置好之后，就可以将grabc.AppendIgnoreRoute(“*”, “*”)代码删掉，然后重启项目~~权限起作用了，是不是很简单~~

接口说明

IUserModel接口

//用于定义用户model
type IUserModel interface {
	//用户列表返回可用用户的id和姓名
	//参数：pageIndex 分页的页数
	//参数：pageCount 每页显示的用户数量
	//返回值：userList [用户ID]用户姓名，用户列表展示
	//返回值：totalNum 全部的用户数目，用于计算分页的数量
	//返回值：err
	UserList(pageIndex, pageCount int) (userList map[int]string, totalNum int, err error)
	//根据用户ID获取用户姓名
	FindNameById(id int) string 
}
IUserIdentify接口

type IUserIdentify interface {
	GetId() int //返回当前登录用户的ID
}

更过详细文档请访问：https://github.com/codyi/grabc

Sublime Text 3也要提前安装好，可以去Sublime Text3官网下载~~官网地址：https://www.sublimetext.com/

打开Sublime Text 3同时输入

 Ctrl + `

这时候Sublime Text3将出现如下界面

在最下面的输入框将下面的命令复制进去，然后回车

import  urllib.request,os;pf='Package Control.sublime-package';ipp=sublime.installed_packages_path();urllib.request.install_opener(urllib.request.build_opener(urllib.request.ProxyHandler()));open(os.path.join(ipp,pf),'wb').write(urllib.request.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read())

安装完成后会出现如下菜单

安装完成之后，就需要安装Sublime的插件了，Ctrl + Commd + p 打开Pack Controll 然后输入pcip（即“Package Control: Install Package”的缩写）回车

过一会将出现如下截图

这时候在输入框中输入：GoSublime将在下面列表中出现选项（注意：如果已经安装过，将不再显示），然后选中GoSublime回车，注意看Sublime Text3左下角，左下角将显示安装的进度。PS：同理继续安装：SidebarEnhancements和Go Build

安装GoCode，在shell中执行下面命令

go get -u github.com/nsf/gocode

都安装完之后，重启Sublime Text3，这时候打开go的源文件代码，看看是不是代码高亮了，而且输入也有了代码提示~~~

PS：在Sublime Text3中执行编译源文件，需要在系统中设置好GOBIN和GOPATH，如果按住Command+b不能运行，那么在Sublime Text3中重新配置，按照下面的截图打开配置文件

然后输入下面的配置，然后再试试Command+b~~

{
    "GOBIN": "你本机的GOBIN目录",
    "GOPATH": "你本机的GOPATH目录"
}

boom安装，使用很简单，详细的安装和使用可以去这个网址看。https://github.com/rakyll/boom

boom的程序很简单，总共代码不到1000行。程序文件有：

• 入口文件：boom.go，这个文件主要定义了boom接受的参数，main函数，请求网址解析
• boomer.go 定义了几个结构体
  result struct 包含了每个网址请求后的结果
  ReqOpts struct 包含了请求网址的一些信息，例如：url，method，header等
  Boomer struct 包括了boom的主要信息，例如：请求的次数，并发数，Qps等
• run.go 总共三个方法：
  Run 执行boom测试
  worker 是每个请求的协程，这里发送请求，获取请求网址的状态，以及计算请求花费的时间
  run 正式执行压力测试，开启规定的协程，启动worker(注意这个方法与上面的Run不一样)

总结：

1. 学到了golang匿名实例化struct，并且执行struct的方法
2. 对flag包、WaitGroup的用法有了深刻认识

ps：这个程序引用了一个pd的包，pd是在终端下的进度条。

达达的测试github地址

https://github.com/codyi/go-labs

1.  对slice数据结构,如果里面存放的是结构铁，不要使用range遍历，最消耗性能。可以考虑如下写法：

   var a := make([]BigStruct, 1000)
   for i := 0; i < len(a); i++ {
       obj := a[i]
   }

    

Cond有三个方法：Wait，Signal，Broadcast。
Wait添加一个计数，也就是添加一个阻塞的goroutine。
Signal解除一个goroutine的阻塞，计数减一。
Broadcast接触所有wait goroutine的阻塞。

那外部传入的Locker，是对wait，Signal，Broadcast进行保护。防止发送信号的时候，不会有新的goroutine进入wait。在wait逻辑完成前，不会有新的事件发生。

注意：在调用Signal，Broadcast之前，应确保目标进入Wait阻塞状态。

例子：

package main

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

func main() {
	wait := sync.WaitGroup{}
	locker := new(sync.Mutex)
	cond := sync.NewCond(locker)

	for i := 0; i < 3; i++ {
		go func(i int) {
			defer wait.Done()
			wait.Add(1)
			cond.L.Lock()
			fmt.Println("Waiting start...")
			cond.Wait()
			fmt.Println("Waiting end...")
			cond.L.Unlock()

			fmt.Println("Goroutine run. Number:", i)
		}(i)
	}

	time.Sleep(2e9)
	cond.L.Lock()
	cond.Signal()
	cond.L.Unlock()

	time.Sleep(2e9)
	cond.L.Lock()
	cond.Signal()
	cond.L.Unlock()

	time.Sleep(2e9)
	cond.L.Lock()
	cond.Signal()
	cond.L.Unlock()

	wait.Wait()
}

输出：

Waiting start...
Waiting start...
Waiting start...
Waiting end...
Goroutine run. Number: 0
Waiting end...
Goroutine run. Number: 1
Waiting end...
Goroutine run. Number: 2

可以看出来，每执行一次Signal就会执行一个goroutine。如果想让所有的goroutine执行，那么将所有的Signal换成一个Broadcast方法可以。

Mutex是一个互斥锁。可以作为struct的一部分，这样这个struct就会防止被多线程更改数据。

来个例子：

package main

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

type User struct {
	Name   string
	Locker *sync.Mutex
}

func (u *User) SetName(wati *sync.WaitGroup, name string) {
	defer func() {
		fmt.Println("Unlock set name:", name)
		u.Locker.Unlock()
		wati.Done()
	}()

	u.Locker.Lock()
	fmt.Println("Lock set name:", name)
	time.Sleep(1 * time.Second)
	u.Name = name
}

func (u *User) GetName(wati *sync.WaitGroup) {
	defer func() {
		fmt.Println("Unlock get name:", u.Name)
		u.Locker.Unlock()
		wati.Done()
	}()

	u.Locker.Lock()
	fmt.Println("Lock get name:", u.Name)
	time.Sleep(1 * time.Second)
}

func main() {
	user := User{}
	user.Locker = new(sync.Mutex)
	wait := &sync.WaitGroup{}
	names := []string{"a", "b", "c"}
	for _, name := range names {
		wait.Add(2)
		go user.SetName(wait, name)
		go user.GetName(wait)
	}

	wait.Wait()
}

输出结果：

Lock set name: a
Unlock set name: a
Lock get name: a
Unlock get name: a
Lock set name: b
Unlock set name: b
Lock get name: b
Unlock get name: b
Lock set name: c
Unlock set name: c
Lock get name: c
Unlock get name: c

程序很简单，就是防止在读取姓名的时候，被其它线程更改。这个程序还有些问题，不过总得来说，就是想演示一下Mutex的用途。可以让一个struct只被一个线程操作，而其它的线程就会阻塞。

先说说WaitGroup的用途：它能够一直等到所有的goroutine执行完成，并且阻塞主线程的执行，直到所有的goroutine执行完成。

WaitGroup总共有三个方法：Add(delta int),Done(),Wait()。简单的说一下这三个方法的作用。

Add:添加或者减少等待goroutine的数量

Done:相当于Add(-1)

Wait:执行阻塞，直到所有的WaitGroup数量变成0

例子：

package main

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

func main() {
	var wg sync.WaitGroup

	for i := 0; i < 5; i = i + 1 {
		wg.Add(1)
		go func(n int) {
			// defer wg.Done()
			defer wg.Add(-1)
			EchoNumber(n)
		}(i)
	}

	wg.Wait()
}

func EchoNumber(i int) {
	time.Sleep(3e9)
	fmt.Println(i)
}

输出结果：

0
1
2
3
4

程序很简单，只是将每次循环的数量过3秒钟输出。那么，这个程序如果不用WaitGroup，那么将看不见输出结果。因为goroutine还没执行完，主线程已经执行完毕。注释的defer wg.Done()和defer wg.Add(-1)作用一样。这个很好，原来执行脚本，都是使用time.Sleep，用一个估计的时间等到子线程执行完。WaitGroup很好。虽然chanel也能实现，但是觉得如果涉及不到子线程与主线程数据同步，这个感觉不错。

package main

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

var counter int = 0

func main() {
	var once sync.Once
	onceBody := func() {
		time.Sleep(3e9)
		fmt.Println("Only once")
	}
	done := make(chan bool)
	for i := 0; i < 10; i++ {
		j := i
		go func(int) {
			once.Do(onceBody)
			fmt.Println(j)
			done <- true
		}(j)
	}
	for i := 0; i < 10; i++ {
		<-done
	}
}

输出结果：

Only once
0
1
2
3
4
5
6
7
8
9

服务器是亚马逊，开发语言：golang，数据库：mongo，mysql。缓存：redis。

测试脚本：写了一个golang的并发请求脚本。大概同时请求100.ulimit限制到50.发现错误立刻呈现。发现在程序的进程下打开了大量的socket连接。所以当时就认为是mongo的连接错误。决定mongo的连接使用单例模式。不过后来发现，这些socket是会降下去的。也就是说，连接用完了，就关闭了。但是服务器的socket连接已经明显超过了ulimit的默认限制。项目也刚刚上线，也没有这么大的用户群。所以问题肯定不是处在了mongo的连接错误上。那是redis，mysql?后经过测试，也并不是这些连接的错误。

整的真是很晕啊。最后想起来了，可以看一下服务器的socket的连接是哪些请求。经过查看，发现是80端口。一个网站的。。搞了一天，方向错了。。。突然想起来了，最近添加的一个小功能，需要使用外网的api。在go打开连接后，好像没有关闭请求。加上关闭请求后，问题解决。socket上去，然后会自动下来。

总结：以后要及时关闭这些请求连接。go与php不一样。php在执行完成后，即使你不关闭请求，在解析完成后，所以变量，都会自动释放。go是编译行语言，所以连接打开后，如果不手动关闭，会一直占用。。