悟云

type Time struct {
	// sec gives the number of seconds elapsed since
	// January 1, year 1 00:00:00 UTC.
	sec int64
	// nsec specifies a non-negative nanosecond
	// offset within the second named by Seconds.
	// It must be in the range [0, 999999999].
	nsec int32
	// loc specifies the Location that should be used to
	// determine the minute, hour, month, day, and year
	// that correspond to this Time.
	// The nil location means UTC.
	// All UTC times are represented with loc==nil, never loc==&utcLoc.
	loc *Location
}

// After reports whether the time instant t is after u.
func (t Time) After(u Time) bool {
	return t.sec > u.sec || t.sec == u.sec && t.nsec > u.nsec
}

// Before reports whether the time instant t is before u.
func (t Time) Before(u Time) bool {
	return t.sec < u.sec || t.sec == u.sec && t.nsec < u.nsec
}

// Equal reports whether t and u represent the same time instant.
// Two times can be equal even if they are in different locations.
// For example, 6:00 +0200 CEST and 4:00 UTC are Equal.
// Do not use == with Time values.
func (t Time) Equal(u Time) bool {
	return t.sec == u.sec && t.nsec == u.nsec
}

func (t Time) Add(d Duration) Time {
	t.sec += int64(d / 1e9)
	nsec := t.nsec + int32(d%1e9)
	if nsec >= 1e9 {
		t.sec++
		nsec -= 1e9
	} else if nsec < 0 {
		t.sec--
		nsec += 1e9
	}
	t.nsec = nsec
	return t
}

func (t Time) Sub(u Time) Duration {
	d := Duration(t.sec-u.sec)*Second + Duration(t.nsec-u.nsec)
	// Check for overflow or underflow.
	switch {
	case u.Add(d).Equal(t):
		return d // d is correct
	case t.Before(u):
		return minDuration // t - u is negative out of range
	default:
		return maxDuration // t - u is positive out of range
}

func (t Time) AddDate(years int, months int, days int) Time {
	year, month, day := t.Date()
	hour, min, sec := t.Clock()
	return Date(year+years, month+Month(months), day+days, hour, min, sec, int(t.nsec), t.Location())
}

// The Timer type represents a single event.
// When the Timer expires, the current time will be sent on C,
// unless the Timer was created by AfterFunc.
// A Timer must be created with NewTimer or AfterFunc.
type Timer struct {
	C <-chan Time
	r runtimeTimer
}

func startTimer( * runtimeTimer)
func stopTimer( * runtimeTimer) bool

// NewTimer creates a new Timer that will send
// the current time on its channel after at least duration d.
func NewTimer(d Duration) * Timer {
	c := make(chan Time, 1)
	t := &Timer{
		C: c,
		r: runtimeTimer{
			when: when(d),
			f:  sendTime,
			arg:  c,
		},
	}
	startTimer(&t.r)
	return t
}

func AfterFunc(d Duration, f func()) * Timer {
	t := &Timer{
		r: runtimeTimer{
			when: when(d),
			f:    goFunc,
			arg:  f,
		},
	}
	startTimer(&t.r)
	return t
}

func (t * Timer) Reset(d Duration) bool {
	if t.r.f == nil {
		panic("time: Reset called on uninitialized Timer")
	}
	w := when(d)
	active := stopTimer(&t.r)
	t.r.when = w
	startTimer(&t.r)
	return active
}

// After waits for the duration to elapse and then sends the current time
// on the returned channel.
// It is equivalent to NewTimer(d).C.
// The underlying Timer is not recovered by the garbage collector
// until the timer fires. If efficiency is a concern, use NewTimer
// instead and call Timer.Stop if the timer is no longer needed.
func After(d Duration) <-chan Time {
	return NewTimer(d).C
}

// Stop prevents the Timer from firing.
// It returns true if the call stops the timer, false if the timer has already
// expired or been stopped.
// Stop does not close the channel, to prevent a read from the channel succeeding
// incorrectly.
//
// To prevent a timer created with NewTimer from firing after a call to Stop,
// check the return value and drain the channel.
// For example, assuming the program has not received from t.C already:
//	if !t.Stop() {
//		<-t.C
//	}
// This cannot be done concurrent to other receives from the Timer's
// channel.
//
// For a timer created with AfterFunc(d, f), if t.Stop returns false, then the timer
// has already expired and the function f has been started in its own goroutine;
// Stop does not wait for f to complete before returning.
// If the caller needs to know whether f is completed, it must coordinate
// with f explicitly.
func (t * Timer) Stop() bool {
	if t.r.f == nil {
		panic("time: Stop called on uninitialized Timer")
	}
	return stopTimer(&t.r)
}

var inputTradeno = make(chan string)
var outputStatus = make(chan bool)

func chanLoop(){
	 hashmap := make(map[string]interface{}, 10000)
	 var queue common.StringFIFO
	 queue.Init(10000)
	 for {
		tradeno := <- inputTradeno
		if _, ok := hashmap[tradeno]; ok{
			outputStatus <- true
		}else {
			if queue.Full(){
				oldestTradeno, _ := queue.Pop()
				delete(hashmap, oldestTradeno)
			}
			queue.Push(tradeno)
			hashmap[tradeno] = struct {}{}
			outputStatus <- false
		}
	}
}

func look(tradeno string) bool{
	inputTradeno <- tradeno
	ret := <- outputStatus
	return ret
}

func main() {
	go chanLoop()
}

func wftNotify(c * gin.Context){
	//检验威富通是否重复通知
	if look(notifyReq.Out_trade_no){
	//已经缓存当前订单，说明威富通重复通知
		common.LogError("该订单已经处理")
		c.Writer.WriteString(wxpay.WFT_RETURN_MSG_SUCCESS)
		return
	}
}

interface{}	

var r io.Reader
tyy, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
if err != nil {
	return nil, err
}
r = tty

var w io.Writer
w = r.(io.Writer)

var empty interface{}
empty = w

package main
import (
	"fmt"
	"reflect"
)
func main() {
	var x float64 = 3.4
	fmt.Println("type:", reflect.TypeOf(x))
}

type: float64

func TypeOf(i interface{}) Type

var x float64 = 3.4
fmt.Println("value:", reflect.ValueOf(x))

value: <float64 Value>

var x float64 = 3.4
v := reflect.ValueOf(x)
fmt.Println("type:", v.Type())
fmt.Println("kind is float64:", v.Kind() == reflect.Float64)
fmt.Println("value:", v.Float())

type: float64
kind is float64: true
value: 3.4

type MyInt int
var x MyInt = 7
v := relect.ValueOf(x)

// Interface returns v's value as an interface{}.
func (v Value) Interface() interface{}

y := v.Interface().(float64)
fmt.Println(y)

fmt.Println(v.Interface())

var x float64 = 3.4
v := reflect.ValueOf(x)
v.SetFLoat(7.1)

f(&x)

var x float64 = 3.4
p := reflect.ValueOf(&x)
fmt.Println("type of p:", p.Type())
fmt.Println("settability of p:", p.CanSet())

type of p: * float64
settability of p: false

v := p.Elem()
fmt.Printlen("settability of v:", v.CanSet())

settability of v: true

v.SetFloat(7.1)
fmt.Println(v.Interface())
fmt.Println(x)

7.1
7.1

type T struct {
	A int
	B string
}
t := T{23, "skidoo"}
s := reflect.ValueOf(&t).Elem()
	typeOfT := s.Type()
	for i := 0; i < s.NumField(); i++ {
		f := s.Field(i)
		fmt.Printf("%d: %s %s = %v\n", i,
			typeOfT.Field(i).Name, f.Type(), f.Interface())
	}

0: A int = 23
1: B string = skidoo

s.Field(0).SetInt(77)
s.Field(1).SetString("Sunset Strip")
fmt.Println("t is now", t)

t is now {77 Sunset Strip}

tag := s.Field(0).Tag.Get("testtag")