打算闲的时候写一个tcp_pool.刚开始做,就结束了.因为我走到了死胡同.

package gyc_server_deploy

import (
"errors"
"fmt"
"net"
"sync"
"time"
)

var GlobalLock *sync.RWMutex = new(sync.RWMutex)

type IPPool struct {
IP      []string
Maxconn int
TimeOut int64
}

type ConnectionPool struct {
IPPool
UseConnection map[string]int
Lock          *sync.RWMutex
Connection    map[string]chan net.Conn
}

var returnChan chan net.Conn = make(chan net.Conn, 1000)
var exitChan chan bool = make(chan bool, 1)

func (this *ConnectionPool) GetConnection(ip string) *NetConnection {
if list := this.Connection[ip]; len(list) > 0 {
con := NetConnection{new(sync.RWMutex), <-list, returnChan}
GlobalLock.Lock()
this.UseConnection[ip] = this.UseConnection[ip] + 1
GlobalLock.Unlock()
return &con
}
if this.UseConnection[ip] < this.Maxconn {
c, err := dial(ip, this.TimeOut)
if err != nil {
fmt.Println(err)
return nil
}
con := NetConnection{new(sync.RWMutex), c, returnChan}
GlobalLock.Lock()
this.UseConnection[ip] = this.UseConnection[ip] + 1
GlobalLock.Unlock()
return &con
}
con := NetConnection{new(sync.RWMutex), <-this.Connection[ip], returnChan}
GlobalLock.Lock()
this.UseConnection[ip] = this.UseConnection[ip] + 1
GlobalLock.Unlock()
return &con
}

func (this *ConnectionPool) New(ip string) error {
if this.Index(ip) {
if _, ok := this.Connection[ip]; !ok {
ConChan := make(chan net.Conn, this.Maxconn)
err := createConList(ip, ConChan, this.TimeOut)
if err != nil {
return err
}
this.Lock.Lock()
this.Connection[ip] = ConChan
this.Lock.Unlock()
}
return errors.New(fmt.Sprintf("%s: Already exists.", ip))
}
ConChan := make(chan net.Conn, this.Maxconn)
err := createConList(ip, ConChan, this.TimeOut)
if err != nil {
return err
}
if !this.Index(ip) {
this.Lock.Lock()
this.IP = append(this.IP, ip)
this.Connection[ip] = ConChan
this.Lock.Unlock()
return nil
}
return errors.New(fmt.Sprintf("%s: Already exists.", ip))
}

func (this *ConnectionPool) Index(ip string) bool {
this.Lock.RLock()
defer this.Lock.RUnlock()
for _, v := range this.IP {
if v == ip {
return true
}
}
return false
}

func (this *ConnectionPool) Close() {
exitChan <- true
}
func (this *IPPool) Init() *ConnectionPool {
M := ConnectionPool{Lock: new(sync.RWMutex),
Connection: make(map[string]chan net.Conn)}
for _, addr := range this.IP {
ConChan := make(chan net.Conn, this.Maxconn)
err := createConList(addr, ConChan, this.TimeOut)
if err != nil {
continue
}
M.Connection[addr] = ConChan
}
M.IP = this.IP
M.TimeOut = this.TimeOut
M.Maxconn = this.Maxconn
M.UseConnection = make(map[string]int)
go RecoveryAndExit(&M)
return &M
}

func createConList(ip string, ConChan chan net.Conn, t int64) error {
for i := 0; i < cap(ConChan); i++ {
con, err := dial(ip, t)
if err != nil {
fmt.Println(err)
continue
}
ConChan <- con
}
if len(ConChan) <= 0 {
return errors.New(fmt.Sprintf("%s: can't connection.", ip))
}
return nil
}

func dial(ip string, t int64) (net.Conn, error) {
if _, err := net.ResolveTCPAddr("tcp", ip); err != nil {
return nil, err
}
return net.DialTimeout("tcp", ip, time.Second*time.Duration(t))
}

func RecoveryAndExit(pool *ConnectionPool) {
for {
select {
case con := <-returnChan:
if con == nil {
GlobalLock.Lock()
pool.UseConnection[ip] = pool.UseConnection[ip] - 1
GlobalLock.Unlock()
continue
}
ip := con.RemoteAddr().String()
if list, ok := pool.Connection[ip]; ok {
GlobalLock.Lock()
pool.UseConnection[ip] = pool.UseConnection[ip] - 1
GlobalLock.Unlock()
list <- con
} else {
con.Close()
}
case exit := <-exitChan:
if exit {
pool.Lock.Lock()
defer pool.Lock.Unlock()
for k, v := range pool.Connection {
num := len(v)
for i := 0; i < num; i++ {
con := <-v
con.Close()
}
close(v)
delete(pool.Connection, k)
}
return
}
}
}
}

type NetConnection struct {
lock       *sync.RWMutex
con        net.Conn
returnChan chan net.Conn
}

func (this *NetConnection) Write(b []byte) (int, error) {
this.lock.RLock()
defer this.lock.RUnlock()
return this.con.Write(b)
}
func (this *NetConnection) Read(b []byte) (int, error) {
this.lock.RLock()
defer this.lock.RUnlock()
return this.con.Read(b)
}
func (this *NetConnection) LocalAddr() net.Addr {
this.lock.RLock()
defer this.lock.RUnlock()
return this.con.LocalAddr()
}
func (this *NetConnection) RemoteAddr() net.Addr {
this.lock.RLock()
defer this.lock.RUnlock()
return this.con.RemoteAddr()
}
func (this *NetConnection) Close() {
this.lock.Lock()
defer this.lock.Unlock()
this.con = nil
this.returnChan <- this.con
}