字节跳动 Golang 一面总结

阿贾克斯的黎明

于 2024-09-15 00:20:44 发布

阅读量889

点赞数 8

分类专栏： golang 文章标签： golang 开发语言后端

本文链接：https://blog.csdn.net/m0_57836225/article/details/142268308

版权

golang 专栏收录该内容

182 篇文章 3 订阅

订阅专栏

最近参加了字节跳动的 Golang 岗位社招面试，整个过程持续了 70 分钟，以下是面试的详细内容总结。

一、项目介绍

面试官对我简历上的项目进行了全面的询问，包括项目的背景、目标、技术架构以及我在项目中承担的具体角色和贡献。由于有些项目时间比较久远，一些细节确实需要仔细回忆。在回答项目相关问题时，要清晰地阐述项目的重点和难点，以及自己是如何解决这些问题的。

二、算法题

最长回文子串
- 思路：可以使用动态规划的方法来解决这个问题。定义一个二维数组dp，其中dp[i][j]表示字符串从下标i到下标j的子串是否是回文串。状态转移方程为：如果s[i]==s[j]且当j-i<=1或者dp[i + 1][j - 1]为真时，dp[i][j]为真。
- 代码实现：

package main

func longestPalindrome(s string) string {
    n := len(s)
    if n < 2 {
       return s
    }
    start, maxLen := 0, 1
    dp := make([][]bool, n)
    for i := range dp {
       dp[i] = make([]bool, n)
       dp[i][i] = true
    }
    for j := 1; j < n; j++ {
       for i := 0; i < j; i++ {
          if s[i] == s[j] {
             if j-i <= 2 {
                dp[i][j] = true
             } else {
                dp[i][j] = dp[i+1][j-1]
             }
          }
          if dp[i][j] && j-i+1 > maxLen {
             start = i
             maxLen = j - i + 1
          }
       }
    }
    return s[start : start+maxLen]
}

LRU（Least Recently Used）缓存
- 思路：可以使用哈希表和双向链表来实现 LRU 缓存。哈希表用于快速查找节点，双向链表用于维护节点的使用顺序。当访问一个节点时，将其移动到链表头部；当缓存满时，删除链表尾部的节点。
- 代码实现：

package main

type Node struct {
    key, value int
    prev, next *Node
}

type LRUCache struct {
    capacity int
    cache    map[int]*Node
    head, tail *Node
}

func Constructor(capacity int) LRUCache {
    cache := LRUCache{
       capacity: capacity,
       cache:    make(map[int]*Node),
       head:     &Node{},
       tail:     &Node{},
    }
    cache.head.next = cache.tail
    cache.tail.prev = cache.head
    return cache
}

func (this *LRUCache) Get(key int) int {
    if node, ok := this.cache[key]; ok {
       this.removeNode(node)
       this.addToHead(node)
       return node.value
    }
    return -1
}

func (this *LRUCache) Put(key int, value int) {
    if node, ok := this.cache[key]; ok {
       node.value = value
       this.removeNode(node)
       this.addToHead(node)
    } else {
       newNode := &Node{key: key, value: value}
       this.cache[key] = newNode
       this.addToHead(newNode)
       if len(this.cache) > this.capacity {
          removed := this.removeTail()
          delete(this.cache, removed.key)
       }
    }
}

func (this *LRUCache) removeNode(node *Node) {
    node.prev.next = node.next
    node.next.prev = node.prev
}

func (this *LRUCache) addToHead(node *Node) {
    node.next = this.head.next
    node.prev = this.head
    this.head.next.prev = node
    this.head.next = node
}

func (this *LRUCache) removeTail() *Node {
    removed := this.tail.prev
    this.removeNode(removed)
    return removed
}

LFU（Least Frequently Used）缓存
- 思路：LFU 缓存需要维护每个键的访问频率。可以使用哈希表和多个双向链表来实现。每个链表代表一个不同的访问频率，当一个键被访问时，将其从当前频率的链表中移除，并插入到更高频率的链表头部。当缓存满时，删除最低频率链表的尾部节点。
- 虽然在面试中没有完整写出代码，但大致思路如下：
  - 定义一个结构体来表示节点，包含键、值、访问频率和指向前一个节点和后一个节点的指针。
  - 定义一个结构体来表示 LFU 缓存，包含容量、哈希表用于存储键和节点的映射、多个双向链表用于存储不同频率的节点。
  - 实现Get方法，根据键从哈希表中查找节点，如果找到，则增加节点的访问频率，并将其移动到更高频率的链表中。
  - 实现Put方法，根据键判断节点是否存在，如果存在，则更新值并增加访问频率；如果不存在，则创建新节点，插入到最低频率的链表中。如果缓存已满，则删除最低频率链表的尾部节点。

三、Redis 相关问题

Redis 大 key 和热 key 问题
- 大 key 问题：
  - 定义：Redis 中的大 key 是指存储的数据量较大的键值对，可能会占用大量的内存空间，影响 Redis 的性能和稳定性。
  - 解决方法：
    - 避免存储过大的数据：尽量将数据拆分成多个小的键值对进行存储。
    - 定期清理无用数据：对于不再使用的大 key，可以及时删除。
    - 使用 Redis 的数据结构优化：例如，对于存储大量元素的集合，可以考虑使用有序集合（Sorted Set）来替代列表（List），以提高查询性能。
- 热 key 问题：
  - 定义：热 key 是指被频繁访问的键，可能会导致 Redis 服务器的负载不均衡，影响整体性能。
  - 解决方法：
    - 缓存预热：在系统启动时，将热 key 预先加载到缓存中，减少首次访问时的延迟。
    - 本地缓存：在应用服务器本地使用缓存，减少对 Redis 的访问压力。
    - 读写分离：对于读操作频繁的热 key，可以使用 Redis 的主从复制功能，将读操作分散到多个从节点上。
    - 数据分片：将热 key 的数据分散到多个 Redis 实例中，通过一致性哈希等算法进行路由。
Redis 和数据库缓存一致性怎么解决
- 先更新数据库，再删除缓存：在更新数据库后，立即删除缓存中的对应数据。这样，下次读取数据时，会从数据库中重新加载最新的数据到缓存中。但是这种方法可能会出现缓存删除失败的情况，可以通过重试机制或者使用消息队列来保证缓存删除的可靠性。
- 先删除缓存，再更新数据库：这种方法可以避免在更新数据库的过程中，其他线程读取到旧数据并放入缓存的问题。但是如果在删除缓存后，数据库更新失败，可能会导致数据不一致。可以通过事务或者重试机制来解决这个问题。
- 使用缓存更新机制：可以在数据库更新时，同时更新缓存。但是这种方法需要保证缓存更新的原子性和一致性，可以使用分布式锁或者事务来实现。