go语言练习

// main
package main

import (
    "fmt"
    "runtime"
    "sync"
)

func main() {
    fmt.Println("Hello World!")
    runtime.GOMAXPROCS(1)
    var wg sync.WaitGroup
    wg.Add(2)
    i := 999
    fmt.Println("Start Goroutines")

    go func() {
        defer wg.Done()
        //共享变量 i wg
        fmt.Println(i)
        for count := 0; count < 3; count++ {
            for char := 'a'; char < 'a'+26; char++ {
                fmt.Printf("%c ", char)
            }
        }
    }()

    go func() {
        defer wg.Done()
        fmt.Println(i)
        for count := 0; count < 3; count++ {
            for char := 'A'; char < 'A'+26; char++ {
                fmt.Printf("%c ", char)
            }
        }
    }()

    fmt.Println("Waiting to Finish")
    wg.Wait()

    fmt.Println("\nTerminating Program")
}

go 协程练习

 

 

接口练习

// Sample program to show what happens when the outer and inner
// type implement the same interface.
package main

import (
    "fmt"
)

// notifier is an interface that defined notification
// type behavior.
type notifier interface {
    notify()
}

// user defines a user in the program.
type user struct {
    name  string
    email string
}

// notify implements a method that can be called via
// a value of type user.
func (u *user) notify() {
    fmt.Printf("Sending user email to %s<%s>\n",
        u.name,
        u.email)
}

// admin represents an admin user with privileges.
type admin struct {
    user
    level string
}

// notify implements a method that can be called via
// a value of type Admin.
func (a *admin) notify() {
    fmt.Printf("Sending admin email to %s<%s>\n",
        a.name,
        a.email)
}

// main is the entry point for the application.
func main() {
    // Create an admin user.
    ad := admin{
        user: user{
            name:  "john smith",
            email: "john@yahoo.com",
        },
        level: "super",
    }

    // Send the admin user a notification.
    // The embedded inner type's implementation of the
    // interface is NOT "promoted" to the outer type.
    sendNotification(&ad)

    // We can access the inner type's method directly.
    ad.user.notify()

    // The inner type's method is NOT promoted.
    ad.notify()
}

// sendNotification accepts values that implement the notifier
// interface and sends notifications.
func sendNotification(n notifier) {
    n.notify()
}

 

work代码注释 《go语言编程实战》

package work

import "sync"

//接口
type Worker interface {
    Task()
}

//pool结构体
type Pool struct {
    work chan Worker
    wg   sync.WaitGroup
}

//new函数  返回 pool指针
func New(maxGorountines int) *Pool {
    p := Pool{
        work: make(chan Worker),
    }
    //wg添加wait数量
    p.wg.Add(maxGorountines)
    for i := 0; i < maxGorountines; i++ {
        go func() {
            //执行POOL内的任务 完成后wg执行done
            for w := range p.work {
                w.Task()
            }
            p.wg.Done()
        }()
    }

    return &p
}

//将任务放入POOL
func (p *Pool) Run(w Worker) {
    p.work <- w
}

//关闭POOL
func (p *Pool) Shutdown() {
    close(p.work)
    p.wg.Wait()
}

// main
package main

import (
    "fmt"
    "log"
    "sync"
    "time"
    "work"
)

var names = []string{
    "steve",
    "bob",
    "mary",
    "therese",
    "jason",
}

type namePrinter struct {
    name string
}

func (m *namePrinter) Task() {
    log.Println(m.name)
    time.Sleep(time.Second)
}

func main() {
    fmt.Println("Hello World!")
    p := work.New(2)

    var wg sync.WaitGroup
    wg.Add(100 * len(names))

    for i := 0; i < 100; i++ {
        for _, name := range names {
            np := namePrinter{
                name: name,
            }
            go func() {
                p.Run(&np)
                wg.Done()
            }()
        }
    }
    wg.Wait()
    p.Shutdown()
}

 

runner代码注释 《go语言编程实战》

// runner
package runner

import (
    "errors"
    "fmt"
    "os"
    "os/signal"
    "time"
)

//runner结构体
type Runner struct {
    interrupt chan os.Signal
    complete  chan error
    timeout   <-chan time.Time
    tasks     []func(int)
}

//错误变量1
var Errtimeout = errors.New("received timeout")
//错误变量2
var ErrInterrupt = errors.New("received interrupt")

//runner的new函数
func New(d time.Duration) *Runner {
    return &Runner{
        interrupt: make(chan os.Signal, 1),
        complete:  make(chan error),
        timeout:   time.After(d),
    }
}

//func(int)加入 runner
func (r *Runner) Add(tasks ...func(int)) {
    r.tasks = append(r.tasks, tasks...)
}


//goroutine执行 结果超时或者错误 成功
func (r *Runner) Start() error {
    signal.Notify(r.interrupt, os.Interrupt)

    go func() {
        r.complete <- r.run()
    }()

    select {
    case err := <-r.complete:
        return err
    case <-r.timeout:
        return Errtimeout
    }
}

//run函数 遍历函数数组
//若发生错误中断则返回 中断错误
func (r *Runner) run() error {
    for id, task := range r.tasks {
        if r.gotInterrupt() {
            return ErrInterrupt
        }
        task(id)
    }
    return nil
}

//通过interrupt接受中断
func (r *Runner) gotInterrupt() bool {
    select {
    case <-r.interrupt:
        signal.Stop(r.interrupt)
        return true
    default:
        return false
    }
}


//无用main函数
func main() {
    fmt.Println("Hello World!")

}

// main
package main

import (
    "fmt"
    "log"
    "os"
    "runner"
    "time"
)

const timeout = 3 * time.Second

func main() {
    fmt.Println("Hello World!")
    log.Println("Starting work.")

    r := runner.New(timeout)

    r.Add(createTask(), createTask(), createTask())

    if err := r.Start(); err != nil {
        switch err {
        case runner.Errtimeout:
            log.Println("Terminating due to timeout")
            os.Exit(1)
        case runner.ErrInterrupt:
            log.Println("Terminating due to interrupt")
            os.Exit(2)
        }
    }
    log.Println("Process ended")
}

func createTask() func(int) {
    return func(id int) {
        log.Printf("processor - Task #%d", id)
        time.Sleep(time.Duration(id) * time.Second)
    }
}

 

go语言编程 代码修改

package library

//music 记录
type MusicEntry struct {
    Id string
    Name string
    Artist string
    Source string
    Type string
}

package library

import "errors"

//音乐管理器  音乐记录数组
type MusicManager struct {
    musics []MusicEntry
}

//返回音乐管理器指针
func NewMusicManager() *MusicManager {
    return &MusicManager{make([]MusicEntry, 0)}
}

//返回音乐管理器 音乐数组的元素数
func (m *MusicManager) Len() int {
    return len(m.musics)
}

//输入索引 获取音乐记录指针
func (m *MusicManager) Get(index int) (music *MusicEntry, err error) {
    if index < 0 || index >= len(m.musics) {
        return nil, errors.New("Index out of range.")
    }
    return &m.musics[index], nil
}


//根据名字字符串 查找音乐记录的指针
func (m *MusicManager) Find(name string) *MusicEntry {
    if len(m.musics) == 0 {
        return nil
    }

    for _, m := range m.musics {
        if m.Name == name {
            return &m
        }
    }
    return nil
}

//添加音乐记录  输入音乐记录指针
func (m *MusicManager) Add(music *MusicEntry) {

    m.musics = append(m.musics, *music)
}


//输入索引 移除指定索引 返回音乐记录指针
func (m *MusicManager) Remove(index int) *MusicEntry {
    if index < 0 || index >= len(m.musics) {
        return nil
    }

    removedMusic := &m.musics[index]

    // Remove the found item from the slice.
    if index < len(m.musics)-1 { // Element between first and last
        m.musics = append(m.musics[:index-1], m.musics[index+1:]...)
    } else if index == 0 { // empty it.
        m.musics = make([]MusicEntry, 0)
    } else { // The last element
        m.musics = m.musics[:index-1]
    }

    return removedMusic
}



//输入名字字符串 移除符合的音乐记录  返回音乐记录指针
func (m *MusicManager) RemoveByName(name string) *MusicEntry {
    if len(m.musics) == 0 {
        return nil
    }

    for i, v := range m.musics {
        if v.Name == name {
            return m.Remove(i)
        }
    }
    return nil
}

package library

import "testing"

func TestOps(t *testing.T) {
    mm := NewMusicManager()
    if mm == nil {
        t.Error("NewMusicManager failed")
    }

    if mm.Len() != 0 {
        t.Error("NewMusicManager failed,not empty")
    }

    m0 := &MusicEntry{"1", "MyHeart", "Celion", "http://wwww", "pop"}
    mm.Add(m0)

    if mm.Len() != 1 {
        t.Error("MusicManager Add() failed")
    }

    m := mm.Find(m0.Name)
    if m == nil {
        t.Error("MusicManager Find() failed")
    }

    if m.Id != m0.Id || m.Name != m0.Name ||
        m.Artist != m0.Artist || m.Source != m0.Source ||
        m.Type != m0.Type {
        t.Error("MusicManager Find() failed.Found item mismatch")
    }

    m, err := mm.Get(0)
    if m == nil || err != nil {
        t.Error("MusicManager Get() failed")
    }

    m = mm.Remove(0)
    if m == nil || mm.Len() != 0 {
        t.Error("MusicManager Remove() failed")
    }

}

 

服务器 代码备份

// main
package main

import (
    //"crypto/cipher"
    //"bufio"
    "bytes"
    "crypto/aes"
    "encoding/binary"
    "errors"
    "fmt"
    "log"
    "net"
)

var g_string string

type Header struct {
    flag       byte
    packageLen int32
}

//字节转换成整形
func BytesToInt(b []byte) int {
    bytesBuffer := bytes.NewBuffer(b)

    var x int32
    binary.Read(bytesBuffer, binary.LittleEndian, &x)

    return int(x)
}

func recvBuf(conn net.Conn, buf []byte) (int, error) {
    n, err := conn.Read(buf)
    return n, err
}

func recvHeader(conn net.Conn) (int, error) {
    headerbuf := make([]byte, 5)
    //fmt.Println("before buf:", headerbuf)

    n, err := recvBuf(conn, headerbuf)
    if err != nil || n != 5 {
        fmt.Println("err:", err)
        return -1, err
    }
    //fmt.Println("after buf:", headerbuf, "  n:", n)
    if headerbuf[0] != '|' {
        fmt.Println("err:flag error,exit!")
        return -2, err
    }
    n = BytesToInt(headerbuf[1:])
    return n, err
}

func recvBody(conn net.Conn, n int) (int, error) {
    var err = errors.New(" closed")
    buf := make([]byte, n)

    n, err = recvBuf(conn, buf)
    if err != nil || n <= 0 {
        fmt.Println("err:", err)
        return -1, err
    }
    //buf 解密
    mainecb(buf)

    return n, err
}

func handleConn(conn net.Conn) {
    fmt.Println("Enter func handleConn")
    defer conn.Close()
    who := conn.RemoteAddr().String()
    fmt.Println(who)
    for {
        n, err := recvHeader(conn)
        //fmt.Println("recvHeader n = ", n, "  ", err)
        if n <= 0 || err != nil {
            var ErrEOF = errors.New("EOF")
            if err == ErrEOF {
                fmt.Println("err eauql")
            }
            fmt.Println("err:recvHeader error,exit!  ,err:", err)
            break
        }
        _, err = recvBody(conn, n)
    }

}

//===============================================
//ecb
//===============================================
//AES ECB模式的加密解密
type AesTool struct {
    //128 192  256位的其中一个 长度 对应分别是 16 24  32字节长度
    Key       []byte
    BlockSize int
}

func (this *AesTool) Decrypt(src []byte) ([]byte, error) {
    //key只能是 16 24 32长度
    block, err := aes.NewCipher([]byte(this.Key))
    if err != nil {
        return nil, err
    }
    //返回加密结果
    decryptData := make([]byte, len(src))
    //存储每次加密的数据
    tmpData := make([]byte, this.BlockSize)

    //分组分块加密
    for index := 0; index < len(src); index += this.BlockSize {
        block.Decrypt(tmpData, src[index:index+this.BlockSize])
        //copy(decryptData, tmpData)
        decryptData = mergeByteArray(decryptData, tmpData)
    }
    return this.PKCS5UnPadding(decryptData), nil
}

func mergeByteArray(a []byte, b []byte) []byte {
    alen := len(a)
    blen := len(b)

    z := make([]byte, alen+blen)

    for i := 0; i < alen; i++ {
        z[i] = a[i]
    }
    for i := 0; i < blen; i++ {
        z[alen+i] = b[i]
    }
    return z
}

//unpadding
func (this *AesTool) unPadding(src []byte) []byte {
    for i := len(src) - 1; ; i-- {
        if src[i] != 0 {
            return src[:i+1]
        }
    }
    return nil
}

func (this *AesTool) PKCS5Padding(ciphertext []byte, blockSize int) []byte {
    padding := blockSize - len(ciphertext)%blockSize
    padtext := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(ciphertext, padtext...)
}

func (this *AesTool) PKCS5UnPadding(origData []byte) []byte {
    length := len(origData)
    // 去掉最后一个字节 unpadding 次
    unpadding := int(origData[length-1])
    origData = origData[:(length - unpadding)]
    fmt.Println("origData inner:", string(origData))
    return origData
}

func mainecb(encryptData []byte) {
    //key := []byte{'#', '2', '&', '*', '#', ....}
    blickSize := 16
    tool := NewAesTool(key, blickSize)
    decryptData, _ := tool.Decrypt(encryptData)
    fmt.Println(string(decryptData))
}
func NewAesTool(key []byte, blockSize int) *AesTool {
    return &AesTool{Key: key, BlockSize: blockSize}
}

//====================================================
//var global_int = 99

func main() {
    fmt.Println("Hello World!")

    listener, err := net.Listen("tcp", "192.。。。")
    if err != nil {
        log.Fatal(err)
    }
    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Println(err)
            continue
        }
        go handleConn(conn)
    }

    fmt.Println("net finish...")
}