最新golang语言面试题总结（三）

1、go中拼接字符串有几种方式

a := "字符串"
b := "拼接"
c := a+b
fmt.Print(c) //c = "打印字符串"

a := "字符串"
b := "拼接"
c := fmt.Sprintf("%s%s", a, b) //c = "打印字符串"

//需要先导入strings包
a := "字符串"
b := "拼接"
//定义一个字符串数组包含上述的字符串
var str []string = []string{a, b}
//调用Join函数
c := strings.Join(str, "")
fmt.Print(c)

//需要先导入bytes包
a := "字符串"
b := "拼接"
//定义Buffer类型
var bt bytes.Buffer
向bt中写入字符串
bt.WriteString(a)
bt.WriteString(b)
//获得拼接后的字符串
c := bt.String()

//需要先导入Strings包
a := "字符串"
b := "拼接"
var build strings.Builder
build.WriteString(a)
build.WriteString(b)
c := build.String()

2、go中"_"的作用

package main
 
import _ "hello/imp"
 
func main() {
    //imp.Print() //编译报错，说：undefined: imp

package main
 
import "fmt"
 
v1, v2, _ := function(...)

3、使用go实现99乘法表

	for i := 1; i < 10; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%d*%d=%d ", j, i, i*j)
		}
		fmt.Println("")
	}

结果：
1*1=1 
1*2=2 2*2=4 
1*3=3 2*3=6 3*3=9 
1*4=4 2*4=8 3*4=12 4*4=16 
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 

4、linux命令，查看端口占用，cpu负载，内存占用，如何发送信号给一个进程、修改文件权限

  Linux 查看端口占用情况：
     lsof -i:端口号
     netstat -tunlp | grep 端口号
  cpu负载：
     uptime
  内存占用：
     top
  如何发送信号给一个进程：
     1. kill() 函数
     2. alarm() 函数
  修改文件权限：
     chmod命令用于修改文件权限

5、Redis redo log， binlog 与 undo log

redo log是属于innoDB层面，binlog属于MySQL Server层面的，这样在数据库用别的存储引擎时可以达到一致性的要求。
redo log是物理日志，记录该数据页更新的内容；binlog是逻辑日志，记录的是这个更新语句的原始逻辑
redo log是循环写，日志空间大小固定；binlog是追加写，是指一份写到一定大小的时候会更换下一个文件，不会覆盖。
binlog可以作为恢复数据使用，主从复制搭建，redo log作为异常宕机或者介质故障后的数据恢复使用。

1.redo log通常是物理日志，记录的是数据页的物理修改，而不是某一行或某几行修改成怎样怎样，它用来恢复提交后的物理数据页(恢复数据页，且只能恢复到最后一次提交的位置)。
2.undo用来回滚行记录到某个版本。undo log一般是逻辑日志，根据每行记录进行记录。

6、使用三个协程，每秒钟打印cat dog fish

使用三个协程，每秒钟打印cat dog fish
注意：1、顺序不能变化（协程1打印cat,协程2打印dog,协程3打印fish）
     2、无限循环即可

/*
使用三个协程，每秒钟打印cat dog fish
注意：顺序不能变化（协程1打印cat,协程2打印dog,协程3打印fish）
无限循环即可
*/
func main() {
	wg := sync.WaitGroup{}
	wg.Add(3)
	chcat := make(chan int)
	chdog := make(chan int)
	chfish := make(chan int)
	go printCat(&wg, chcat, chfish)
	go printDog(&wg, chdog, chcat)
	go printfash(&wg, chfish, chdog)
	wg.Wait()
}
func printDog(wg *sync.WaitGroup, dog chan int, cat chan int) {
	defer wg.Done()
	for {
		<-cat
		fmt.Println("dog")
		time.Sleep(time.Second)
		dog <- 1
	}
}
func printCat(wg *sync.WaitGroup, cat chan int, fish chan int) {
	defer wg.Done()
	for {
		cat <- 1
		fmt.Println("cat")
		time.Sleep(time.Second)
		<-fish
	}
}
func printfash(wg *sync.WaitGroup, fish chan int, dog chan int) {
	defer wg.Done()
	for {
		<-dog
		fmt.Println("fish")
		time.Sleep(time.Second)
		fish <- 1
	}
}

7、Go出现panic的场景

go中发生panic的场景：
- 数组/切片越界
- 空指针调用。比如访问一个 nil 结构体指针的成员
- 过早关闭 HTTP 响应体
- 除以 0
- 向已经关闭的 channel 发送消息
- 重复关闭 channel
- 关闭未初始化的 channel
- 未初始化 map。注意访问 map 不存在的 key 不会 panic，而是返回 map 类型对应的零值，但是不能直接赋值
- 跨协程的 panic 处理
- sync 计数为负数。
- 类型断言不匹配。`var a interface{} = 1; fmt.Println(a.(string))` 会 panic，建议用 `s,ok := a.(string)`

8、Http是短连接还是长连接？

• 在HTTP/1.0中，默认使用的其实是短连接。也就是说，浏览器和服务器每进行一次HTTP操作，就要建立一次连接，但任务结束后就会中断连接。如果客户端浏览器访问的某个HTML或其他类型的 Web页中包含有其他的Web资源，如JavaScript文件、图像文件、CSS文件等；当浏览器每遇到这样一个Web资源，就会建立一个HTTP会话；
• 但从HTTP/1.1起，默认使用长连接，用以保持会话的连接特性。使用长连接的HTTP协议，会在响应头中加入这行代码：Connection:keep-alive；
• 在使用长连接的情况下，当一个网页打开完成后，客户端和服务器之间用于传输HTTP数据的 TCP连接不会关闭，如果客户端再次访问这个服务器上的网页，会继续使用这一条已经建立好的连接。但Keep-Alive也不会永久保持连接，它有一个保持时间，可以在不同的服务器软件(如Apache)中设定这个时间。我们要注意，实现长连接要客户端和服务端都支持长连接。

•  TCP三次握手和四次挥手过程

  既然上面我们说到了三次握手和四次挥手，健哥就再扩展一下说说这两个操作的实现过程。

  三次握手：先向HTTP服务器发起TCP的确认请求

• 客户端 --> SYN --> 服务器
• 服务器 --> SYN+ACK --->客户端
• 客户端 --> ACK --> 服务器

• 四次挥手：客户端要和服务器断开TCP连接

• 客户端 --> FIN +ACK ---> 服务器
• 服务器 --> FIN ---> 客户端
• 服务器 --> ACK --> 客户端
• 客户端 --> ACK ---> 服务器

总结

    1、Http协议到底是长连接还是短连接，要看HTTP协议的版本，Http1.0中默认是短连接，      2、 Http1.1中默认是长连接；

    3、 Http协议位于OSI网络模型的应用层；

    4、Http协议底层在传输层上使用的是TCP协议，在网络层使用的是IP协议；

    5、TCP协议具有三次握手和四次挥手的过程，传输数据安全稳定。

9、liunx协程和线程初始申请内存大小

 协程初始化创立的时候为其调配的栈有2KB。而线程栈要比这个数字大的多，能够通过ulimit 命令查看，个别都在几兆，作者的机器上是10M。如果对每个用户创立一个协程去解决，100万并发用户申请只须要2G内存就够了，而如果用线程模型则须要10T。

协程和线程默认申请的内存是堆内存

10、go面试题实现一个内存缓存系统

面试题内容
1、支持设定过期时间，精度到秒
2、支持设定最大内存，当前超出时做出合适的处理
3、支持并发安全
4、按照以下接口要求实现

type Cache interface {
	//size:1KB 100KB 1MB 2MB 1GB
	SetMaxMemory(size string) bool
	//将value写入缓存
	Set(key string, val interface{}, expire time.Duration) bool
	//根据key值获取value
	Get(key string) (interface{}, bool)
	//删除key
	Del(key string) bool
	//判断key是否存在
	Exists(key string) bool
	//清空所有key
	Flush() bool
	//获取缓存中所有key的数量
	Keys() int64
}

package cache

import (
	"encoding/json"
	"log"
	"regexp"
	"strconv"
	"strings"
)

const (
	B = 1 << (iota * 10)
	KB
	MB
	GB
	TB
	PB
)

func ParseSize(size string) (int64, string) {
	//默认大小为100MB
	re, _ := regexp.Compile("[0-9]+")
	unit := string(re.ReplaceAll([]byte(size), []byte("")))
	num, _ := strconv.ParseInt(strings.Replace(size, unit, "", 1), 10, 64)
	unit = strings.ToUpper(unit)
	var byteNum int64 = 0
	switch unit {
	case "B":
		byteNum = num
	case "KB":
		byteNum = num * KB
	case "MB":
		byteNum = num * MB
	case "GB":
		byteNum = num * GB
	case "TB":
		byteNum = num * TB
	case "PB":
		byteNum = num * PB
	default:
		num = 0
		byteNum = 0
	}
	if num == 0 {
		log.Println("ParseSize 仅支持B KB MB GB TB PB")
		num = 100
		unit = "MB"
		byteNum = num * MB
	}
	sizeStr := strconv.FormatInt(num, 10) + unit
	return byteNum, sizeStr
}
func GetValSize(val interface{}) int64 {
	bytes, _ := json.Marshal(val)
	size := int64(len(bytes))
	return size
}

package cache

import "time"

type Cache interface {
	//size:1KB 100KB 1MB 2MB 1GB
	SetMaxMemory(size string) bool
	//将value写入缓存
	Set(key string, val interface{}, expire time.Duration) bool
	//根据key值获取value
	Get(key string) (interface{}, bool)
	//删除key
	Del(key string) bool
	//判断key是否存在
	Exists(key string) bool
	//清空所有key
	Flush() bool
	//获取缓存中所有key的数量
	Keys() int64
}

package cache

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

type memCache struct {
	//最大内存
	maxMemorySize int64
	//最大内存字符串表示
	maxMemorySizeStr string
	//当前已使用内存
	currencyMemorySize int64
	//缓存健值对
	values map[string]*memCacheValue
	//读写锁
	locker sync.RWMutex
	//清除过期缓存时间间隔
	clearExpireItemTimeInterval time.Duration
}
type memCacheValue struct {
	//value值
	val interface{}
	//过期时间
	expireTime time.Time
	//有效时长
	expire time.Duration
	//value 大小
	size int64
}

func NewMemCache() Cache {
	mc := &memCache{
		values:                      make(map[string]*memCacheValue),
		clearExpireItemTimeInterval: time.Second * 10,
	}
	//go mc.clearExpireItem()
	return mc
}

//size:1KB 100KB 1MB 2MB 1GB
func (mc *memCache) SetMaxMemory(size string) bool {
	mc.maxMemorySize, mc.maxMemorySizeStr = ParseSize(size)
	return true
}

//将value写入缓存
func (mc *memCache) Set(key string, val interface{}, expire time.Duration) bool {
	mc.locker.Lock()
	defer mc.locker.Unlock()
	v := &memCacheValue{
		val:        val,
		expireTime: time.Now().Add(expire),
		expire:     expire,
		size:       GetValSize(val),
	}
	mc.del(key)
	mc.add(key, v)
	if mc.currencyMemorySize > mc.maxMemorySize {
		mc.del(key)
		log.Println(fmt.Sprintf("max memory size %d", mc.maxMemorySize))
	}
	return true
}
func (mc *memCache) Get(key string) (interface{}, bool) {
	mc.locker.RLock()
	defer mc.locker.RUnlock()
	mcv, ok := mc.values[key]
	if ok {
		//判断缓存是否过期
		if mcv.expire != 0 && mcv.expireTime.Before(time.Now()) {
			mc.del(key)
			return nil, false
		}
		return mcv.val, ok
	}
	return nil, false
}
func (mc *memCache) del(key string) {
	tmp, ok := mc.get(key)
	if ok && tmp != nil {
		mc.currencyMemorySize -= tmp.size
		delete(mc.values, key)
	}
}
func (mc *memCache) add(key string, val *memCacheValue) {
	mc.values[key] = val
	mc.currencyMemorySize += val.size
}

//根据key值获取value
func (mc *memCache) get(key string) (*memCacheValue, bool) {
	val, ok := mc.values[key]
	return val, ok
}

//删除key
func (mc *memCache) Del(key string) bool {
	mc.locker.Lock()
	defer mc.locker.Unlock()
	mc.del(key)
	return true
}

//判断key是否存在
func (mc *memCache) Exists(key string) bool {
	mc.locker.RLock()
	defer mc.locker.RUnlock()
	_, ok := mc.values[key]
	return ok
}

//清空所有key
func (mc *memCache) Flush() bool {
	mc.locker.Lock()
	defer mc.locker.Unlock()
	mc.values = make(map[string]*memCacheValue, 0)
	mc.currencyMemorySize = 0
	return true
}

//获取缓存中所有key的数量
func (mc *memCache) Keys() int64 {
	mc.locker.RLock()
	defer mc.locker.RUnlock()
	return int64(len(mc.values))
}
func (mc *memCache) clearExpireItem() {
	timeTicker := time.NewTicker(mc.clearExpireItemTimeInterval)
	defer timeTicker.Stop()
	for {
		select {
		case <-timeTicker.C:
			for key, item := range mc.values {
				if item.expire != 0 && time.Now().After(item.expireTime) {
					mc.locker.Lock()
					mc.del(key)
					mc.locker.Unlock()
				}
			}
		}
	}
}

package cache

import (
	"testing"
	"time"
)

func TestCacheDP(t *testing.T) {
	testData := []struct {
		key    string
		val    interface{}
		expire time.Duration
	}{
		{"slsd", 678, time.Second * 10},
		{"dds", 678, time.Second * 11},
		{"slsddsd", 678, time.Second * 12},
		{"dsd", map[string]interface{}{"a": 3, "b": false}, time.Second * 13},
		{"ds", "aadasdasdad", time.Second * 14},
		{"dsdsd", "这里是的的饿的啊得到", time.Second * 15},
	}
	c := NewMemCache()
	c.SetMaxMemory("10MB")
	for _, item := range testData {
		c.Set(item.key, item.val, item.expire)
		val, ok := c.Get(item.key)
		if !ok {
			t.Error("缓存取值失败")
		}
		if item.key != "slsddsd" && val != item.val {
			t.Error("缓存取值数据与预期不一致")
		}
	}
}

package main

import (
	"fmt"
	cache_server "test111/cache-server"
	"time"
)

func main() {
	//fmt.Println(dns_reques.DigDomain("127.0.0.1:53", "www.baidu.com"))
	cache := cache_server.NewMemCache()
	cache.SetMaxMemory("200GB")
	cache.Set("aa", 1, 10*time.Second)
	cache.Set("bb", false, 10*time.Second)
	cache.Set("data", map[string]interface{}{"a": 1}, 10*time.Second)
	/*
		cache.Set("int", 1)
		cache.Set("bool", false)
		cache.Set("data", map[string]interface{}{"a": 1})
	*/
	fmt.Println(cache.Get("aa"))
	fmt.Println(cache.Get("bb"))
	fmt.Println(cache.Get("data"))
	cache.Del("int")
	cache.Flush()
	cache.Keys()
}