字节跳动开启两大顶尖人才计划！内推一人一万？

大家好，我是白露。

问大家一个问题，你觉得内推一个校招生能拿到多少钱？

今天从字节朋友了解到，最近字节跳动新开了一个招聘计划。内推奖励是一人至少一万。。。

我都惊呆了，因为我之前了解过腾讯、快手、字节的招聘奖励。根据内推人员的级别不同，奖励从1000~6000不等。

然而字节这1w的手笔属实有点大了。

我进一步了解到，这个计划名为——筋斗云人才计划计划。

从这个名称就可以看出，字节这次的招聘计划要求很高。直接写明了，只要博士。

有点类似于华为天才少年那种感觉的了。

昨晚字节官网也放出了该计划的详细信息：

可以看出，筋斗云人才计划，主要是为了挖掘在AI应用、搜索、机器人等领域有潜力的应届博士。

更有意思的，就在几天前，其实字节还公布了一个人才计划，名为：Top Seed人才计划。

咦，两个人才计划的区别是啥？🤨

官方给出的解释是;

• 如果你有志于投身机器学习、人工智能、大模型、计算机视觉、音视频生成等领域，请选择Top Seed 人才计划。
• 如果你有志于投身 AI应用、搜索、推荐、广告、Al for Science、Al Safety、机器人、隐私与安全、硬件、视频架构、工程架构等领域，请选择筋斗云人才计划。

emmm…（其实，这大概率是在布局 AI 领域了，豆包就是字节首推的 AI 软件）

其实在白露看来，这两个计划的区别都不大，归根结底，就是字节内部推出的人才计划，晋升、薪资等肯定比正常offer高出不多。

并且，这两个人才计划的投递都不会影响正常的校招投递次数！

一句话。

如果你正好是博士毕业，并且真的有不错的成绩，白露强烈建议你去投递这两个计划。总是不会吃亏的。

好了，今天我们就来看《拿下面试官》收录的一篇字节飞书面试题目，需要参加秋招的同学可要好好看看！

飞书面试

进程和线程

面试官: 那我们先聊聊进程和线程吧。能否解释一下它们的区别以及各自的应用场景？

求职者: 当然可以。

• 进程：进程是操作系统分配资源的基本单位，每个进程都有独立的内存空间。进程之间是相互独立的，一个进程的崩溃不会影响到其他进程。常见的应用场景包括：运行独立的应用程序，如浏览器、IDE等。
• 线程：线程是CPU调度的基本单位，同一进程下的线程共享进程的内存空间和资源。线程之间可以直接通信，但需要注意同步问题。常见的应用场景包括：多线程并发处理，如Web服务器的并发请求处理。

面试官: 那么，线程在什么情况下会发生死锁，如何避免？

求职者: 线程死锁通常发生在以下情况下：

1. 互斥条件：线程需要独占资源。
2. 持有并等待：线程持有一个资源，并等待获取另一个资源。
3. 不可剥夺：资源不能被强制剥夺，只能由持有线程释放。
4. 循环等待：存在一个循环等待的线程链。

避免死锁的方法：

• 破坏互斥条件：尽量减少独占资源的使用。
• 破坏持有并等待条件：在申请资源时不持有其他资源。
• 破坏不可剥夺条件：允许资源被抢占。
• 破坏循环等待条件：按顺序申请资源。

---

堆和栈

面试官: 接下来，我们聊聊堆和栈。能否解释一下它们的区别？在C++中如何避免内存碎片？

求职者: 当然。

• 堆：堆是用于动态分配内存的区域，大小不固定，需要手动管理（如malloc/free）。容易产生内存碎片。
• 栈：栈是用于静态内存分配的区域，大小固定，由编译器自动管理。不存在内存碎片问题。

避免内存碎片的方法：

1. 内存池：使用内存池预先分配大块内存，按需分配小块。
2. 智能指针：使用智能指针自动管理内存，减少内存泄漏。
3. 操作系统提供的内存管理函数：如posix_memalign等。

---

哈希表

面试官: 解释一下哈希表及其底层实现。

求职者: 哈希表是一种数据结构，通过哈希函数将键映射到存储桶（bucket）。其底层实现包括以下几个部分：

1. 哈希函数：将键转换为数组索引。
2. 数组：存储数据的主要结构。
3. 冲突处理：常见的方法有链地址法（拉链法）和开放地址法。

---

场景题：云服务写和读

面试官: 假设某个云服务，同时有1个写操作和多个读操作，需要加锁吗？怎么加？

求职者: 需要加锁，以保证数据的一致性。可以使用读写锁来实现：

• 读锁（共享锁）：多个读操作可以同时进行，不会互相阻塞。
• 写锁（独占锁）：写操作需要独占资源，写锁会阻塞读锁和其他写锁。

---

提升性能

面试官: 怎么在加锁的情境下提升性能？

求职者: 可以采用以下方法：

1. 粒度优化：减少锁的粒度，尽量锁定更小的范围。
2. 读写锁：用读写锁替代互斥锁，允许多个读操作并行。
3. 减少锁的持有时间：尽量缩短锁的持有时间，减少锁的竞争。

---

无锁情况下的数据一致性

面试官: 在无锁的情况下，如何保持数据的一致性？

求职者: 在无锁情况下，可以采用以下方法：

1. 事务机制：数据库中使用事务机制，通过回滚来保持一致性。
2. 原子操作：使用原子操作（如C++中的std::atomic）进行操作，保证操作的原子性。
3. 数据副本：拷贝一份数据进行操作，操作结束后再替换原数据，避免并发修改带来的不一致。

---

算法题：LRU缓存和X秒过期缓存

面试官: 我们来做一道算法题，设计一个LRU缓存，并实现X秒过期的缓存。

求职者: 好的，这是LRU缓存的实现代码：

#include <unordered_map>
#include <list>
#include <chrono>

class LRUCache {
private:
    int capacity;
    std::list<std::pair<int, int>> cacheList;
    std::unordered_map<int, std::list<std::pair<int, int>>::iterator> cacheMap;

public:
    LRUCache(int capacity) : capacity(capacity) {}

    int get(int key) {
        if (cacheMap.find(key) == cacheMap.end()) {
            return -1;
        }
        cacheList.splice(cacheList.begin(), cacheList, cacheMap[key]);
        return cacheMap[key]->second;
    }

    void put(int key, int value) {
        if (cacheMap.find(key) != cacheMap.end()) {
            cacheList.splice(cacheList.begin(), cacheList, cacheMap[key]);
            cacheMap[key]->second = value;
            return;
        }
        if (cacheList.size() == capacity) {
            int delKey = cacheList.back().first;
            cacheList.pop_back();
            cacheMap.erase(delKey);
        }
        cacheList.emplace_front(key, value);
        cacheMap[key] = cacheList.begin();
    }
};

这是X秒过期缓存的实现：

#include <unordered_map>
#include <list>
#include <chrono>

class ExpiringCache {
private:
    int capacity;
    int ttl; // Time to live in seconds
    std::list<std::tuple<int, int, std::chrono::time_point<std::chrono::steady_clock>>> cacheList;
    std::unordered_map<int, std::list<std::tuple<int, int, std::chrono::time_point<std::chrono::steady_clock>>>::iterator> cacheMap;

public:
    ExpiringCache(int capacity, int ttl) : capacity(capacity), ttl(ttl) {}

    int get(int key) {
        auto currentTime = std::chrono::steady_clock::now();
        if (cacheMap.find(key) == cacheMap.end()) {
            return -1;
        }
        auto& entry = *cacheMap[key];
        if (std::chrono::duration_cast<std::chrono::seconds>(currentTime - std::get<2>(entry)).count() >= ttl) {
            cacheList.erase(cacheMap[key]);
            cacheMap.erase(key);
            return -1;
        }
        cacheList.splice(cacheList.begin(), cacheList, cacheMap[key]);
        return std::get<1>(cacheMap[key]);
    }

    void put(int key, int value) {
        auto currentTime = std::chrono::steady_clock::now();
        if (cacheMap.find(key) != cacheMap.end()) {
            cacheList.splice(cacheList.begin(), cacheList, cacheMap[key]);
            std::get<1>(cacheMap[key]) = value;
            std::get<2>(cacheMap[key]) = currentTime;
            return;
        }
        if (cacheList.size() == capacity) {
            int delKey = std::get<0>(cacheList.back());
            cacheList.pop_back();
            cacheMap.erase(delKey);
        }
        cacheList.emplace_front(key, value, currentTime);
        cacheMap[key] = cacheList.begin();
    }
};

面试官: 很好，今天的面试就到这里了。我们会尽快通知你结果。

参考原文:https://offernow.cn
AI学习助手:https://aistar.cool