golang

今天在这里写一些Golang怎么连接ldap golang的ldap包有一些，我使用的是 go get -u "gopkg.in/ldap.v2" 我的ldap环境: rootdn: uid=admin,dc=wjq,dc=com password: openldap dn: dc=wjq,dc=com dc: wjq objectClass: top objectClass: domain dn: ou=Group,dc=wjq,dc=com ou: Group objectClass: top objectClass: organizationalUnit dn: ou=People,dc=wjq,dc=com ou: People objectClass: top objectClass: organizationalUnit dn: uid=admin,dc=wjq,dc=com uid: admin objectClass: top objectClass: account 一个组和一个用户: #组信息 dn: cn=test,ou=Group,dc=wjq,dc=com gidNumber: 1003 cn: test objectClass: posixGroup #用户信息 dn: uid=test,ou=People,dc=wjq,dc=com uidNumber

golang的协程使用非常方便，但为了确保协程能够在主程序退出之前确保执行，会采用各种手段。 笨点的time大法： func foo(){ //do something } func main(){ go foo() //do anotherthing time.Sleep(time.Second) //还真不知道foo运行多久，只能靠猜 } 稍微好点的通道阻塞： var signalchan= make ( chan int ,0 ) //阻塞通道 func foo(){ //do something signalchan <-1 //传递一个完成信号 } func main(){ go foo() //do anotherthing <-signalchan } 再聪明点的，使用sync.WaitGroup 代码可以这样写: func foo(){ //do something } func main(){ var w sync.WaitGroup w.Add (1 ) go func (){ foo() w.Done() } //do anotherthing w.Wait() 虽然没有了全局变量，但感觉代码多了，感觉不清爽，能够优化呢。 WaitGroup Wrapper封装 代码参考如下： package waitgroup import ( "sync" ) type

锁 golang中sync包实现了两种功能的锁Mutex（互斥锁）和RWMutex(读写锁） type Mutex func (m *Mutex) Lock() func (m *Mutex) Unlock() type RWMutex func (rw *RWMutex) Lock() func (rw *RWMutex) RLock() func (rw *RWMutex) RLocker() Locker func (rw *RWMutex) RUnlock() func (rw *RWMutex) Unlock() Mutex 重复Lock()，会引起死锁。 fatal error: all goroutines are asleep - deadlock! Unlock()之前，并未Lock()，会引起一个运行时的错误。 panic: sync: unlock of unlocked mutex 适用场景：读写次数不确定，并且只允许一个读或写的场景，又称为全局锁 RWMutex 写锁加锁：如果在添加写锁之前，已有写锁或者读锁，则Lock()会阻塞直至之前持有的锁被释放，写锁权限高于读锁，有写锁时优先进行写锁定。 func (rw *RWMutex) Lock() 写锁解锁：如果解锁之前未加锁，会引起一个运行时的错误。 func (rw *RWMutex) Lock()

golang sync WaitGroup 刚才看golang的sync的包，看见一个很有用的功能。就是WaitGroup。 先说说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

sync 主要用于 golang 中的同步控制。虽然 golang 更推荐 chan 这种通过通信来共享资源的方式，但有时候直接使用 sync 的效果更好，它是 chan 方式很好的补充。本文简单介绍一下 sync 的使用方式。 ##互斥锁 func TestMutex ( ) { var mutex sync . Mutex sum := 0 for i := 0 ; i < 10 ; i ++ { go func ( t int ) { mutex . Lock ( ) defer mutex . Unlock ( ) sum += t fmt . Println ( t ) } ( i ) } time . Sleep ( time . Second ) fmt . Printf ( "Sum: %v\n" , sum ) } ##条件变量 func TestCond ( ) { cond := sync . NewCond ( & sync . Mutex { } ) for i := 0 ; i < 10 ; i ++ { go func ( t int ) { time . Sleep ( time . Second ) cond . L . Lock ( ) defer cond . L . Unlock ( ) cond . Wait ( ) fmt .

介绍 经常会看到以下了代码： package main import ( "fmt" "time" ) func main(){ for i := 0; i < 100 ; i++{ go fmt.Println(i) } time.Sleep(time.Second) } 主线程为了等待goroutine都运行完毕，不得不在程序的末尾使用 time.Sleep() 来睡眠一段时间，等待其他线程充分运行。对于简单的代码，100个for循环可以在1秒之内运行完毕， time.Sleep() 也可以达到想要的效果。 但是对于实际生活的大多数场景来说，1秒是不够的，并且大部分时候我们都无法预知for循环内代码运行时间的长短。这时候就不能使用 time.Sleep() 来完成等待操作了。 可以考虑使用管道来完成上述操作： func main() { c := make(chan bool, 100) for i := 0; i < 100; i++ { go func(i int) { fmt.Println(i) c <- true }(i) } for i := 0; i < 100; i++ { <-c } } 首先可以肯定的是使用管道是能达到我们的目的的，而且不但能达到目的，还能十分完美的达到目的。 但是管道在这里显得有些大材小用，因为它被设计出来不仅仅只是在这里用作简单的同步处理

groupcache 简介 在软件系统中使用缓存,可以降低系统响应时间,提高用户体验,降低某些系统模块的压力. groupcache是一款开源的缓存组件.与memcache与redis不同的时,groupcache不需要单独的部署,可以作为你程序的一个库来使用. 这样方便我们开发的程序部署. groupcache使用流程介绍 NewGroup创建一个group实例, // 创建一个Group实例, // 第一个参数是group名字. // 第二个参数是缓冲区大小. // 第三个参数是回调函数. func NewGroup ( name string , cacheBytes int64 , getter Getter ) * Group { return newGroup ( name , cacheBytes , getter , nil ) } // If peers is nil, the peerPicker is called via a sync.Once to initialize it. func newGroup ( name string , cacheBytes int64 , getter Getter , peers PeerPicker ) * Group { if getter == nil { panic ( "nil Getter" ) } mu

WaitGroup kafka消费者 WaitGroup WaitGroup在go语言中，用于线程同步，单从字面意思理解，wait等待的意思，group组、团队的意思，WaitGroup就是指等待一组，等待一个系列执行完成后才会继续向下执行。 package main import ( "fmt" "sync" "time" ) func main() { wg := sync .WaitGroup {} for i := 0 ; i < 10; i++ { wg .Add ( 1 ) go calc(&wg, i) } wg .Wait () fmt .Println ( "all goroutine finish" ) } func calc(w *sync .WaitGroup , i int) { fmt .Println ( "calc:" , i) time .Sleep (time .Second ) w .Done () } 输出如下： PS E:\golang\go_pro\src\safly> go run waitGroup .go calc: 0 calc: 1 calc: 4 calc: 2 calc: 3 calc: 9 calc: 6 calc: 7 calc: 5 calc: 8 all goroutine finish PS E:\golang

面对goroutine我们都需要等待它完成交给它的事情，等待它计算完成或是执行完毕，所以不得不在程序需要等待的地方使用time.Sleep()来睡眠一段时间，等待其他goroytine执行完毕，下面的代码打印1到100的for循环可以在很快的时间内运行完毕，但是我们必须添加time.Sleep()来等待其打印完毕,如果我们不等待仿佛什么也没有发生一样。。。。。这肯定不是我们想要的！ func main(){ for i := 0; i < 100 ; i++{ go fmt.Println(i) } time.Sleep(time.Second) } 这就是我最开始学习goroutine想到的笨方法。。。。死等！ 等不到 time.Second*2 在等不到*3 但是对于我们实际的使用场景来说，1秒也许等待的时间有点长，而有时候是远远不够的，最主要的我们无法预知gorotine的运行时间长短，所以也无法指定Sleep睡眠的时间。 正好前几天学习了channel，那么现在我们就可以使用channel来达到我们的目的了： func main() { c := make(chan bool, 100) for i := 0; i < 100; i++ { go func(i int) { fmt.Println(i) c <- true }(i) } for i := 0; i <

题目原地址 package main import ( "fmt" "sync" "time" "sync/atomic" ) const THREE_MINUTES = 3 * 60 * 1 type BanTable struct { VisTable map [ string ] int64 Lock *sync.Mutex } func NewBanTable() *BanTable { return &BanTable{ VisTable: make ( map [ string ] int64 , 0 ), Lock: new (sync.Mutex), } } func (self *BanTable) IsVisited(ip string ) bool { self.Lock.Lock() defer self.Lock.Unlock() ts, ok := self.VisTable[ip] ret := false if ok && ts > 0 && time.Now().Unix()-ts < THREE_MINUTES { ret = true } if !ret { self.VisTable[ip] = time.Now().Unix() } return ret } func main() { var succ int64 = 0 ban :=