golang版的高效日志组件

package log

import (

"sync"

"time"

"os"

"fmt"

"strconv"

)

type Tlog struct{

Qidx int

Q1 []string

Q2 []string

Qlen int

Q1len int

Q2len int

Locker sync.Mutex

SavePath string

FilePrefix string

WriteFileInterval time.Duration

StopMark chan int

TimeoutChan chan int

}

func NewTlog(queue_len int,write_file_interval time.Duration,save_path,file_prefix string) *Tlog{

ret := new(Tlog)

ret.Q1 = make([]string,queue_len,queue_len)

ret.Q2 = make([]string,queue_len,queue_len)

ret.Qidx = 1

ret.Qlen = queue_len

ret.Q1len = 0

ret.Q2len = 0

ret.SavePath = IncludeTrailingPathDelimiter(save_path)

ret.FilePrefix = file_prefix

ret.WriteFileInterval = write_file_interval

ret.StopMark = make(chan int,1)

ret.TimeoutChan = make(chan int,1)

return ret

}

func (log *Tlog) Stop(){

log.StopMark <- 1

}

func (log *Tlog) start_timer(){

for{

time.Sleep(log.WriteFileInterval * time.Millisecond)

log.TimeoutChan <- 1

//fmt.Println("log timer passed")

}

}

func(log *Tlog) internal_run(){

go log.start_timer()

for{

select{

case <- log.StopMark:

goto end

case <- log.TimeoutChan:{

log.writefile(true)

}

}

}

end:

log.writefile(true)

}

func (log *Tlog) Run(){

go log.internal_run()

}

func (log *Tlog)swap(){

log.writefile(false)

if log.Qidx == 1{

log.Qidx = 2

}else{

log.Qidx = 1

}

}

func (log *Tlog)writefile(with_lock bool){

if with_lock{

log.Locker.Lock()

defer log.Locker.Unlock()

}

if log.Qidx == 1 && log.Q1len == 0{

return

}

if log.Qidx == 2 && log.Q2len == 0{

return

}

file := log.SavePath + log.FilePrefix + time.Now().String()[:10]

var f *os.File

var e error

if FileExists(file){

f,e = os.OpenFile(file,os.O_APPEND | os.O_RDWR ,0666)

}else{

f,e = os.OpenFile(file,os.O_CREATE | os.O_RDWR ,0666)

}

if e!=nil{

fmt.Println("open/create log file error:"+file+","+e.Error())

return

}

defer f.Close()

var buf string

if log.Qidx == 1{

for i:=0;i<log.Q1len;i++{

buf = buf + "\r\n" + log.Q1[i]

}

}else{

for i:=0;i<log.Q2len;i++{

buf = buf + "\r\n" + log.Q2[i]

}

}

_,err := f.Write([]byte(buf))

if err!=nil{

fmt.Println("write log file error:"+file+","+e.Error())

return

}

if log.Qidx == 1{

log.Q1len = 0

}else{

log.Q2len = 0

}

}

func (log *Tlog)Log(s string){

if s[:4] == "err:"{

fmt.Println(s)

}

log.Locker.Lock()

defer log.Locker.Unlock()

if log.Qidx==1{

if log.Q1len >= log.Qlen{

log.swap()

}

}else{

if log.Q2len >= log.Qlen{

log.swap()

}

}

//s1 := time.Now().String()

slog :=time.Now().String() + " " + s

if log.Qidx==1{

log.Q1len++

log.Q1[log.Q1len - 1] = slog

}else{

log.Q2len++

log.Q2[log.Q2len - 1] = slog

}

}

func testlog(log *Tlog){

for i:=0;i<10000;i++{

log.Log(strconv.Itoa(i))

if i % 1000 ==0{

time.Sleep(1000 * time.Millisecond)

}

}

}

func TestLog(){

log := NewTlog(100,1000,"/usr/fys/","log")

log.Run()

go testlog(log)

go testlog(log)

time.Sleep(5000 * time.Millisecond)

log.Stop()

}