golang grace.go

Posted 2021-05-24

package main

import (
	"log"
	"net"
	"os"
	"os/signal"
	"sync"
	"syscall"
	"time"
)

// An uninteresting service.
type Service struct {
	ch        chan bool
	waitGroup *sync.WaitGroup
}

// Make a new Service.
func NewService() *Service {
	s := &Service{
		ch:        make(chan bool),
		waitGroup: &sync.WaitGroup{},
	}
	s.waitGroup.Add(1)
	return s
}

// Accept connections and spawn a goroutine to serve each one.  Stop listening
// if anything is received on the service's channel.
func (s *Service) Serve(listener *net.TCPListener) {
	defer s.waitGroup.Done()
	for {
		select {
		case <-s.ch:
			log.Println("stopping listening on", listener.Addr())
			listener.Close()
			return
		default:
		}
		listener.SetDeadline(time.Now().Add(1e9))
		conn, err := listener.AcceptTCP()
		if nil != err {
			if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() {
				continue
			}
			log.Println(err)
		}
		log.Println(conn.RemoteAddr(), "connected")
		s.waitGroup.Add(1)
		go s.serve(conn)
	}
}

// Stop the service by closing the service's channel.  Block until the service
// is really stopped.
func (s *Service) Stop() {
	close(s.ch)
	s.waitGroup.Wait()
}

// Serve a connection by reading and writing what was read.  That's right, this
// is an echo service.  Stop reading and writing if anything is received on the
// service's channel but only after writing what was read.
func (s *Service) serve(conn *net.TCPConn) {
	defer conn.Close()
	defer s.waitGroup.Done()
	for {
		select {
		case <-s.ch:
			log.Println("disconnecting", conn.RemoteAddr())
			return
		default:
		}
		conn.SetDeadline(time.Now().Add(1e9))
		buf := make([]byte, 4096)
		if _, err := conn.Read(buf); nil != err {
			if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() {
				continue
			}
			log.Println(err)
			return
		}
		if _, err := conn.Write(buf); nil != err {
			log.Println(err)
			return
		}
	}
}

func main() {

	// Listen on 127.0.0.1:48879.  That's my favorite port number because in
	// hex 48879 is 0xBEEF.
	laddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:48879")
	if nil != err {
		log.Fatalln(err)
	}
	listener, err := net.ListenTCP("tcp", laddr)
	if nil != err {
		log.Fatalln(err)
	}
	log.Println("listening on", listener.Addr())

	// Make a new service and send it into the background.
	service := NewService()
	go service.Serve(listener)

	// Handle SIGINT and SIGTERM.
	ch := make(chan os.Signal)
	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
	log.Println(<-ch)

	// Stop the service gracefully.
	service.Stop()

}

Golang 入门

Golang 入门

• 一、Golang 简介
• • 1.Go 语言的特点
  • 2.Golang 的变量作用域
  • 3.Golang 执行流程的两种方式
• 二、Golang 的基本操作
• • 1.在 Linux 上安装 Golang 语言开发包
  • 2.Golang 变量的基本使用
  • 3.Golang 中整数的类型
  • 4.Golang 基本数据类型的默认值
  • 5.基本数据类型转换为 String 类型

一、Golang 简介

Golang（又称为 Go）是 Google 公司开发出的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。

1.Go 语言的特点

Go 语言保证了既能够达到 静态编译语言的安全和性能，又达到了 动态开发语言维护的高效率，使用一个表达式来形容 Go 语言：Go = C + Python，说明 Go 语言既有 C 静态语言程序的运行速度，又能达到 Python 动态语言的快速开发。

---

1）从 C 语言中继承了很多理念，包括表达式语法，控制结构，基础数据类型，调用参数传值，指针 等等，也保留了和 C 语言一样的编译执行方式及弱化的指针。

func testPtr(num *int) 
    *num = 20

2）引入 包的概念，用于组织程序结构，Go 语言的 一个文件都要归于一个包，而不能单独存在。

package main
import "fmt"
func main() 
    fmt.Println("Hello World")

3）垃圾回收机制，内存自动回收，不需要开发人员管理。

4）天然并发：从语言层面上支持并发，实现简单；goroutine 轻量级线程，可实现大并发处理，高效利用多核；基于 CPS 并发模型实现。

5）吸收了 管道通信机制，形成 Go 语言特有的管道 Channel，通过管道 Channel，我们可以实现不通的 goroute 之间的互相通信。

6）函数可以返回多个值：

func getSumAndSub(sum int,sub int) (int,int) 
    Sum := sum + sub
    Sub := sum - sub
    return Sum,Sub

7）新的创新，比如：Slice 切片，Defer 延时执行等。

2.Golang 的变量作用域

• 局部变量： 在函数内部定义的变量，作用域仅限于函数内部（首字母是大写的也不行）
• 全局变量： 在函数外部定义的变量，作用域在整个包都有效，当首字母是大写时，则作用域在整个程序都有效。

但是当变量在代码块中定义时，比如 if for 中，那么这个变量的作用域就在该代码块中有效。

还有一个就是：赋值语句是不能定义在函数体外的，如：这种 name := "zhangsan"，我们换成 var name string = "zhangsan" 即可。

3.Golang 执行流程的两种方式

1. 先编译，在执行： go build -o Hello.exe test.go（编译完后可以到处运行，但是编译后文件会较大）
2. 直接运行： go run test.go（直接运行，速度相对来说要比先编译的较慢，需要依赖 Go 环境）

PS：Go 语言 定义的变量 或者 import 包，如果没有使用放到，代码是不能编译通过的。

二、Golang 的基本操作

1.在 Linux 上安装 Golang 语言开发包

1）安装 Golang 软件包

[root@localhost ~]# wget https://golang.google.cn/dl/go1.17.3.linux-amd64.tar.gz
[root@localhost ~]# tar xf go1.17.3.linux-amd64.tar.gz -C /usr/local/
[root@localhost ~]# ln -s /usr/local/go/bin/* /usr/bin/
[root@localhost ~]# go version
go version go1.17.3 linux/amd64

2）配置 Golang 的开发环境

[root@localhost ~]# mkdir -p ~/Go-Test/src						# Golang 的源代码目录
[root@localhost ~]# mkdir -p ~/Go-Test/pkg						# Golang 编译后生成的库文件
[root@localhost ~]# mkdir -p ~/Go-Test/bin						# Golang 编译后生成的可执行文件

[root@localhost ~]# cat <<END >> ~/.bashrc
export GOROOT=/usr/local/go
export GOPATH=~/Go-Test
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
END
[root@localhost ~]# source ~/.bashrc
[root@localhost ~]# go env							# 查看 Go 的环境变量是否修改文件中目录

3）编写 Go 代码进行验证

[root@localhost ~]# cat <<END > Hello.go
package main
import "fmt"
func main() 
    fmt.Println("Hello World")

END
[root@localhost ~]# go run Hello.go
Hello World

2.Golang 变量的基本使用

package main
import "fmt"
func main() 
    var Count int						// 定义一个变量 (声明变量)
    Count = 188 						// 给定义的变量进行赋值
    fmt.Println("Count:",Count)

Golang 变量的三种使用方式：

1）指定变量类型（声明后若不赋值，则使用默认值）

func main() 
    var Count int						// int 类型的默认值为 0
    fmt.Println(Count)

2）根据自行判定变量类型（类型推导： 简单来说就是让 Go 编译器进行自主判断）

func main() 
    var Count = 18.88
    fmt.Printf("Count 的值=%v,Count 的类型=%T",Count,Count)

3）直接使用 := 进行赋值（:= 表示声明并赋值）

func main() 
    name := "zhangsan"
    fmt.Println(name)

在区域中的 数据值 可以在 同一类型范围内不断变化：

func main() 
    // 当定义多个相同名称的变量时. Go 便会获取最后一个变量的变量值
    // 需要注意的是只能是同类型的 (比如说 int 类型就不能替换成 string)
    var sum = 188
    // PS: 在同一区域中的变量名不能重复声明. 也就是说在同一区域中的同一个变量名只能声明一次
    sum = 288
    fmt.Println(sum)

Golang 中 + 的使用：

func main() 
    var Sum = 188
    var Sub = 18
    Result := Sum + Sub
    fmt.Println(Result)					// 当变量为整数时. 做的便是加法运算
    1 := "Hello"
    2 := "World"
    3 := 1 + 2
    fmt.Println(3)						// 当变量为字符串时. 做的便是拼接操作

3.Golang 中整数的类型

类型	有无符号	占用存储空间	备注
int	有	32 位系统 4 个字节，64 位系统 8 个字节
uint	无	32 位系统 4 个字节，64 位系统 8 个字节
rune	有	与 int32 等价	主要用于处理 Unicode 码
byte	无	与 uint8 等价	主要用于存储字符

• 有符号合无符号最大的区别就是，有符号支持负数，而无符号则是只支持正数。
• bit 和 byte 的区别：bit 是计算机中最小的存储单位，而 byte 则是计算机中的基本存储单元（1 btye = 8 bit）

Go 语言的字符使用的是 UTF-8 的字符编码，查询编码地址为：查询编码地址

• 在 Go 中，字符的本质是一个整数，直接输出时，会打印出字符对应的 UTF-8 编码的码值。

func main() 
    var str string = "张三"
    fmt.Println("str 对应的 Unicode 码为:",[]byte(str))			// 需要使用 []byte 来进行转换

4.Golang 基本数据类型的默认值

数据类型	默认值
整形	0
浮点型	0
字符串	" "
布尔类型	false

常见的值类型和引用类型：

• 值类型： 基本数据类型（int float bool string），数组和结构体（struct）
• 引用类型： 指针、slice 切片、map、channel 管道、interface 接口等等都是引用类型。

值类型和引用类型的使用特点：

• 值类型： 变量直接存储值，内存通常在栈中分配。
• 引用类型： 变量存储的是一个地址，这个地址对应的空间才是真正存储的数据（值），内存通常在堆上分配。

当没有任何变量引用这个地址时，这个地址对应的数据空间就成为了一个 垃圾，由 GC 来进行回收。

5.基本数据类型转换为 String 类型

第一种方式：

package main
import "fmt"
func main() 
    var A int = 88
    var B float64 = 188.88
    var C bool = true
    var D byte = 'Z'						// byte 只能定义单个字符
    var str string							// 定义一个空的字符串
    str = fmt.Sprintf("%d",A)
    fmt.Printf("str type is %T str=%q\\n",str,str)
    str = fmt.Sprintf("%f",B)
    fmt.Printf("str type is %T str=%q\\n",str,str)
    str = fmt.Sprintf("%t",C)
    fmt.Printf("str type is %T str=%q\\n",str,str)
    str = fmt.Sprintf("%c",D)
    fmt.Printf("str type is %T str=%q\\n",str,str)

第二种方式：

package main
import (
    "fmt"
    "strconv"
)
func main() 
    var A int = 88
    var B float64 = 188.88
    var C bool = true
    var str string
    str = strconv.FormatInt(int64(A),10)
    fmt.Printf("str type is %T str=%q\\n",str,str)
    str = strconv.FormatFloat(B,'f',2,64)			// 'f' 表示格式. 2 表示小数位保留两位. 64 表示这个小数点是 float64
    fmt.Printf("str type is %T str=%q\\n",str,str)
    str = strconv.FormatBool(C)
    fmt.Printf("str type is %T str=%q\\n",str,str)