大家好，我是程序员小灰。
很多校招同学都是 9-10 月份拿到了字节意向，等了 1 个多月才能知道具体的薪资，这几天字节跳动 25 届校招终于开奖了。
先说结论，从目前我看到的薪资情况来看，今年字节跳动的薪资和去年差不多。
我们先来看看，去年 24 届字节跳动开发岗位的校招薪资：
我根据网络上同学们的爆料，整理了 25 届字节跳动后端开发的校招薪资 情况：
ssp offer：
35k*15 + 1w 签字费，同学 bg 硕士 985，base 上海 34k*15 + 1w 签字费，同学 bg 硕士 985，base 北京 33k*15 + 1w 签字费，同学 bg 硕士双一流，base 北京 32k*15 + 1w 签字费，同学 bg 硕士 985，base 深圳 sp offer：
30k*15 + 1w 签字费，同学 bg 硕士 211，base 深圳 28k*15 + 1w 签字费，同学 bg 硕士 211，base 北京 27k*15 + 1w 签字费，同学 bg 硕士 985，base 珠海 普通 offer：
26k*15 + 1w 签字费 ，同学 bg 硕士 985，base 北京 珠海 base 同学就会比较香，基本跟北京薪资差不多，没有打 8 折。
今年整体上跟去年差不多，有一点小区别在于，后端开发的普通档 offer 比去年多了 1k，今年是 26x15，去年是 25x15。
不过，今年测试开发岗的普通档 offer 是 25k *15，会比后端开发岗位少 1k，差距不是很大。
字节跳动招聘是偏向直接招聪明的人，而不想培养人，所以面试相对会比较严格，基本每一轮技术面试都有手撕算法环节，不只是针对校招，包括社招也逃不了。
之前有双非同学面字节实习，上来就扔 2 个 hard 级别的算法题给他做，这种很明显就是劝退式面试，大部分人肯定做不出来的，能做出来面试官也认了，好在这个同学平时算法下了苦功夫，他是手撕出来了，所以最后也进了字节实习。
但是也见过学历+实习较好的同学面字节，直接出了easy 算法题，这种明显就是面试官很想招这个同学，给了放水式的算法题，不过终究都还是有算法题。
这次，来分享字节跳动的校招面经 ，问八股文比较多，一共经历了一二三面，每一场面试的强度还是蛮高，每次都是 1 个小时+。
我把这几场面试中比较有代表性的题目抽离出来给大家解析一波，下面是题目，够长吧.....
Redis Redis 有哪些数据结构？ Redis 提供了丰富的数据类型，常见的有五种数据类型：String（字符串），Hash（哈希），List（列表），Set（集合）、Zset（有序集合） 。
img img 随着 Redis 版本的更新，后面又支持了四种数据类型：BitMap（2.2 版新增）、HyperLogLog（2.8 版新增）、GEO（3.2 版新增）、Stream（5.0 版新增） 。Redis 五种数据类型的应用场景：
String 类型的应用场景：缓存对象、常规计数、分布式锁、共享 session 信息等。 List 类型的应用场景：消息队列（但是有两个问题：1. 生产者需要自行实现全局唯一 ID；2. 不能以消费组形式消费数据）等。 Set 类型：聚合计算（并集、交集、差集）场景，比如点赞、共同关注、抽奖活动等。 Zset 类型：排序场景，比如排行榜、电话和姓名排序等。 Redis 后续版本又支持四种数据类型，它们的应用场景如下：
BitMap（2.2 版新增）：二值状态统计的场景，比如签到、判断用户登陆状态、连续签到用户总数等； HyperLogLog（2.8 版新增）：海量数据基数统计的场景，比如百万级网页 UV 计数等； GEO（3.2 版新增）：存储地理位置信息的场景，比如滴滴叫车； Stream（5.0 版新增）：消息队列，相比于基于 List 类型实现的消息队列，有这两个特有的特性：自动生成全局唯一消息ID，支持以消费组形式消费数据。 Zset 使用了什么数据结构？ Zset 类型的底层数据结构是由压缩列表或跳表 实现的：
如果有序集合的元素个数小于 128 个，并且每个元素的值小于 64 字节时，Redis 会使用压缩列表 作为 Zset 类型的底层数据结构； 如果有序集合的元素不满足上面的条件，Redis 会使用跳表 作为 Zset 类型的底层数据结构； 在 Redis 7.0 中，压缩列表数据结构已经废弃了，交由 listpack 数据结构来实现了。
SkipList 了解吗？ 链表在查找元素的时候，因为需要逐一查找，所以查询效率非常低，时间复杂度是O(N)，于是就出现了跳表。跳表是在链表基础上改进过来的，实现了一种「多层」的有序链表 ，这样的好处是能快读定位数据。
那跳表长什么样呢？我这里举个例子，下图展示了一个层级为 3 的跳表。
img 图中头节点有 L0~L2 三个头指针，分别指向了不同层级的节点，然后每个层级的节点都通过指针连接起来：
L0 层级共有 5 个节点，分别是节点1、2、3、4、5； L1 层级共有 3 个节点，分别是节点 2、3、5； 如果我们要在链表中查找节点 4 这个元素，只能从头开始遍历链表，需要查找 4 次，而使用了跳表后，只需要查找 2 次就能定位到节点 4，因为可以在头节点直接从 L2 层级跳到节点 3，然后再往前遍历找到节点 4。
可以看到，这个查找过程就是在多个层级上跳来跳去，最后定位到元素。当数据量很大时，跳表的查找复杂度就是 O(logN)。
跳表的时间复杂度是多少？ 跳表中查找一个元素的时间复杂度为O(logn)，空间复杂度是 O(n)。
为什么 MysSQL 不用 SkipList？ B+树的高度在3层时存储的数据可能已达千万级别，但对于跳表而言同样去维护千万的数据量那么所造成的跳表层数过高而导致的磁盘io次数增多，也就是使用B+树在存储同样的数据下磁盘io次数更少。
Redis 使用场景? Redis 是一种基于内存的数据库，对数据的读写操作都是在内存中完成，因此读写速度非常快 ，常用于缓存，消息队列、分布式锁等场景 。
Redis 提供了多种数据类型来支持不同的业务场景，比如 String(字符串)、Hash(哈希)、 List (列表)、Set(集合)、Zset(有序集合)、Bitmaps（位图）、HyperLogLog（基数统计）、GEO（地理信息）、Stream（流），并且对数据类型的操作都是原子性 的，因为执行命令由单线程负责的，不存在并发竞争的问题。
除此之外，Redis 还支持事务 、持久化、Lua 脚本、多种集群方案（主从复制模式、哨兵模式、切片机群模式）、发布/订阅模式，内存淘汰机制、过期删除机制 等等。
Redis 性能好的原因是什么？ 官方使用基准测试的结果是，单线程的 Redis 吞吐量可以达到 10W/每秒 ，如下图所示：
img 之所以 Redis 采用单线程（网络 I/O 和执行命令）那么快，有如下几个原因：
Redis 的大部分操作都在内存中完成 ，并且采用了高效的数据结构，因此 Redis 瓶颈可能是机器的内存或者网络带宽，而并非 CPU，既然 CPU 不是瓶颈，那么自然就采用单线程的解决方案了； Redis 采用单线程模型可以避免了多线程之间的竞争 ，省去了多线程切换带来的时间和性能上的开销，而且也不会导致死锁问题。 Redis 采用了 I/O 多路复用机制 处理大量的客户端 Socket 请求，IO 多路复用机制是指一个线程处理多个 IO 流，就是我们经常听到的 select/epoll 机制。简单来说，在 Redis 只运行单线程的情况下，该机制允许内核中，同时存在多个监听 Socket 和已连接 Socket。内核会一直监听这些 Socket 上的连接请求或数据请求。一旦有请求到达，就会交给 Redis 线程处理，这就实现了一个 Redis 线程处理多个 IO 流的效果。 Redis 和 MySQL 如何保证一致性 可以采用「先更新数据库，再删除缓存」的更新策略+过期时间来兜底。
我们用「读 + 写」请求的并发的场景来分析。
假如某个用户数据在缓存中不存在，请求 A 读取数据时从数据库中查询到年龄为 20，在未写入缓存中时另一个请求 B 更新数据。它更新数据库中的年龄为 21，并且清空缓存。这时请求 A 把从数据库中读到的年龄为 20 的数据写入到缓存中。
图片 最终，该用户年龄在缓存中是 20（旧值），在数据库中是 21（新值），缓存和数据库数据不一致。
从上面的理论上分析，先更新数据库，再删除缓存也是会出现数据不一致性的问题，但是在实际中，这个问题出现的概率并不高 。
因为缓存的写入通常要远远快于数据库的写入 ，所以在实际中很难出现请求 B 已经更新了数据库并且删除了缓存，请求 A 才更新完缓存的情况。
而一旦请求 A 早于请求 B 删除缓存之前更新了缓存，那么接下来的请求就会因为缓存不命中而从数据库中重新读取数据，所以不会出现这种不一致的情况。
所以，「先更新数据库 + 再删除缓存」的方案，是可以保证数据一致性的 。
而且为了确保万无一失，还给缓存数据加上了「过期时间 」，就算在这期间存在缓存数据不一致，有过期时间来兜底，这样也能达到最终一致。
MySQL 事务有哪些特性? 事务 4 个特性，分别如下：
原子性（Atomicity） ：一个事务中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节，而且事务在执行过程中发生错误，会被回滚到事务开始前的状态，就像这个事务从来没有执行过一样，就好比买一件商品，购买成功时，则给商家付了钱，商品到手；购买失败时，则商品在商家手中，消费者的钱也没花出去。一致性（Consistency） ：是指事务操作前和操作后，数据满足完整性约束，数据库保持一致性状态。比如，用户 A 和用户 B 在银行分别有 800 元和 600 元，总共 1400 元，用户 A 给用户 B 转账 200 元，分为两个步骤，从 A 的账户扣除 200 元和对 B 的账户增加 200 元。一致性就是要求上述步骤操作后，最后的结果是用户 A 还有 600 元，用户 B 有 800 元，总共 1400 元，而不会出现用户 A 扣除了 200 元，但用户 B 未增加的情况（该情况，用户 A 和 B 均为 600 元，总共 1200 元）。隔离性（Isolation） ：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致，因为多个事务同时使用相同的数据时，不会相互干扰，每个事务都有一个完整的数据空间，对其他并发事务是隔离的。也就是说，消费者购买商品这个事务，是不影响其他消费者购买的。持久性（Durability） ：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。隔离性有哪些隔离级别? 四个隔离级别如下：
读未提交（*read uncommitted*） ，指一个事务还没提交时，它做的变更就能被其他事务看到；读提交（*read committed*） ，指一个事务提交之后，它做的变更才能被其他事务看到；可重复读（*repeatable read*） ，指一个事务执行过程中看到的数据，一直跟这个事务启动时看到的数据是一致的，MySQL InnoDB 引擎的默认隔离级别 ；串行化（*serializable* ） ；会对记录加上读写锁，在多个事务对这条记录进行读写操作时，如果发生了读写冲突的时候，后访问的事务必须等前一个事务执行完成，才能继续执行；按隔离水平高低排序如下：
图片 针对不同的隔离级别，并发事务时可能发生的现象也会不同。
图片 也就是说：
在「读未提交」隔离级别下，可能发生脏读、不可重复读和幻读现象； 在「读提交」隔离级别下，可能发生不可重复读和幻读现象，但是不可能发生脏读现象； 在「可重复读」隔离级别下，可能发生幻读现象，但是不可能脏读和不可重复读现象； 在「串行化」隔离级别下，脏读、不可重复读和幻读现象都不可能会发生。 MySQL 默认用的哪个级别? MySQL 默认隔离级别是「可重复读」，可以很大程度上避免幻读现象的发生（注意是很大程度避免，并不是彻底避免），所以 MySQL 并不会使用「串行化」隔离级别来避免幻读现象的发生，因为使用「串行化」隔离级别会影响性能。
间隙锁的原理 Gap Lock 称为间隙锁，只存在于可重复读隔离级别，目的是为了解决可重复读隔离级别下幻读的现象。
假设，表中有一个范围 id 为（3，5）间隙锁，那么其他事务就无法插入 id = 4 这条记录了，这样就有效的防止幻读现象的发生。
img 间隙锁虽然存在 X 型间隙锁和 S 型间隙锁，但是并没有什么区别，间隙锁之间是兼容的，即两个事务可以同时持有包含共同间隙范围的间隙锁，并不存在互斥关系，因为间隙锁的目的是防止插入幻影记录而提出的 。
什么时候会加间隙锁? 当我们用唯一索引进行等值查询的时候，查询的记录不存在的时候，在索引树找到第一条大于该查询记录的记录后，将该记录的索引中的 next-key lock 会退化成「间隙锁」 。
假设事务 A 执行了这条等值查询语句，查询的记录是「不存在」于表中的。
mysql> begin ;select * from user where id = 2 for update ;set (0.03 sec)接下来，通过 select * from performance_schema.data_locks\G; 这条语句，查看事务执行 SQL 过程中加了什么锁。
img 从上图可以看到，共加了两个锁，分别是：
因此，此时事务 A 在 id = 5 记录的主键索引上加的是间隙锁，锁住的范围是 (1, 5)。
img 接下来，如果有其他事务插入 id 值为 2、3、4 这一些记录的话，这些插入语句都会发生阻塞。
注意，如果其他事务插入的 id = 1 或者 id = 5 的记录话，并不会发生阻塞，而是报主键冲突的错误，因为表中已经存在 id = 1 和 id = 5 的记录了。
比如，下面这个例子：
img 因为事务 A 在 id = 5 记录的主键索引上加了范围为 (1, 5) 的 X 型间隙锁，所以事务 B 在插入一条 id 为 3 的记录时会被阻塞住，即无法插入 id = 3 的记录。
MySQL 如何保证原子性? 通过 undo log 来保证原子性的。
undo log 是一种用于撤销回退的日志。在事务没提交之前，MySQL 会先记录更新前的数据到 undo log 日志文件里面，当事务回滚时，可以利用 undo log 来进行回滚。如下图：
回滚事务 undo log 撤销过程具体是怎么撤销的? 每当 InnoDB 引擎对一条记录进行操作（修改、删除、新增）时，要把回滚时需要的信息都记录到 undo log 里，比如：
在插入 一条记录时，要把这条记录的主键值记下来，这样之后回滚时只需要把这个主键值对应的记录删掉 就好了； 在删除 一条记录时，要把这条记录中的内容都记下来，这样之后回滚时再把由这些内容组成的记录插入 到表中就好了； 在更新 一条记录时，要把被更新的列的旧值记下来，这样之后回滚时再把这些列更新为旧值 就好了。 在发生回滚时，就读取 undo log 里的数据，然后做原先相反操作。比如当 delete 一条记录时，undo log 中会把记录中的内容都记下来，然后执行回滚操作的时候，就读取 undo log 里的数据，然后进行 insert 操作。
怎么决定建立哪些索引? 什么时候适用索引？
经常用于 WHERE 查询条件的字段，这样能够提高整个表的查询速度，如果查询条件不是一个字段，可以建立联合索引。 经常用于 GROUP BY 和 ORDER BY 的字段，这样在查询的时候就不需要再去做一次排序了，因为我们都已经知道了建立索引之后在 B+Tree 中的记录都是排序好的。 什么时候不需要创建索引？
WHERE 条件，GROUP BY，ORDER BY 里用不到的字段，索引的价值是快速定位，如果起不到定位的字段通常是不需要创建索引的，因为索引是会占用物理空间的。字段中存在大量重复数据，不需要创建索引，比如性别字段，只有男女，如果数据库表中，男女的记录分布均匀，那么无论搜索哪个值都可能得到一半的数据。在这些情况下，还不如不要索引，因为 MySQL 还有一个查询优化器，查询优化器发现某个值出现在表的数据行中的百分比很高的时候，它一般会忽略索引，进行全表扫描。 经常更新的字段不用创建索引，比如不要对电商项目的用户余额建立索引，因为索引字段频繁修改，由 最左匹配是什么，举个例子？ 使用联合索引时，存在最左匹配原则 ，也就是按照最左优先的方式进行索引的匹配。在使用联合索引进行查询的时候，如果不遵循「最左匹配原则」，联合索引会失效，这样就无法利用到索引快速查询的特性了。
比如，如果创建了一个 (a, b, c) 联合索引，如果查询条件是以下这几种，就可以匹配上联合索引：
where a=1 and b=2 and c=3； 需要注意的是，因为有查询优化器，所以 a 字段在 where 子句的顺序并不重要。
但是，如果查询条件是以下这几种，因为不符合最左匹配原则，所以就无法匹配上联合索引，联合索引就会失效:
上面这些查询条件之所以会失效，是因为(a, b, c) 联合索引，是先按 a 排序，在 a 相同的情况再按 b 排序，在 b 相同的情况再按 c 排序。所以，b 和 c 是全局无序，局部相对有序的 ，这样在没有遵循最左匹配原则的情况下，是无法利用到索引的。
我这里举联合索引（a，b）的例子，该联合索引的 B+ Tree 如下（图中叶子节点之间我画了单向链表，但是实际上是双向链表，原图我找不到了，修改不了，偷个懒我不重画了，大家脑补成双向链表就行）。
img 可以看到，a 是全局有序的（1, 2, 2, 3, 4, 5, 6, 7 ,8），而 b 是全局是无序的（12，7，8，2，3，8，10，5，2）。因此，直接执行where b = 2这种查询条件没有办法利用联合索引的，利用索引的前提是索引里的 key 是有序的 。
只有在 a 相同的情况才，b 才是有序的，比如 a 等于 2 的时候，b 的值为（7，8），这时就是有序的，这个有序状态是局部的，因此，执行where a = 2 and b = 7是 a 和 b 字段能用到联合索引的，也就是联合索引生效了。
Java Java 里面线程有哪些状态? 源自《Java并发编程艺术》 java.lang.Thread.State枚举类中定义了六种线程的状态，可以调用线程Thread中的getState()方法获取当前线程的状态 。
线程状态 解释 NEW 尚未启动的线程状态，即线程创建，还未调用start方法 RUNNABLE 就绪状态 （调用start，等待调度）+正在运行 BLOCKED 等待监视器锁 时，陷入阻塞状态WAITING 等待状态的线程正在等待 另一线程执行特定的操作（如notify） TIMED_WAITING 具有指定等待时间 的等待状态 TERMINATED 线程完成执行，终止状态
wait 状态下的线程如何进行恢复到 running 状态? 等待的线程被其他线程对象唤醒 ，notify()和notifyAll()。 如果线程没有获取到锁则会直接进入 Waiting 状态，其实这种本质上它就是执行了 LockSupport.park() 方法进入了Waiting 状态，那么解锁的时候会执行LockSupport.unpark(Thread)，与上面park方法对应，给出许可证，解除等待状态 。 notify 和 notifyAll 的区别? 同样是唤醒等待的线程，同样最多只有一个线程能获得锁，同样不能控制哪个线程获得锁。
区别在于：
notify：唤醒一个线程，其他线程依然处于wait的等待唤醒状态，如果被唤醒的线程结束时没调用notify，其他线程就永远没人去唤醒，只能等待超时，或者被中断 notifyAll：所有线程退出wait的状态，开始竞争锁，但只有一个线程能抢到，这个线程执行完后，其他线程又会有一个幸运儿脱颖而出得到锁 notify 选择哪个线程? notify在源码的注释中说到notify选择唤醒的线程是任意的，但是依赖于具体实现的jvm。
notify源码 JVM有很多实现，比较流行的就是hotspot，hotspot对notofy()的实现并不是我们以为的随机唤醒,，而是“先进先出”的顺序唤醒。
如何停止一个线程的运行? 主要有这些方法：
异常法停止 ：线程调用interrupt()方法后，在线程的run方法中判断当前对象的interrupted()状态，如果是中断状态则抛出异常，达到中断线程的效果。在沉睡中停止 ：先将线程sleep，然后调用interrupt标记中断状态，interrupt会将阻塞状态的线程中断。会抛出中断异常，达到停止线程的效果stop()暴力停止 ：线程调用stop()方法会被暴力停止，方法已弃用，该方法会有不好的后果：强制让线程停止有可能使一些请理性的工作得不到完成。使用return停止线程 ：调用interrupt标记为中断状态后，在run方法中判断当前线程状态，如果为中断状态则return，能达到停止线程的效果。调用 interrupt 是如何让线程抛出异常的? 每个线程都一个与之关联的布尔属性来表示其中断状态，中断状态的初始值为false，当一个线程被其它线程调用Thread.interrupt()方法中断时，会根据实际情况做出响应。
如果该线程正在执行低级别的可中断方法（如Thread.sleep()、Thread.join()或Object.wait()），则会解除阻塞并抛出InterruptedException异常 。 否则Thread.interrupt()仅设置线程的中断状态，在该被中断的线程中稍后可通过轮询中断状态来决定是否要停止当前正在执行的任务。 如果是靠变量来停止线程，缺点是什么? 缺点是中断可能不够及时，循环判断时会到下一个循环才能判断出来。
class InterruptFlag // 自定义的中断标识符 private static volatile boolean isInterrupt = false ;public static void main (String[] args) throws InterruptedException // 创建可中断的线程实例 new Thread(() -> {while (!isInterrupt) { // 如果 isInterrupt=true 则停止线程 "thread 执行步骤1：线程即将进入休眠状态" );try {// 休眠 1s 1000 );catch (InterruptedException e) {"thread 执行步骤2：线程执行了任务" );// 启动线程 // 休眠 100ms，等待 thread 线程运行起来 100 );"主线程：试图终止线程 thread" );// 修改中断标识符，中断线程 true ;当终止线程后，执行步骤2依然会被执行，这就是缺点。
volatile 保证原子性吗？ volatile关键字并没有保证我们的变量的原子性，volatile是Java虚拟机提供的一种轻量级的同步机制，主要有这三个特性：
那我们要如何保证原子性? 可以通过synchronized来保证原子性。
synchronized 支持重入吗？如何实现的? synchronized是基于原子性的内部锁机制，是可重入的，因此在一个线程调用synchronized方法的同时在其方法体内部调用该对象另一个synchronized方法，也就是说一个线程得到一个对象锁后再次请求该对象锁，是允许的，这就是synchronized的可重入性。
synchronized底层是利用计算机系统mutex Lock实现的。每一个可重入锁都会关联一个线程ID和一个锁状态status。
当一个线程请求方法时，会去检查锁状态。
如果锁状态是0，代表该锁没有被占用，使用CAS操作获取锁，将线程ID替换成自己的线程ID。 如果锁状态不是0，代表有线程在访问该方法。此时，如果线程ID是自己的线程ID，如果是可重入锁，会将status自增1，然后获取到该锁，进而执行相应的方法；如果是非重入锁，就会进入阻塞队列等待。 在释放锁时，
如果是可重入锁的，每一次退出方法，就会将status减1，直至status的值为0，最后释放该锁。 如果非可重入锁的，线程退出方法，直接就会释放该锁。 网络 HTTP 与 HTTPS 协议的区别？ HTTP 与 HTTPS 网络层 HTTP 是超文本传输协议，信息是明文传输，存在安全风险的问题。HTTPS 则解决 HTTP 不安全的缺陷，在 TCP 和 HTTP 网络层之间加入了 SSL/TLS 安全协议，使得报文能够加密传输。 HTTP 连接建立相对简单， TCP 三次握手之后便可进行 HTTP 的报文传输。而 HTTPS 在 TCP 三次握手之后，还需进行 SSL/TLS 的握手过程，才可进入加密报文传输。 两者的默认端口不一样，HTTP 默认端口号是 80，HTTPS 默认端口号是 443。 HTTPS 协议需要向 CA（证书权威机构）申请数字证书，来保证服务器的身份是可信的。 操作系统 有哪些进程调度算法 ? 01 先来先服务调度算法
最简单的一个调度算法，就是非抢占式的先来先服务（*First Come First Serve, FCFS*）算法 了。
FCFS 调度算法 顾名思义，先来后到，每次从就绪队列选择最先进入队列的进程，然后一直运行，直到进程退出或被阻塞，才会继续从队列中选择第一个进程接着运行。
这似乎很公平，但是当一个长作业先运行了，那么后面的短作业等待的时间就会很长，不利于短作业。
FCFS 对长作业有利，适用于 CPU 繁忙型作业的系统，而不适用于 I/O 繁忙型作业的系统。
02 最短作业优先调度算法
最短作业优先（*Shortest Job First, SJF*）调度算法 同样也是顾名思义，它会优先选择运行时间最短的进程来运行 ，这有助于提高系统的吞吐量。
SJF 调度算法 这显然对长作业不利，很容易造成一种极端现象。
比如，一个长作业在就绪队列等待运行，而这个就绪队列有非常多的短作业，那么就会使得长作业不断的往后推，周转时间变长，致使长作业长期不会被运行。
03 高响应比优先调度算法
前面的「先来先服务调度算法」和「最短作业优先调度算法」都没有很好的权衡短作业和长作业。
那么，高响应比优先 （*Highest Response Ratio Next, HRRN*）调度算法 主要是权衡了短作业和长作业。
每次进行进程调度时，先计算「响应比优先级」，然后把「响应比优先级」最高的进程投入运行 ，「响应比优先级」的计算公式：
img 从上面的公式，可以发现：
如果两个进程的「等待时间」相同时，「要求的服务时间」越短，「响应比」就越高，这样短作业的进程容易被选中运行； 如果两个进程「要求的服务时间」相同时，「等待时间」越长，「响应比」就越高，这就兼顾到了长作业进程，因为进程的响应比可以随时间等待的增加而提高，当其等待时间足够长时，其响应比便可以升到很高，从而获得运行的机会； 04 时间片轮转调度算法
最古老、最简单、最公平且使用最广的算法就是时间片轮转（*Round Robin, RR*）调度算法 。
RR 调度算法 每个进程被分配一个时间段，称为时间片（*Quantum*），即允许该进程在该时间段中运行。
如果时间片用完，进程还在运行，那么将会把此进程从 CPU 释放出来，并把 CPU 分配给另外一个进程； 如果该进程在时间片结束前阻塞或结束，则 CPU 立即进行切换； 另外，时间片的长度就是一个很关键的点：
如果时间片设得太短会导致过多的进程上下文切换，降低了 CPU 效率； 如果设得太长又可能引起对短作业进程的响应时间变长。将 一般来说，时间片设为 20ms~50ms 通常是一个比较合理的折中值。
05 最高优先级调度算法
前面的「时间片轮转算法」做了个假设，即让所有的进程同等重要，也不偏袒谁，大家的运行时间都一样。
但是，对于多用户计算机系统就有不同的看法了，它们希望调度是有优先级的，即希望调度程序能从就绪队列中选择最高优先级的进程进行运行，这称为最高优先级（*Highest Priority First，HPF*）调度算法 。
进程的优先级可以分为，静态优先级和动态优先级：
静态优先级：创建进程时候，就已经确定了优先级了，然后整个运行时间优先级都不会变化； 动态优先级：根据进程的动态变化调整优先级，比如如果进程运行时间增加，则降低其优先级，如果进程等待时间（就绪队列的等待时间）增加，则升高其优先级，也就是随着时间的推移增加等待进程的优先级 。 该算法也有两种处理优先级高的方法，非抢占式和抢占式：
非抢占式：当就绪队列中出现优先级高的进程，运行完当前进程，再选择优先级高的进程。 抢占式：当就绪队列中出现优先级高的进程，当前进程挂起，调度优先级高的进程运行。 但是依然有缺点，可能会导致低优先级的进程永远不会运行。
06 多级反馈队列调度算法
多级反馈队列（*Multilevel Feedback Queue*）调度算法 是「时间片轮转算法」和「最高优先级算法」的综合和发展。
顾名思义：
「多级」表示有多个队列，每个队列优先级从高到低，同时优先级越高时间片越短。 「反馈」表示如果有新的进程加入优先级高的队列时，立刻停止当前正在运行的进程，转而去运行优先级高的队列； 多级反馈队列 来看看，它是如何工作的：
设置了多个队列，赋予每个队列不同的优先级，每个队列优先级从高到低 ，同时优先级越高时间片越短 ； 新的进程会被放入到第一级队列的末尾，按先来先服务的原则排队等待被调度，如果在第一级队列规定的时间片没运行完成，则将其转入到第二级队列的末尾，以此类推，直至完成； 当较高优先级的队列为空，才调度较低优先级的队列中的进程运行。如果进程运行时，有新进程进入较高优先级的队列，则停止当前运行的进程并将其移入到原队列末尾，接着让较高优先级的进程运行； 可以发现，对于短作业可能可以在第一级队列很快被处理完。对于长作业，如果在第一级队列处理不完，可以移入下次队列等待被执行，虽然等待的时间变长了，但是运行时间也变更长了，所以该算法很好的兼顾了长短作业，同时有较好的响应时间。
算法 给定链表 1 -> 2 -> ... -> n-1 -> n，使用 O(1) 空间复杂度使其变为 1 -> n -> 2 -> n-1 -> ... 只记得有关滑动窗口，应该是力扣 TOP 100 的 为了帮助想要尝试做副业的朋友们，小灰撰写了一份电子小册，分享自己8年的自媒体经验，有兴趣的小伙伴欢迎扫码订阅：
