package main

import (

"container/list"

"fmt"

"net/http"

"os"

"runtime"

"strconv"

// "strings"

"io"

"log"

"sync"

"syscall"

"time"

)

var lockger sync.Mutex

var fansMap map[int]*list.List

func root(w http.ResponseWriter, r *http.Request) {

fmt.Fprintf(w, "<h1>Hello %s!</h1>", r.URL.Path[1:])

url := "get?key=123"

fmt.Fprintf(w, "<a href=%s>%s</a><br />", url, url)

url = "set?key=123&v=100"

fmt.Fprintf(w, url)

url = "stop"

fmt.Fprintf(w, url)

}

func setData(w http.ResponseWriter, "...")

runtime.GC()

}

func getData(w http.ResponseWriter, r *http.Request) {

key := r.FormValue("key")

i, _ := strconv.Atoi(key)

fmt.Fprintf(w, "val:%d", i)

lockger.Lock()

l, ok := fansMap[i]

lockger.Unlock()

if ok {

fmt.Fprintf(w, "mapok\n")

for e := l.Front(); e != nil; e = e.Next() {

// do something with l.Value

v := e.Value.(int)

fmt.Fprintf(w, "%d,", v)

}

}

//r.ParseForm()

//for k, v := range r.Form {

//    fmt.Fprintf(w, "key:%s", k)

//    fmt.Fprintf(w, "val:%d", v)

//    //i, _ := strconv.Atoi(v)

//}

}

// getEnv Request Handler

func getEnv(writer http.ResponseWriter, req *http.Request) {

env := os.Environ()

writer.Write([]byte("<h1>??????</h1><br>"))

for _, v := range env {

writer.Write([]byte(v + "<br>"))

}

writer.Write([]byte("<br>"))

}

func StopServer(w http.ResponseWriter, req *http.Request) {

responseString := "STOP"

w.Header().Set("Content-Type", "text/plain; charset=utf-8")

w.Header().Set("Content-Length", strconv.Itoa(len(responseString)))

io.WriteString(w, responseString)

f, canFlush := w.(http.Flusher)

if canFlush {

f.Flush()

}

conn, _, err := w.(http.Hijacker).Hijack()

if err != nil {

log.Fatalf("error while shutting down: %v", err)

}

conn.Close()

log.Println("Shutting down")

os.Exit(0)

}

func main() {

np := runtime.Numcpu()

runtime.GOMAXPROCS(np - 1)

println(np)

go ReportStatus()

fansMap = make(map[int]*list.List)

t := time.Now()

var i int

var fans *list.List

max := 1000000

for i = 0; i < max; i++ {

fans = list.New()

fansMap[i] = fans

for j := 1; j <= 200; j++ {

_ = fans.PushFront(j)

}

fans.PushFront(i)

if i%1000 == 0 {

fmt.Println("i=", i)

}

memstatus := MemStat()

if memstatus.Free < 512000000 {

fmt.Println("OUT OF MEMORY")

break

}

}

fmt.Println("list: " + time.Now().Sub(t).String())

http.HandleFunc("/", root)

http.HandleFunc("/get", getData)

http.HandleFunc("/set", setData)

http.HandleFunc("/stop", StopServer)

http.HandleFunc("/env", getEnv)

http.ListenAndServe(":8080", nil)

}

type MemStatus struct {

All  uint32 `json:"all"`

Used uint32 `json:"used"`

Free uint32 `json:"free"`

Self uint64 `json:"self"`

}

func MemStat() MemStatus {

//自身占用

memStat := new(runtime.MemStats)

runtime.ReadMemStats(memStat)

mem := MemStatus{}

mem.Self = memStat.Alloc

//系统占用,仅linux/mac下有效

//system memory usage

sysInfo := new(syscall.Sysinfo_t)

err := syscall.Sysinfo(sysInfo)

if err == nil {

mem.All = sysInfo.Totalram * uint32(syscall.Getpagesize())

mem.Free = sysInfo.Freeram * uint32(syscall.Getpagesize())

mem.Used = mem.All - mem.Free

}

return mem

}

func ReportStatus() {

memStats := &runtime.MemStats{}

runtime.ReadMemStats(memStats)

nsInMs := float64(time.Millisecond)

prefix := "MT"

for {

//now := time.Now()

fmt.Println("=========")

fmt.Println(fmt.Sprintf("%s.goroutines", prefix),

float64(runtime.NumGoroutine()))

fmt.Println(fmt.Sprintf("%s.memory.allocated",

float64(memStats.Alloc))

fmt.Println(fmt.Sprintf("%s.memory.mallocs",

float64(memStats.Mallocs))

fmt.Println(fmt.Sprintf("%s.memory.frees",

float64(memStats.Frees))

fmt.Println(fmt.Sprintf("%s.memory.gc.total_pause",

float64(memStats.PauseTotalNs)/nsInMs)

fmt.Println(fmt.Sprintf("%s.memory.heap",

float64(memStats.HeapAlloc))

fmt.Println(fmt.Sprintf("%s.memory.stack",

float64(memStats.StackInuse))

time.Sleep(10e8)

}

}

//func   reportRuntimeStats(prefix, context string,

//  dimensions Dimensions, sleep time.Duration) {

//  memStats := &runtime.MemStats{}

//  lastSampleTime := time.Now()

//  var lastPauseNs uint64 = 0

//  var lastNumGc uint32 = 0

//  nsInMs := float64(time.Millisecond)

//  for self.runtimeStatsRunning {

//    runtime.ReadMemStats(memStats)

//    now := time.Now()

//    Println(fmt.Sprintf("%s.goroutines", prefix),

//      float64(runtime.NumGoroutine()), now, context, dimensions)

//    Println(fmt.Sprintf("%s.memory.allocated",

//      float64(memStats.Alloc), dimensions)

//    Println(fmt.Sprintf("%s.memory.mallocs",

//      float64(memStats.Mallocs), dimensions)

//    Println(fmt.Sprintf("%s.memory.frees",

//      float64(memStats.Frees), dimensions)

//    Println(fmt.Sprintf("%s.memory.gc.total_pause",

//      float64(memStats.PauseTotalNs)/nsInMs, dimensions)

//    Println(fmt.Sprintf("%s.memory.heap",

//      float64(memStats.HeapAlloc), dimensions)

//    Println(fmt.Sprintf("%s.memory.stack",

//      float64(memStats.StackInuse), dimensions)

//    if lastPauseNs > 0 {

//      pauseSinceLastSample := memStats.PauseTotalNs - lastPauseNs

//      Println(fmt.Sprintf("%s.memory.gc.pause_per_second",

//        float64(pauseSinceLastSample)/nsInMs/sleep.Seconds(), dimensions)

//    }

//    lastPauseNs = memStats.PauseTotalNs

//    countGc := int(memStats.NumGC - lastNumGc)

//    if lastNumGc > 0 {

//      diff := float64(countGc)

//      diffTime := now.Sub(lastSampleTime).Seconds()

//      Println(fmt.Sprintf("%s.memory.gc.gc_per_second",

//        diff/diffTime, dimensions)

//    }

//    // get the individual pause times

//    if countGc > 0 {

//      if countGc > 256 {

//        fmt.Fprintf(os.Stderr, "We're missing some gc pause times")

//        countGc = 256

//      }

//      for i := 0; i < countGc; i++ {

//        idx := int((memStats.NumGC-uint32(i))+255) % 256

//        pause := float64(memStats.PauseNs[idx])

//        self.Aggregate(fmt.Sprintf("%s.memory.gc.pause",

//          pause/nsInMs, dimensions)

//      }

//    }

//    // keep track of the prevIoUs state

//    lastNumGc = memStats.NumGC

//    lastSampleTime = now

//    time.Sleep(sleep)

//  }

//}