DD——运维开发准备

一
- 4 linux用的什么版本，常见命令（awk sed grep telnet netstate tcpdump top ps perf）
- 5 数据库有哪些类型，关系型数据库有哪些，非关系型数据库有哪些
- 6 mysql事务
- 7 mysql集群了解多少
- 8 redis数据类型
- 9 缓存数据一致性问题
- 10 用过哪些语言（回答go，c，python），讲讲各自有哪些特性和区别
- 11 go并发编程的了解
- 12 restful风格含义
- 13 你的项目中有没有调用过其他系统的open api经验，（可能想问这方面的问题，我没有过，面试官解释了一番）
- 14 k8s中etcd作用
二
- 1.查看操作系统各个硬件的使用情况
- 2.Nginx和LVS负载均衡的区别
- 3.如何应对ack攻击（如何知道这是ack攻击，从哪些方面得出？）
- 4.查看系统配置（几核等等）
- 5.docker给企业带来的好处（如在一核的服务器中跑docker和虚拟机的差异）
- 6.开发一个五分钟之内发放五百万优惠券的系统，要求在多台服务器上负载均衡（使用队列）
- 7.装饰器的作用，多个装饰器运行的顺序
- 8.监控程序（如普罗米修斯，zabbix）的数据源从哪里来
- 9.如何开机自启自己写的服务？
- 10.如何查看进程的资源使用情况
- 11.tcp、udp的区别
- 12.如何知道自己的系统上有多少块硬盘
- 13.说说对递归的理解
- 14.swap分区的作用，如何关闭？
- 17.给一个数组，统计重复数字
- 19.协程和线程的区别
三
- 4.一个情景下多线程的设计
- 5.敲个99乘法表
- 3.10分钟时间，不定长字符串数组中找公共后缀（abcbcd zxcbcd kmibcd 这种最后找到bcd就好，时间很短，没有自动填充，打字要快，思路要清楚）
- 4.10分钟时间，输入一周股价，算出买入卖出的最大利润，（典型DP问题）
- 5.一个高并发的题（可以只说思路）
- - 1.什么是高并发？
  - 2.如何衡量系统的并发能力？
  - 3.什么是负载均衡？
  - 4.什么是分布式缓存？
  - 5.数据库连接池的作用是什么？
  - 6.如何处理并发写入？
  - 7.CAP定理是什么？
  - 8.什么是分布式锁？
  - 9.怎么解决热点访问问题？
  - 10.说说消息队列的用途和优势。
  - 11.什么是悲观锁和乐观锁？
  - 12.如何保证数据一致性？
  - 13.什么是无锁编程？
  - 何进行系统水平的扩展？
  - 什么是反向代理和CDN？
  - 反向代理和正向代理
- 6.一个遥控器，说说如何优化（开放题）
- - 2 谈谈遇到不公平待遇怎么办
  - 3.谈如何处理压力
  - 8.深刻理解分布式系统架构，大规模并发处理技术
- 企业

一

1 面试官自我介绍
2 自我介绍
3 项目相关问题

4 linux用的什么版本，常见命令（awk sed grep telnet netstate tcpdump top ps perf）

1.文件和目录：touch、mkdir、rm、gedit、vim、cat、less、head、tail、cp
mv、wc；字符集和表示方法：[]模糊匹配、{}点名机制。
2.进程：
程序是静态的代码文件；进程是指程序运行时的形态
进程是程序的一个副本(copy程序到内存，相当于副本)
进程是有生命周期的
准备期：准备资源(类似于执行“打扫教室任务”前，“拿扫把”)
运行期：执行过程
终止期：执行后程序所占用的系统资源被回收
进程和线程
进程：进程是资源调用的最小单位。所有事件由cpu处理，当一个事件cpu，其他事件就无法占用处于，等待用完才可以使用cpu；
双核、三核cpu：为使充分使用cpu，一个事件细划分成若干个小的线程，加速cpu同时处理；
线程是进程的最小单位。

程序执行流是从上到下贯穿运行的
当进程是多任务，cpu是多核心时，多任务应该同时被每个核心处理，每个核心处理的任务叫线程资源。线程资源是共享的

进程状态：
R(TASK_RUNNING) ##可执行态：正在被cpu处理，或已经加载好等待被cpu处理
S(TASK_INTRRUPTABLE) ##可唤醒休眠：使用cpu超时，进入休眠，再次使用时需要被激活
D(TASK_UNINTRRUPTABLE) ##不可唤醒休眠：使用cpu超时，仍有资源没有被加载好，不可以使用cpu
T(TASK_STOP) ##暂停状态：关闭无法使用程序，但可以人为唤醒
Z(EXIT_ZOMBLE) ##僵死态：进程已经结束，却占用资源不放，需要手动结束程序。“bug”
ps #进程查看
ps 命令的三种执行风格 unix bsd GNU
##unix##
ps a #与终端相关的，带字符终端的进程(当用户登陆系统后产生的进程都是带终端)
ps x #与终端无关的，不带字符终端的进程(除了某些有依赖关系的，其余都是?)
ps u #用户信息归类的查看方式
ps f #进程层级关系
ps o #显示指定参数，如pid comm nice pri pcpu ppid stat,user,group
ps -e 显示所有进程
ps -f 显示信息的完整格式
ps -H 显示进程的层级结构
ps -o 显示指定参数
ps --sort= (如cpu排序、内存排序) - sort=为倒序

ps ax 显示信息如下：
PID 进程id、TTY 进程用到的终端、STAT 进程状态、TIME 进程占用cpu时长
COMMAND 进程名称。
ps aux 显示信息如下：
USER 进程所有人、PID 进程id、%CPU 进程使用cpu的用量、%MEM 进程所用到的内存用量、VSZ 进程使用的虚拟内存大小、RSS 进程常驻内存中的数据大小、TTY 进程用到的终端、STAT 进程状态、START 进程运行时长、TIME 进程占用CPU时长、COMMAND 进程名称。

pgrep #进程过滤
pgrep -u ##uid 显示指定用户进程
pgrep -U ##user 显示指定用户进程
pgrep -t ##tty 显示指定终端进程
pgrep -l ##显示进程名称
pgrep -a ##显示进程的完整名称
pgrep -P ##显示进程的子进程
pidof vim ##查看vim命令进程的pid

top ##动态进程查看
top命令的参数
-d 指定刷新频率(默认3秒刷新)，停留； -b 以批次方式显示(默认刷新2批次)，退出；-n 指定显示的批次数量；-b -n 3 指定3批次刷新。
在这里插入图片描述
系统是多任务多用户的操作模式
任务的重要性是有区分的
如何确定任务的重要性——“优先级” 范围：0–139 (共140个优先级)
内核自控优先级范围：0–99
用户可控优先级：100–139
nice -20 ~ 19
##linux系统中nice值——优先级的另一种说法：系统可控优先级的值
##普通用户优先级只能调低不能调高

进程前后台调用
##查看进程状态 stat
Ctrl +Z ##把占用shell的进程打入后台挂起
bg ##把后台挂起的进程运行起来
fg ##把后台进程调回前台
& ##运行进程在后台
jobs ##查看当前shell中在后台的所有工作

进程信息号
man 7 signal
1 ##重新读取加载系统配置文件（source）
2 ##清空内存中的进程数据
3 ##清空内存中的鼠标（Ctrl +\）
9 ##强制结束进程（不能被阻塞）
15 ##正常关闭进程（会被阻塞），无法强制关闭子程序，关闭shell会被阻塞
18 ##被暂停的进程运行起来
19 ##暂停进程（不会被阻塞）
20 ##暂停进程（会被阻塞的）

进程信号控制工具
kill 进程信号 pid
killall 进程信号进程名字
pkill 进程信号进程条件
killall ##结束某一进程或命令
pkill ##指定结束某一用户及所有进程

systemd守护进程
守护进程替内核分担程序管控的程序，通常pid为1 (类似于总经理之于董事长，控制服务型软件)
服务器s：对外提供某种功能，共享型软件
systemd -------->systemctl
systemctl 管理系统服务
服务指在系统中开启的共享系统资源到网络中的程序 cs client ------- server
在这里插入图片描述

5 数据库有哪些类型，关系型数据库有哪些，非关系型数据库有哪些

数据库可以根据不同的分类方式进行分类。常见的分类方式包括数据库类型、数据模型以及数据库管理系统（DBMS）等。以下是根据数据库类型分类的一些主要类型：
根据数据库类型分类：
关系型数据库（Relational Database）：以表格形式存储数据，使用结构化查询语言（SQL）进行数据管理和查询。常见的关系型数据库有：
MySQL
PostgreSQL
Oracle Database
Microsoft SQL Server
SQLite
非关系型数据库（NoSQL Database）：采用灵活的数据模型，适用于处理大量非结构化或半结构化数据。常见的非关系型数据库类型包括：常见的有：NoSql、Cloudant、MongoDB、redis、HBase
文档型数据库（Document Database）：如MongoDB、Couchbase
键值型数据库（Key-Value Store）：如Redis、Amazon DynamoDB
列族型数据库（Column-family Database）：如Apache Cassandra、HBase
图形数据库（Graph Database）：如Neo4j、Amazon Neptune
时间序列数据库（Time Series Database）：如InfluxDB、OpenTSDB
新SQL数据库：一种介于传统关系型数据库和NoSQL数据库之间的数据库类型，旨在提供更好的水平扩展性和性能。例如：CockroachDB、NuoDB。
内存数据库（In-Memory Database）：将数据存储在内存中，以提供更快的读写性能。例如：Redis、MemSQL。
综合型数据库（Hybrid Database）：结合了关系型和非关系型数据库的特点，可同时处理结构化和非结构化数据。
文件型数据库：将数据以文件的形式进行存储，适用于一些特定的应用场景。
对象数据库（Object Database）：用于存储对象，适合面向对象编程模型。
XML数据库：专门用于存储和查询XML文档的数据库类型。
这只是数据库分类的一些常见类型，还有许多其他特定用途的数据库类型。
关系型数据库和非关系型数据库是两大主要的数据库范式。关系型数据库使用表格来存储数据，而非关系型数据库使用不同的数据模型来存储数据。在关系型数据库中，数据之间的关系由外键等约束来维护，而在非关系型数据库中，数据之间的关系可以更加灵活。

关系型数据库的特性
1、关系型数据库，是指采用了关系模型来组织数据的数据库；
2、关系型数据库的最大特点就是事务的一致性；
3、简单来说，关系模型指的就是二维表格模型，而一个关系型数据库就是由二维表及其之间的联系所组成的一个数据组织。
关系型数据库的优点、缺点
1、容易理解：二维表结构是非常贴近逻辑世界一个概念，关系模型相对网状、层次等其他模型来说更容易理解；2、使用方便：通用的SQL语言使得操作关系型数据库非常方便；3、易于维护：丰富的完整性(实体完整性、参照完整性和用户定义的完整性)大大减低了数据冗余和数据不一致的概率；4、支持SQL，可用于复杂的查询。
1、为了维护一致性所付出的巨大代价就是其读写性能比较差；2、固定的表结构；3、高并发读写需求；4、海量数据的高效率读写；
对于非关系型数据库——非关系型数据库的特性
1、使用键值对存储数据；
2、分布式；
3、一般不支持ACID特性；
4、非关系型数据库严格上不是一种数据库，应该是一种数据结构化存储方法的集合。
非关系型数据库的优点、缺点
1、无需经过sql层的解析，读写性能很高；2、基于键值对，数据没有耦合性，容易扩展；3、存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等，文档形式、图片形式等等，而关系型数据库则只支持基础类型。
1、不提供sql支持，学习和使用成本较高；2、无事务处理，附加功能bi和报表等支持也不好；
关系型数据库具有数据安全且容易理解的优点, 但是随着互联网的发展,数据存储越来越多, 对于并发的要求也越来越高,项目中单纯使用关系型数据库已经无法满足这些要求, 于是应运而生了非关系型数据库.
非关系型数据库具有格式灵活, 成本低, 查询快, 高性能, 高扩展的优点.

6 mysql事务

MySQL是一种常见的关系型数据库管理系统，支持事务处理以确保数据的一致性、隔离性、持久性和原子性（通常称为ACID属性）。事务是一组SQL操作的逻辑单元，要么全部执行成功，要么全部回滚，以保证数据在数据库中的正确性和完整性。
以下是关于MySQL事务的一些重要概念和操作：

事务特性（ACID）：
原子性（Atomicity）：事务中的操作被视为单个不可分割的操作。要么全部执行成功，要么全部失败回滚。
一致性（Consistency）：事务开始和结束时，数据的状态应保持一致。事务执行过程中可能会改变数据状态，但最终结果必须符合数据库的规则。
隔离性（Isolation）：事务的执行在逻辑上是隔离的，即一个事务的操作在提交之前对其他事务是不可见的。
持久性（Durability）：一旦事务提交，其结果将持久保存在数据库中，即使发生系统故障也不会丢失。
事务控制语句：
BEGIN 或 START TRANSACTION：开始一个事务。
COMMIT：提交事务，使之生效。
ROLLBACK：回滚事务，撤销未提交的操作。
SAVEPOINT 和 ROLLBACK TO SAVEPOINT：创建和回滚到保存点，用于在事务中部分回滚。
自动提交：
默认情况下，MySQL以自动提交模式运行，即每个SQL语句都被视为一个独立的事务，立即生效。可以使用SET AUTOCOMMIT = 0来禁用自动提交，从而将多个语句组合成一个事务。
事务隔离级别：
MySQL支持不同的事务隔离级别，用于控制事务之间的可见性和并发操作。常见的隔离级别包括：READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ 和 SERIALIZABLE。
并发控制：
MySQL使用锁机制来实现并发控制，以确保多个事务之间的数据一致性。不同的隔离级别会影响锁的获取和释放策略，从而影响事务的隔离性和性能。

在MySQL中，正确使用事务能够确保数据的完整性和一致性，尤其在多用户并发操作的环境中更为重要。了解事务的概念和使用方法，以及选择合适的隔离级别，对于开发和维护应用程序的数据库操作至关重要。
MySQL支持四种事务隔离级别，这些隔离级别定义了事务之间的可见性和并发操作行为。不同的隔离级别提供了不同的权衡，以适应不同的应用场景。以下是MySQL支持的四种事务隔离级别：

READ UNCOMMITTED（读未提交）：
最低的隔离级别。允许事务读取其他事务尚未提交的数据，可能导致"脏读"问题（读取到未提交的数据）。事务间没有任何隔离，可能导致数据的不一致性。
READ COMMITTED（读已提交）：
默认隔离级别。允许事务只读取已经提交的数据，但在同一事务内，多次读取可能会看到不同的结果（不可重复读）。可避免脏读问题，但仍可能出现不可重复读的情况。
REPEATABLE READ（可重复读）：
在同一事务内，多次读取同一数据会得到一致的结果，即使其他事务对数据进行了修改。阻止了不可重复读问题，但在某些情况下仍可能出现幻读问题（读到其他事务插入的新数据）。默认情况下，MySQL使用的就是这个隔离级别。
SERIALIZABLE（串行化）：
最高的隔离级别，也是最严格的隔离级别。强制事务串行执行，确保每个事务都在其他事务之前完成。避免了幻读问题，但在并发较高的情况下，可能导致性能下降。
随着隔离级别的逐渐升高，事务的可见性和并发性能都会有所不同。选择适当的隔离级别取决于应用的需求，需要在数据一致性和性能之间进行权衡。在某些情况下，可以使用表级别的锁或行级别的锁来进一步控制并发。

7 mysql集群了解多少

MySQL集群是一种将多个MySQL数据库服务器连接在一起的架构，旨在提供高可用性、负载均衡、容错性和扩展性。MySQL集群的目标是通过复制、分片和其他技术来实现数据的分布和管理，从而提高整个系统的性能和可用性。
有几种常见的MySQL集群架构：

主从复制（Master-Slave Replication）：
在主从复制架构中，一个MySQL数据库被配置为主服务器（Master），而其他服务器则是从服务器（Slave）。主服务器负责写入数据，而从服务器复制主服务器的数据以实现读取负载均衡和冗余备份。主从复制提供了简单的故障恢复和读取扩展，但写入操作仍然限制在主服务器上。
主主复制（Master-Master Replication）：
在主主复制架构中，两个MySQL服务器都可以扮演主服务器和从服务器的角色。这使得写入操作可以在两个服务器之间进行分流，从而提高写入性能。主主复制通常需要解决冲突问题，例如同时在两个服务器上进行写入可能导致数据不一致。
MySQL分片（Sharding）：
分片是将数据分割成多个片段，每个片段存储在独立的MySQL服务器上。这种方法可以水平扩展数据库以处理大量数据。分片需要应用程序在逻辑上处理数据分布和路由问题，并且可能需要处理全局唯一标识等挑战。
Galera集群：
Galera是一个支持多主复制的集群架构，允许多个MySQL节点同时进行写入操作。Galera使用同步复制来确保数据的一致性，但也可能对性能产生影响。它适用于需要高写入性能和高可用性的场景。
MySQL Group Replication：
MySQL Group Replication是MySQL官方提供的一种集群解决方案，支持多主复制和自动故障切换。它使用了Paxos协议来实现数据同步和一致性。
无论选择哪种MySQL集群架构，都需要根据应用的需求和复杂性做出权衡。集群架构可以提供高可用性和性能，但也需要考虑数据一致性、故障恢复、监控和管理等方面的问题。

8 redis数据类型

Redis（Remote Dictionary Server）是一种快速的开源内存数据存储系统，支持多种数据结构。以下是Redis支持的主要数据类型：

1.字符串（String）：存储字符串、整数、浮点数等数据。可以进行字符串连接、追加、获取子串等操作。常用于缓存、计数器等场景。
2.哈希（Hash）：存储字段-值对的映射，类似于关联数组或散列。可以单独获取、设置、删除哈希中的字段值。常用于存储对象的属性。
3.列表（List）：存储有序的字符串元素，可在列表的两端进行插入和弹出操作。支持按索引获取元素，可以进行范围操作，如分页。常用于实现队列、栈等数据结构。
4.集合（Set）：存储唯一、无序的字符串元素。支持集合的交、并、差等操作。常用于去重、判定元素是否存在等。
5.有序集合（Sorted Set）：类似于集合，每个元素关联一个分数（score），用于排序元素。支持按分数范围获取元素、获取排名等操作。常用于排行榜、带有权重的数据。
6.位图（Bitmap）：存储位的数据结构，支持位操作，如AND、OR、XOR等。常用于处理大规模的标志位，如统计在线用户。
7.HyperLogLog：用于进行基数估算（估计集合中不同元素的数量）的数据结构。占用固定的内存空间，用于节省内存。
8.地理空间（Geospatial）：存储地理坐标点，支持计算坐标之间的距离和范围查询。常用于地理位置相关应用，如附近的人、地点检索。
Redis的多样数据类型使其适用于不同的应用场景，从缓存到计数器、消息队列以及数据分析等。不同的数据类型提供了不同的功能和性能特点，开发人员可以根据应用的需求选择合适的数据类型。

9 缓存数据一致性问题

缓存数据一致性问题是指在使用缓存系统（如Redis、Memcached）的情况下，由于缓存和数据库之间的数据更新可能发生不一致性，导致应用程序读取到不正确的数据。解决缓存数据一致性问题是确保缓存中的数据与底层数据源（通常是数据库）保持一致的重要问题。
以下是一些常见的缓存数据一致性问题以及对应的解决方法：

缓存雪崩：
当缓存中的大量数据同时失效，导致大量请求直接击中数据库，造成数据库压力过大，甚至崩溃。
解决方法：使用不同的缓存过期时间，或者采用热点数据预加载等方法。
缓存穿透：
请求的数据在缓存和数据库中都不存在，导致大量请求直接访问数据库，降低性能。
解决方法：在缓存中存储空值，或者使用布隆过滤器等方法过滤不存在的数据请求。
缓存击穿：
某个热点数据失效，导致大量请求同时访问数据库，造成数据库压力。
解决方法：在热点数据失效时使用互斥锁或分布式锁来防止并发访问数据库，同时重新加载缓存。
数据写入不一致：
当数据发生更新时，缓存和数据库的数据不一致，导致读取到过期或错误的数据。
解决方法：在更新数据库时同时更新缓存，或者使用缓存失效策略来保证一致性。
缓存数据过期与数据更新不同步：
缓存数据过期后，数据源（数据库）的数据已经更新，但缓存中的数据还是旧数据。
解决方法：使用定时任务或消息队列，定期或异步地更新缓存，确保缓存中的数据与数据源保持同步。
多级缓存一致性：
在使用多级缓存时，不同级别的缓存之间的数据一致性可能会受到影响。
解决方法：采用缓存失效策略、更新通知机制、缓存中间件等方法来维护多级缓存的一致性。
解决缓存数据一致性问题需要根据具体情况选择合适的策略和技术。通常，可以使用缓存失效策略、缓存更新机制、分布式锁、事务等手段来保证缓存与数据源之间的一致性。

10 用过哪些语言（回答go，c，python），讲讲各自有哪些特性和区别

Go、C和Python是三种不同的编程语言，各自具有不同的特性和用途。以下是它们的主要特性和一些区别：
Go（也称为Golang）：
Go是由Google开发的编程语言，旨在提供高效的性能和简洁的语法。
特点：并发支持内置在语言中，通过goroutines和channels实现轻量级并发；垃圾回收机制帮助管理内存；静态类型系统提供类型安全性；编译速度快，生成的二进制文件较小；支持自动内存分配和释放。
适用领域：网络编程、后端服务、系统编程、分布式系统等。
C：
C是一种通用的编程语言，广泛用于系统编程和低级别的开发。
特点：低级别的编程，对计算机硬件直接操作的能力；强大的性能和内存控制；面向过程的编程风格；标准库较小，需要使用外部库来实现高级功能。
适用领域：系统级编程、嵌入式系统、操作系统、驱动程序等。
Python：
Python是一种高级编程语言，强调代码的可读性和简洁性。
特点：易于学习和使用，具有清晰简洁的语法；动态类型系统，无需显式声明变量类型；丰富的标准库和第三方库；适合快速开发和原型设计；多范式支持，包括面向对象、函数式编程等。
适用领域：Web开发、数据分析、科学计算、人工智能、自动化脚本等。
区别：
性能和控制：Go和C通常具有更好的性能，适用于需要高效率和低级别控制的场景。Python则在性能上通常较慢，但易于使用和编写。
并发和并行：Go在语言级别支持并发，使得编写并发代码更加简单。C也可以进行并发编程，但需要更多的手动管理。Python也有并发库，但通常需要使用全局解释器锁（GIL），在多核情况下限制了多线程的并行性。
语法：Go和Python都以简洁、清晰的语法著称，使得代码易于阅读和维护。C语法较为底层，需要更多的操作和控制。
应用领域：Go适用于后端服务、网络编程等高并发场景。C适用于系统级开发和性能要求较高的场景。Python适用于快速原型设计、数据处理、脚本编写等。
生态系统：Python具有广泛的第三方库和生态系统，适合各种应用。Go也有逐渐增长的生态系统，但相对于Python可能稍显有限。

11 go并发编程的了解

Go语言以其强大的并发支持而闻名，它在语言级别内置了轻量级的协程（goroutine）和通信机制（channel），使并发编程变得更加简单和高效。以下是关于Go并发编程的一些重要概念和特性：

协程（Goroutine）：
Goroutine是Go语言中的轻量级执行单元，类似于线程，但比线程更轻量且更高效。
可以启动成千上万个goroutine而不会造成大量系统资源的消耗。
使用关键字go来创建一个新的goroutine：go function()
通道（Channel）：
通道是goroutine之间进行通信和同步的机制，用于在不同的goroutine之间传递数据。通道可以是带缓冲或无缓冲的，有缓冲的通道可以在不阻塞发送方的情况下缓存一定数量的数据。通过通道可以实现数据传递和同步，避免了竞态条件等并发问题。
并发安全：
Go语言在语言级别提供了并发安全的数据结构，如sync.Mutex用于互斥锁和sync.WaitGroup用于等待多个goroutine的完成。使用这些工具可以确保在并发环境中访问共享资源时的安全性。
Select语句：Select语句用于在多个通道之间进行选择，可以用于阻塞等待多个通道中的任意一个数据到达。它也可以用于非阻塞地从通道中接收数据，类似于非阻塞I/O操作。
调度器：Go运行时具有一个Goroutine调度器，负责在多个逻辑处理器上分配goroutine的执行。调度器自动在不同的goroutine之间切换，实现了抢占式多任务。
并发模型：Go的并发模型基于CSP（通信顺序进程）模型，强调通过通信共享数据而不是通过共享数据来实现并发。
性能和扩展性：由于goroutines的轻量级和Go调度器的优化，Go能够实现高并发性能和扩展性。
错误处理：Go推荐使用错误值来处理错误，而不是抛出异常。这种方式可以更好地控制并发代码中的错误。Go的并发编程模型让开发者能够以一种更简单和可控的方式编写并发代码，有效地利用多核处理器和执行并发任务。然而，也需要小心处理并发问题，如竞态条件、死锁和饥饿等。熟练掌握Go的并发编程技巧，可以有效地提高应用程序的性能和响应能力。

12 restful风格含义

REST（Representational State Transfer）是一种设计风格和架构原则，用于创建具有可扩展性、可维护性和性能的网络服务。RESTful是遵循REST原则的设计实践，旨在构建简单、可预测、易于理解的Web服务接口。
RESTful风格的含义包括以下几个重要方面：

资源（Resources）：
在REST中，所有的数据和功能都被视为资源，例如用户、文章、订单等。每个资源都有唯一的标识符，通常通过URL来表示。
状态转移（State Transfer）：
客户端通过HTTP请求（GET、POST、PUT、DELETE等）来对资源进行状态转移。服务器根据请求进行相应的操作，例如获取、创建、更新或删除资源。
无状态性（Statelessness）：
RESTful架构中，每个请求都应该包含所有必要的信息，服务器不保存客户端的状态。这有助于提高可扩展性和可靠性，使服务更加简化和可移植。
标准化的操作（Uniform Interface）：
RESTful接口应该采用统一的操作方式，使用标准HTTP方法（GET、POST、PUT、DELETE）来操作资源。这有助于降低学习成本，使接口更易于理解和使用。
层次结构（Layered System）：
RESTful架构支持分层的设计，每一层都有特定的职责。这样可以提高系统的可扩展性，允许更灵活的架构。
缓存（Caching）：
RESTful接口可以使用HTTP中的缓存机制来减少网络流量和提高性能。客户端可以通过缓存控制头来控制资源的缓存策略。
自描述消息（Self-Descriptive Messages）：
RESTful接口应该提供足够的信息，使客户端能够理解如何解释响应，而无需依赖外部文档。
使用RESTful风格设计的API具有很多优势，包括简单性、可扩展性、互操作性和可维护性。它适用于构建Web服务、移动应用后端、微服务等各种应用场景。

13 你的项目中有没有调用过其他系统的open api经验，（可能想问这方面的问题，我没有过，面试官解释了一番）

OpenAPI，全称为"OpenAPI Specification"，是一个用于描述和定义RESTful API的标准格式。它以机器可读的方式定义API的结构、请求和响应格式、参数等细节，以便于生成客户端代码、自动生成文档和进行API测试。

OpenAPI的核心目标是促进API的可重用性、互操作性和开发者友好性。它允许开发者更好地理解和使用API，同时也可以帮助工具和平台生成与API交互所需的代码和文档。

OpenAPI规范通常使用JSON或YAML格式编写，其中包含了API的各个方面，包括：

基本信息：API的标题、版本、描述等基本信息。
路径和操作：API的不同端点（路径）和对应的HTTP操作（GET、POST、PUT、DELETE等）。
请求和响应参数：每个操作的输入参数和输出参数的描述，包括数据类型、验证规则等。
身份验证和授权：描述如何进行身份验证和授权。
错误处理：描述可能的错误响应和状态码，以及错误的详细描述。
数据模型：定义API中使用的数据结构和对象模型。
使用OpenAPI规范的优势包括：

自动生成文档：可以基于OpenAPI规范自动生成易于理解的API文档，减少文档编写的工作量。
自动生成客户端代码：可以使用OpenAPI规范生成客户端代码，帮助开发者更轻松地与API进行交互。
自动化测试：可以使用工具自动生成API测试，确保API的正确性。
互操作性：由于OpenAPI是一个标准，它可以被不同的工具和平台支持，从而实现更好的互操作性。
更好的开发者体验：开发者可以更快速地了解和使用API，减少学习曲线。
一些流行的API管理工具，如Swagger、OpenAPI Generator和Postman等，都支持OpenAPI规范，使得创建、维护和使用API更加高效和方便。

14 k8s中etcd作用

在Kubernetes（通常缩写为K8s）中，etcd是一个核心组件，它是一个高可用、分布式的键值存储数据库，被用作Kubernetes集群的数据存储和同步机制。etcd在Kubernetes中扮演着重要的角色，用于存储集群的配置、状态信息和元数据，以及支持分布式系统的协调和一致性。
etcd在Kubernetes中的作用包括：

配置存储：
etcd用于存储Kubernetes集群的配置信息，包括Pods、Services、Replication Controllers等资源的定义。这些信息可以通过API Server进行读取和更新。
状态存储：
etcd存储Kubernetes集群的实时状态信息，例如节点的健康状态、Pod的调度信息等。这使得集群的各个组件可以实时获取最新的状态。
服务发现：
Kubernetes中的Service资源抽象了一组Pod，etcd存储了这些Service的信息，使得其他组件和应用程序能够动态地发现这些Service的IP和端口。
分布式锁和协调：
etcd的一致性和分布式特性使其适用于分布式系统中的锁、选举和协调机制。Kubernetes在其中使用etcd来进行分布式锁定和资源竞争的处理，以保证系统的稳定性和正确性。
配置更改通知：
etcd支持观察者模式，允许应用程序和Kubernetes组件监听配置的更改。当配置发生变化时，监听器可以接收通知并采取相应的行动。
集群同步和高可用性：
etcd被设计为一个高可用的分布式系统，支持数据的复制和同步。Kubernetes集群中的etcd通常以多个实例运行，保证数据的备份和高可用性。
总之，etcd作为Kubernetes集群的数据存储后端，承担着维护配置、状态和元数据的任务，为整个集群的正常运行提供了重要支持。它的高可用性、一致性和分布式特性使得Kubernetes能够管理大规模的容器化应用。
15 反问，个人建议，sre职责

二

1.查看操作系统各个硬件的使用情况

Linux:

CPU使用情况：
使用命令top或htop可以实时查看CPU的使用情况。
命令cat /proc/cpuinfo可以显示CPU的详细信息。
内存使用情况：
使用命令free -h可以显示内存使用情况。
命令cat /proc/meminfo可以显示内存的详细信息。
磁盘使用情况：
使用命令df -h可以显示磁盘使用情况。
命令du -h可以查看特定目录的磁盘使用情况。
网络使用情况：
使用命令iftop可以实时查看网络流量情况。
GPU使用情况（如果有GPU）：
使用工具如nvidia-smi（NVIDIA GPU）或rocm-smi（AMD GPU）可以查看GPU的使用情况。

Windows:
任务管理器：
在Windows任务管理器中可以查看CPU、内存、磁盘和网络的使用情况。
资源监视器：
使用Windows资源监视器可以详细查看CPU、内存、磁盘和网络的使用情况。
性能监视器：
使用Windows性能监视器（perfmon）可以创建自定义性能计数器并监视各个硬件资源。
设备管理器：
使用Windows设备管理器可以查看和管理系统中的硬件设备。

2.Nginx和LVS负载均衡的区别

Nginx和LVS（Linux Virtual Server）都是常见的负载均衡解决方案，但它们在实现方式、功能特点和适用场景上存在一些区别。以下是Nginx和LVS负载均衡的主要区别：

1.类型：
Nginx是一款高性能的Web服务器和反向代理服务器，同时也可以用作负载均衡器。
LVS是一个基于Linux内核的负载均衡器，它通过网络层的IP负载均衡来实现。
2.负载均衡算法：
Nginx支持多种负载均衡算法，如轮询、权重、IP哈希等，可以根据需要选择不同的算法。
LVS也支持多种负载均衡算法，如轮询、加权轮询、源IP哈希等。
3.层次：
Nginx可以在应用层进行负载均衡，例如对HTTP、HTTPS请求进行负载均衡。
LVS在网络层进行负载均衡，通过IP地址和端口进行数据包分发。
4.反向代理和缓存：
Nginx除了负载均衡功能外，还可以作为反向代理服务器，用于处理请求并将其分发到后端服务器。此外，Nginx还支持HTTP缓存等功能。
LVS专注于负载均衡，不提供反向代理和缓存功能。
5.性能和定制性：
Nginx以其出色的性能和高效的异步事件驱动模型而著名，适用于大多数Web应用的负载均衡需求。
LVS则是在Linux内核层实现的，可以处理大规模的并发连接，适用于网络层的负载均衡需求。
6.配置和管理：
Nginx的配置相对简单，可以通过文本配置文件进行配置。同时，Nginx还提供了一些管理界面和第三方工具。
LVS的配置可能更复杂一些，需要在Linux内核中进行一些配置。
7.适用场景：
Nginx适用于Web服务器、反向代理、负载均衡、缓存等多种应用场景。
LVS适用于大规模、高并发的网络层负载均衡，比如TCP和UDP服务的负载均衡。
总之，Nginx和LVS都是优秀的负载均衡解决方案，选择哪个取决于具体的应用需求和架构。如果需要负载均衡和反向代理等功能，Nginx可能更适合。如果需要在网络层进行大规模负载均衡，LVS可能是更好的选择。

3.如何应对ack攻击（如何知道这是ack攻击，从哪些方面得出？）

（1）判断是否发生了ACK攻击需要观察一些特定的网络和系统指标，以及分析流量模式。虽然没有一种绝对准确的方法可以单独确定是否发生了ACK攻击，但以下一些方面可能会提示可能发生了ACK攻击：
异常的ACK流量：
观察网络流量中是否存在大量的ACK数据包，特别是在没有正常连接的情况下。如果短时间内出现大量的ACK数据包，可能是攻击者试图占用服务器资源。
高负载和资源消耗：
监控服务器的CPU、内存和网络使用情况。如果发现这些指标异常高，而且与ACK流量增加同时发生，可能是ACK攻击导致的。
连接数和半连接数：
观察服务器的连接数和半连接数（半打开连接数）。如果出现异常的半连接数，表示有大量的TCP连接被保持在连接状态，这可能是ACK攻击的迹象。
TCP连接状态：
分析服务器上的TCP连接状态，观察是否存在大量的TIME_WAIT状态的连接，这可能是ACK攻击导致的。
日志分析：
检查服务器和网络设备的日志，特别是网络流量日志。如果发现大量的无效ACK请求，可能是攻击者试图发起ACK攻击。
源IP分布：
分析流量的源IP分布情况，如果有大量的IP地址集中在同一时间发送大量的ACK请求，可能是分布式的ACK攻击。
网络监控工具：
使用网络监控工具来分析流量模式和异常情况，检测流量的变化和不正常的数据包。
虽然这些方面可能暗示可能发生了ACK攻击，但需要结合其他指标和分析来进行确定。在检测和应对网络攻击时，建议采取多层次的防御策略，包括使用入侵防御系统（IDS）、防火墙、负载均衡器等，以及实时监控网络和系统指标。
（2）ACK攻击（ACK Flood Attack）是一种网络攻击类型，攻击者通过向目标服务器发送大量的ACK（确认）数据包，消耗目标服务器的资源，导致网络性能下降甚至服务不可用。这种攻击利用了TCP三次握手过程中的漏洞，从而使服务器资源被耗尽。
以下是一些应对ACK攻击的方法：
防火墙配置：
配置防火墙规则，限制来自外部网络的无效TCP数据包。例如，禁止来自Internet的源IP的ACK数据包。
流量过滤：
使用流量过滤设备，如入侵防御系统（IDS）或入侵防火墙（IPS），对网络流量进行监控和过滤，识别并阻止异常的ACK流量。
设备和系统优化：
针对服务器和网络设备，进行性能优化和调整，以更好地应对大规模的ACK请求。
连接数限制：
在服务器上配置连接数限制，以限制单个IP地址或IP段可以建立的连接数量，从而防止攻击者使用大量连接来发起攻击。
负载均衡器：
使用负载均衡器，将来自不同源的流量分散到多个服务器上，从而减轻单个服务器的压力。
SYN Cookie：
使用SYN Cookie技术，它在三次握手的第一步即SYN请求中，将客户端的状态信息编码到SYN/ACK响应中，以减轻服务器的负载。
TCP协议参数调整：
调整TCP协议的参数，例如TCP SYN队列长度、超时等，使服务器能够更好地处理大量的ACK请求。
DDoS保护服务：
考虑使用专业的DDoS保护服务，这些服务可以检测和阻止各种类型的分布式拒绝服务攻击，包括ACK攻击。
无论采取哪种方法，都需要在服务器、网络设备和防火墙等多个层面上采取综合的防御策略，以减轻或阻止ACK攻击对系统造成的影响。

4.查看系统配置（几核等等）

要查看系统的配置信息，包括CPU核数、内存大小等等，可以使用不同操作系统提供的不同命令和工具。以下是在常见操作系统上查看系统配置信息的方法：

Linux:
查看CPU信息：
使用命令cat /proc/cpuinfo可以查看CPU的详细信息，包括核心数、型号、频率等。
查看内存信息：
使用命令free -h可以查看内存的使用情况和总量。
命令cat /proc/meminfo可以显示更详细的内存信息。
查看硬盘信息：
使用命令df -h可以查看磁盘使用情况和总容量。
查看系统版本：
使用命令uname -a可以查看操作系统的版本和内核信息。
查看网络配置：
使用命令ifconfig或ip addr可以查看网络接口的配置信息。
Windows:
查看CPU信息：
打开任务管理器，在“性能”选项卡下可以查看CPU的核心数和使用情况。
查看内存信息：
打开任务管理器，在“性能”选项卡下可以查看内存使用情况和总量。
查看硬盘信息：
打开“计算机”或“文件资源管理器”，右键点击硬盘驱动器，选择“属性”可以查看磁盘使用情况和总容量。
查看系统信息：
使用快捷键Win + Pause/Break可以打开系统属性窗口，其中包含有关系统的基本信息。
查看网络配置：
使用命令ipconfig可以查看网络接口的配置信息。

5.docker给企业带来的好处（如在一核的服务器中跑docker和虚拟机的差异）

Docker是一种容器化技术，它在企业环境中带来了许多好处。与传统虚拟化技术相比，使用Docker在一核的服务器上运行容器相比虚拟机有很多优势。以下是一些Docker给企业带来的好处以及与传统虚拟化的差异：

1. 资源利用率和性能优势：
  Docker容器共享操作系统内核，相比每个虚拟机都运行完整操作系统，容器更加轻量级，占用更少的资源。
  在一核服务器上，Docker容器由于更轻量，可以更好地利用有限的资源，从而提供更好的性能。
1. 快速部署和启动：
  Docker容器可以在几秒钟内启动和停止，而虚拟机启动需要更多的时间。这使得容器更适合快速部署、扩展和回滚。
1. 环境一致性：
  Docker容器将应用及其依赖项打包成一个可移植的容器，确保在不同环境中的一致性，避免了"在我的机器上可以工作"的问题。
1. 资源隔离和安全性：
  Docker使用Linux内核特性实现资源隔离，不同容器之间互不干扰。这提供了更好的安全性，防止应用间的相互影响。
1. 管理和自动化：
  Docker容器可以通过版本控制、自动化工具和编排平台（如Kubernetes）进行管理，使得部署、监控和管理变得更加容易。
1. 快速迭代和持续集成：
  Docker容器可以轻松创建不同版本的应用，并支持快速迭代和持续集成。开发人员可以更快地构建、测试和部署新功能。
1. 节省资源和成本：
  Docker容器在资源利用率上的优势意味着可以在同样的硬件上运行更多的应用，从而降低硬件成本。
1. 高度可移植性：
  Docker容器可以在任何支持Docker的环境中运行，包括本地开发环境、云服务器、数据中心等。
  总之，Docker的轻量级、可移植性、性能优势以及强大的开发和部署工具，使得它成为企业中常用的容器化技术。对于一核服务器而言，Docker在资源利用、部署速度和环境一致性方面都具有优势，因此它在这种情况下可能会更为适用。

6.开发一个五分钟之内发放五百万优惠券的系统，要求在多台服务器上负载均衡（使用队列）

开发一个能够在五分钟内发放五百万优惠券的系统，并且要求在多台服务器上进行负载均衡，可以采用以下步骤和技术：

架构设计：
设计一个分布式架构，将任务分成多个小任务，并将它们放入队列中。每个服务器从队列中获取任务进行处理，以实现负载均衡。
使用消息队列：
选择适合的消息队列（如RabbitMQ、Kafka等），将优惠券发放的任务拆分成多个消息，并将消息发送到队列中。
多台服务器设置：
配置多台服务器，每台服务器都可以独立地从消息队列中获取任务并执行。可以使用容器化技术（如Docker、Kubernetes）来管理多个服务器的部署。
任务拆分：
将五百万优惠券发放任务拆分成多个子任务，例如每个任务处理一定数量的优惠券。
并行处理：
每台服务器可以并行处理多个子任务，从队列中获取任务、处理任务并将结果返回。
数据库存储：
使用数据库存储优惠券的信息和状态。确保数据库可以支持高并发读写操作。
监控和日志：
实时监控系统性能、队列状态和任务执行情况，记录日志以便于问题排查。
自动扩展：
根据任务量和负载情况，可以自动扩展服务器数量，以应对高负载情况。
异常处理：
处理任务过程中可能出现的异常情况，如网络故障、队列处理失败等，确保系统的可靠性。
性能优化：
对任务执行进行性能优化，例如并发处理、缓存数据等，以加快优惠券发放速度。
代码测试和部署：
确保编写稳定、高效的代码，并进行充分的测试。使用自动化工具进行持续集成和部署。
负载均衡设置：
使用负载均衡器（如Nginx、HAProxy）将外部流量分发到多台服务器上，以实现负载均衡。
安全性考虑：
确保系统具有适当的安全性措施，例如身份验证、访问控制等。
需要注意，开发这样的系统需要考虑多个方面，包括架构设计、代码优化、性能测试等。同时，负载均衡和消息队列的配置和使用也需要经验和技术支持。最好寻求专业的开发团队或者顾问来协助您设计和实现这样的系统

7.装饰器的作用，多个装饰器运行的顺序

装饰器（Decorator）是Python中一种强大的编程特性，它可以用于修改或扩展函数或方法的行为。装饰器可以将一个函数或方法作为输入，并返回一个经过修改的新函数。装饰器在Python中广泛用于代码重用、代码美化、日志记录、性能分析等方面。
装饰器的作用包括：
代码重用：可以将一些通用的功能，比如权限验证、日志记录等，封装成装饰器，然后在多个函数或方法上重复使用。
代码美化：可以将与核心业务逻辑无关的代码（如日志记录、计时等）从主函数中分离出来，提高代码的可读性。
横切关注点的分离：允许将横切关注点（cross-cutting concerns）从核心逻辑中分离，以便更好地管理和维护。
函数的动态修改：可以通过装饰器在不修改原始函数代码的情况下，为函数添加新的功能。
多个装饰器运行的顺序是从上到下，从外到内。具体来说，如果一个函数或方法被多个装饰器修饰，那么它们的执行顺序是从外到内，即最外层的装饰器首先执行，然后依次往里执行。这是因为装饰器是按照嵌套的顺序进行应用的。需要注意的是，如果装饰器有参数，那么在使用装饰器时需要用括号传递参数。

8.监控程序（如普罗米修斯，zabbix）的数据源从哪里来

监控程序如Prometheus和Zabbix获取数据的来源通常来自于各种监控目标，包括服务器、网络设备、应用程序等。这些数据源提供了有关系统、应用和服务运行状况的信息，监控程序通过收集、存储和分析这些信息来提供实时的监控和警报。
以下是一些常见的数据源，供监控程序获取监控数据：
服务器和主机：
监控程序可以通过网络连接到服务器和主机，收集有关CPU使用率、内存使用率、磁盘空间、网络流量等信息。
容器和微服务：
对于使用容器技术的应用，监控程序可以连接到容器管理平台（如Docker、Kubernetes）来获取容器内部的性能数据。
应用程序：
监控程序可以连接到应用程序的API、日志或其他接口，获取有关应用性能、事务处理、错误日志等信息。
数据库：
监控程序可以连接到数据库系统，收集数据库的性能指标、查询性能、连接数等信息。
网络设备：
对于网络设备如路由器、交换机等，监控程序可以通过SNMP协议获取网络设备的状态和性能数据。
操作系统：
监控程序可以获取操作系统的性能指标、进程信息、系统日志等。
第三方服务和API：
一些监控程序支持与第三方服务和API集成，从而获取外部系统的性能数据，如云服务商的API。
自定义监控指标：
可以在应用代码中嵌入自定义的监控指标，监控程序通过这些指标获取应用内部的运行信息。
远程调用和代理：
一些情况下，为了安全性或隔离性，监控程序可能需要通过远程调用或代理来获取数据，例如代理服务器收集数据后发送给监控程序。
不同的监控程序具有不同的数据源支持和集成方式。普罗米修斯（Prometheus）通常使用基于HTTP的Pull模型，即主动从监控目标拉取数据。Zabbix则支持Pull和Push模型，可以主动从监控目标拉取数据，也可以由监控目标推送数据给Zabbix服务器。
综上所述，监控程序的数据源可以来自于多种不同类型的监控目标，这些目标提供了有关系统和应用运行状态的各种指标和信息。

9.如何开机自启自己写的服务？

在不同的操作系统中，设置开机自启动自己编写的服务可能会有一些差异。以下是在常见操作系统中实现开机自启动的一些方法：
在Linux中开机自启动服务：
使用systemd（适用于大多数现代Linux发行版）：
创建一个以.service为后缀的服务配置文件，通常存放在/etc/systemd/system/目录下。
编写配置文件，定义服务的执行路径、命令等信息。
运行systemctl enable your-service.service来启用自启动。
运行systemctl start your-service.service来启动服务。
使用init.d（在一些较旧的Linux发行版中）：
创建一个启动脚本文件，存放在/etc/init.d/目录下。
在脚本中编写启动、停止、重启等操作。
运行chkconfig your-service on来启用自启动。
运行service your-service start来启动服务。

10.如何查看进程的资源使用情况

要查看进程的资源使用情况，包括CPU、内存、磁盘、网络等方面的情况，你可以使用不同操作系统提供的工具和命令。以下是在不同操作系统上查看进程资源使用情况的方法：
Linux:
top命令：
使用top命令可以实时查看系统中各个进程的资源使用情况，包括CPU、内存、虚拟内存等。
htop命令：
htop是一个交互式的进程查看工具，提供了更友好的界面和更多的功能。
ps命令：
使用ps命令可以查看系统中运行的进程列表，使用不同的选项可以查看不同的信息，如ps aux可以显示详细信息。
pidstat命令：
pidstat命令可以查看指定进程的资源使用情况，包括CPU、内存、IO等。
Windows:
任务管理器：
打开任务管理器，可以查看正在运行的进程的资源使用情况，包括CPU、内存、磁盘、网络等。
资源监视器：
使用资源监视器（Resource Monitor），可以查看系统中各个进程的详细资源使用情况，包括CPU、内存、磁盘、网络等。
Process Explorer：
Process Explorer是Sysinternals Suite中的一个工具，提供了更详细的进程信息和资源使用情况。

11.tcp、udp的区别

TCP（Transmission Control Protocol）和UDP（User Datagram Protocol）是两种在计算机网络中常用的传输层协议，它们有一些重要的区别：

1. 连接性：
  TCP是面向连接的协议，通信双方需要先建立连接，然后才能进行数据传输。TCP提供可靠的、有序的数据传输。
  UDP是无连接的协议，通信双方之间不需要建立连接，数据包可以直接发送。UDP不提供可靠性和顺序性保证。
1. 可靠性：
  TCP提供可靠性传输，它使用确认、重传、流量控制等机制来确保数据的完整性和可靠性。
  UDP不提供可靠性保证，发送的数据包可能丢失、重复、乱序。
1. 有序性：
  TCP保证数据传输的有序性，接收方会按照发送顺序重新组装数据。
  UDP不保证数据的有序性，数据包可能以任意顺序到达。
1. 流量控制：
  TCP使用滑动窗口等机制来进行流量控制，确保发送方不会过多地发送数据，避免拥塞。
  UDP不提供流量控制机制。
1. 适用场景：
  TCP适用于需要可靠数据传输和顺序性的应用，如网页浏览、文件下载等。
  UDP适用于实时性要求高、数据传输量较大的应用，如实时音视频通信、在线游戏等。
1. 头部开销：
  TCP的头部开销较大，有额外的控制字段和序号信息，用于保证可靠性和有序性。
  UDP的头部较小，没有额外的控制字段，只有源端口、目标端口等基本信息。
  总的来说，TCP提供了可靠性、有序性和流量控制等功能，适用于对数据完整性和顺序性有较高要求的场景。UDP则更加轻量，适用于实时性要求高、数据传输速度更重要的场景，但不保证数据的可靠性和顺序性。在选择使用TCP还是UDP时，需要根据应用的需求来决定。

12.如何知道自己的系统上有多少块硬盘

使用命令lsblk：
打开终端，运行命令lsblk可以显示系统上的块设备（包括硬盘和分区）的信息，包括硬盘数量。
使用命令fdisk：
运行命令sudo fdisk -l可以列出系统上的所有硬盘和分区的详细信息。
使用命令lshw：
运行命令sudo lshw -class disk可以获取更详细的硬盘信息，包括硬盘数量、型号等。

13.说说对递归的理解

递归是一种编程技术，它指的是在函数中调用自身来解决问题的方法。递归在很多情况下可以使问题的解决变得更简洁和优雅，但同时也需要谨慎使用，因为不当的递归可能导致性能问题或堆栈溢出。
以下是对递归的一些理解：

递归调用：在递归中，一个函数可以调用自身，这种调用称为递归调用。每次递归调用都会缩小问题的规模，直到达到基本情况。
基本情况：递归函数需要定义一个或多个基本情况，这些情况下函数不再继续递归，而是返回一个已知的结果。
递归的思维方式：递归的思维方式是将大问题分解成相同的小问题。递归函数通过解决这些小问题来解决原始问题。
递归链条：递归调用形成了一个递归链条，每次调用都会向下一个较小规模的问题迈进。
栈的使用：递归调用会使用系统堆栈来保存每个函数调用的局部变量和返回地址。这可能会导致堆栈溢出，特别是在递归深度很大的情况下。
复杂性：递归算法可能很难理解和调试，因为每个递归层级都有自己的状态。
优缺点：递归可以使一些问题的解决变得非常简洁，但在某些情况下，迭代或其他方法可能更高效。
尾递归：尾递归是一种特殊的递归形式，其中递归调用是函数的最后一个操作。某些编程语言的优化器可以将尾递归优化为迭代。
总之，递归是一种有用的编程技术，可以用来解决许多问题。理解递归的关键是确定递归链条中的基本情况和递归的停止条件，以及确保递归调用朝着基本情况的方向进行。

14.swap分区的作用，如何关闭？

Swap分区是一种用于虚拟内存管理的技术，主要用于操作系统将部分内存中的数据移到磁盘上，以释放物理内存供其他进程使用。当系统的物理内存不足时，操作系统会将一些不常用的数据移至Swap分区，以便为更重要的数据腾出空间。Swap分区在提高系统的稳定性和性能方面起到了重要作用。
关闭Swap分区可能会影响系统的性能和稳定性，因此在关闭之前，请确保了解关闭后可能产生的影响。
关闭Swap分区的步骤：
临时禁用Swap分区：
可以使用以下命令临时禁用Swap分区（并不是永久关闭，重启后会恢复）：
sudo swapoff -a
永久关闭Swap分区：
永久关闭Swap分区需要编辑系统的fstab文件（通常位于/etc/fstab），并将Swap分区的相关行注释掉或删除。使用以下步骤：
a. 使用文本编辑器（如sudo nano /etc/fstab）打开fstab文件。
b. 查找包含Swap分区的行，通常类似于：
UUID=<swap_partition_UUID> none swap sw 0 0
c. 将该行注释掉（在行首添加#）或删除。
d. 保存文件并退出编辑器。
重新启用Swap分区：
如果在某个时刻想要重新启用Swap分区，可以使用以下命令重新启用：
sudo swapon -a
再次强调，关闭Swap分区可能会影响系统的性能和稳定性，因此在关闭之前，应该对系统进行充分测试，以确保不会出现问题。通常情况下，建议保留Swap分区以确保系统在内存不足时仍能正常工作。
15.有哪些文件系统？
文件系统是操作系统用来管理存储设备上的文件和数据的一种结构和方法。不同的操作系统和环境支持多种不同的文件系统。以下是一些常见的文件系统：

FAT（File Allocation Table）系列：
FAT12、FAT16、FAT32：常用于早期的Windows系统和移动存储设备，如U盘、SD卡等。
NTFS（New Technology File System）：
Windows NT系列操作系统的主要文件系统，支持更大的文件和更高级的权限管理。
exFAT（Extended File Allocation Table）：
扩展的FAT文件系统，支持更大的文件和存储设备，适用于移动设备和外部存储。
HFS+（Hierarchical File System Plus）：
用于Mac OS X及之前的文件系统，支持目录索引、元数据等。
APFS（Apple File System）：
Mac OS X High Sierra及之后版本的默认文件系统，具有高级的性能和特性。
ext系列（Extended File System）：
ext2、ext3、ext4：用于Linux操作系统，ext4是较新版本，支持更大的文件和更高级的特性。
ZFS（Zettabyte File System）：
具有强大的数据完整性、压缩、快照和存储池管理的文件系统，通常在类Unix系统中使用。
Btrfs（B-tree File System）：
具有快照、压缩、校验和等特性的文件系统，适用于Linux系统。
XFS：
适用于Linux系统，支持大文件、高性能的文件系统。
ReFS（Resilient File System）：

用于Windows Server系统，具有高级的数据完整性和容错性。

UFS（Unix File System）：

传统的Unix和BSD系统上使用的文件系统。
以上只是一些常见的文件系统，实际上还有更多不同的文件系统存在，它们各自具有不同的特点和适用场景。选择合适的文件系统取决于操作系统、存储设备和需求。
16.判断循环链表
判断一个链表是否为循环链表（Circular Linked List）的方法是通过遍历链表，并使用两个指针来判断是否存在循环。循环链表是一种特殊的链表，其最后一个节点的指针指向链表的某个中间节点，从而形成一个循环。
以下是判断循环链表的一种常见方法，使用两个指针：
使用快慢指针：
定义两个指针，一个称为快指针（fast），一个称为慢指针（slow）。
初始化时，让快指针指向链表的第一个节点，慢指针也指向第一个节点。
然后，使用循环来进行遍历，每次循环中，快指针走两步，慢指针走一步。
如果链表中存在循环，那么快指针最终会追上慢指针，指向同一个节点。
如果链表中不存在循环，快指针会在某个时刻指向末尾节点，循环结束。
如果在遍历过程中，快指针追上了慢指针，那么链表就是循环链表。如果循环结束时，快指针没有追上慢指针，那么链表不是循环链表。

17.给一个数组，统计重复数字

你可以使用哈希表（字典）来统计一个数组中重复数字的出现次数。以下是使用Python语言的示例代码：
python

def count_duplicates(nums):
    num_count = {}  # 创建一个字典来存储数字和其出现次数
    for num in nums:
        if num in num_count:
            num_count[num] += 1
        else:
            num_count[num] = 1
    duplicates = []
    for num, count in num_count.items():
        if count > 1:
            duplicates.append((num, count))  # 存储重复数字及其出现次数
    return duplicates
示例数组
nums = [1, 2, 3, 2, 4, 3, 5, 6, 7, 8, 1, 4, 9, 5, 10]
result = count_duplicates(nums)
print("重复数字及其出现次数：", result)

18.实现四则运算法则（栈）
通过使用栈（Stack）数据结构，你可以实现简单的四则运算表达式的计算。以下是一个使用Python实现的基本四则运算表达式计算的例子：
python

def evaluate_expression(expression):
    def precedence(operator):
        if operator in {'+', '-'}:
            return 1
        elif operator in {'*', '/'}:
            return 2
        return 0
    def apply_operator(operators, values):
        operator = operators.pop()
        right = values.pop()
        left = values.pop()
        if operator == '+':
            values.append(left + right)
        elif operator == '-':
            values.append(left - right)
        elif operator == '*':
            values.append(left * right)
        elif operator == '/':
            values.append(left / right)
    operators = []
    values = []
    i = 0
    while i < len(expression):
        if expression[i].isdigit():
            num = 0
            while i < len(expression) and expression[i].isdigit():
                num = num * 10 + int(expression[i])
                i += 1
            values.append(num)
        elif expression[i] in {'+', '-', '*', '/'}:
            while (operators and operators[-1] != '(' and
                   precedence(operators[-1]) >= precedence(expression[i])):
                apply_operator(operators, values)
            operators.append(expression[i])
            i += 1
        elif expression[i] == '(':
            operators.append(expression[i])
            i += 1
        elif expression[i] == ')':
            while operators[-1] != '(':
                apply_operator(operators, values)
            operators.pop()
            i += 1
        else:
            i += 1
    while operators:
        apply_operator(operators, values)
    return values[0]
# 示例表达式
expression = "3 + 4 * ( 2 - 1 )"
result = evaluate_expression(expression)
print("结果:", result)

在这个例子中，evaluate_expression函数将一个包含四则运算的表达式作为输入，使用两个栈（operators和values）来进行表达式的解析和计算。在解析过程中，通过比较运算符的优先级来决定是否进行计算，并使用栈来保存中间结果。

开发和运维兼顾，使用go语言开发私有云平台，企业内部使用的

19.协程和线程的区别

协程（Coroutine）和线程（Thread）都是用于并发编程的概念，但它们有一些重要的区别。以下是协程和线程之间的主要区别：

1. 调度方式：
  线程是由操作系统进行调度的，操作系统负责在不同线程之间进行切换，这需要一定的上下文切换开销。
  协程则是由程序员主动控制的，协程之间的切换是在代码级别上进行的，因此切换开销通常更小。
1. 并发数量：
  在一个应用程序中，可以同时存在大量的线程，每个线程都会占用一些操作系统资源，因此线程的数量受到系统资源限制的影响。
  协程通常可以创建更多的实例，因为它们的资源消耗相对较少。
1. 内存消耗：
  每个线程都需要一些系统资源，包括栈空间等，因此创建大量线程可能会导致较高的内存消耗。
  协程的内存消耗相对较小，因为它们共享相同的进程资源。
1. 阻塞：
  在多线程中，一个线程的阻塞操作不会影响其他线程的执行。
  在协程中，如果一个协程发生阻塞，它可能会影响其他协程的执行，因为协程之间的切换需要程序员显式地调度。
1. 数据共享和同步：
  在多线程编程中，不同线程之间共享的数据需要进行同步，以避免竞争条件和数据不一致的问题。
  协程通常在同一个线程中运行，因此数据共享相对较为简单，但也需要考虑同步。
1. 复杂性：
  多线程编程较为复杂，因为需要考虑线程同步、竞争条件等问题。
  协程相对较为简单，因为切换和同步控制在代码级别上进行。
  总之，协程和线程都有各自的优势和适用场景。线程适用于需要利用多核处理器的并行计算和IO密集型任务，而协程适用于高并发、事件驱动的编程场景，以及需要更轻量级的并发控制的情况。选择哪种并发模型取决于你的应用需求和设计目标。

三

一面：
1.自我介绍
2.常用linux命令，参考上面的
3.智力题

4.一个情景下多线程的设计

设计多线程程序时，需要考虑如何合理地利用多个线程来实现并发执行，以提高程序的性能和响应能力。以下是设计多线程程序的一般步骤和注意事项：
确定并发任务：首先，确定哪些任务可以并发执行，可以将它们分解为独立的子任务，每个子任务可以由一个线程执行。
线程安全性：确保多个线程可以同时访问共享资源而不会引发数据竞争和错误。使用互斥锁、信号量等同步机制来保护共享资源。
线程数量：根据硬件性能和任务复杂性，决定要创建的线程数量。太多的线程可能会导致线程切换开销过大，而太少的线程可能无法充分利用多核处理器。
线程间通信：如果线程需要共享数据或通信，需要设计适当的线程间通信机制，如使用消息队列、条件变量等。
错误处理：考虑多线程环境下的错误处理策略。捕获并处理线程可能引发的异常，避免程序崩溃。
任务分配：如果有多个任务，需要设计合理的任务分配策略，使不同的线程可以充分利用资源。
线程启动和结束：确保线程在合适的时间启动和结束，避免资源泄漏。
优先级和调度：了解线程调度算法和优先级设置，以确保高优先级任务得到及时处理。
资源管理：确保线程使用的资源（如内存、文件句柄等）在不再需要时能够被释放，避免资源泄漏。
测试和调试：多线程程序容易出现难以重现的问题，因此需要充分测试和调试，使用工具来检测死锁、数据竞争等问题。
性能优化：监控多线程程序的性能，识别性能瓶颈，考虑使用线程池、异步操作等来提高性能。
平台差异：注意不同操作系统对多线程的支持和差异，确保程序在不同平台上运行正常。
总之，在设计多线程程序时，需要综合考虑并发任务、资源共享、线程安全性等方面的问题，以确保程序稳定、高效地运行。同时，充分了解多线程编程的原则和技术，可以更好地设计和实现多线程程序。

5.敲个99乘法表

def multiplication_table(n):
    for i in range(1, n+1):
        for j in range(1, n+1):
            result = i * j
            print(f"{i:2d} * {j:2d} = {result:2d}\t", end="")
        print()
# 输出一个9x9的乘法表
multiplication_table(9)

#include <stdio.h>

void multiplication_table(int n) {
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            int result = i * j;
            printf("%2d * %2d = %2d\t", i, j, result);
        }
        printf("\n");
    }
}

int main() {
    // 输出一个9x9的乘法表
    multiplication_table(9);
    return 0;
}

二面：
1.自我介绍
2.定时任务

3.10分钟时间，不定长字符串数组中找公共后缀（abcbcd zxcbcd kmibcd 这种最后找到bcd就好，时间很短，没有自动填充，打字要快，思路要清楚）

#include <stdio.h>
#include <string.h>

这两行是包含标准C库的头文件，其中<stdio.h>用于输入输出操作，<string.h>用于字符串操作。

char* find_common_suffix(char** strs, int n) {
    if (n <= 0) {
        return "";
    }

这里定义了一个名为find_common_suffix的函数，该函数接受一个字符串指针数组strs和数组的长度n作为参数，并返回一个char*类型的指针。如果传入的数组长度小于等于0，则返回一个空字符串。

    char* first_str = strs[0];
    int common_suffix_len = strlen(first_str);

这里将数组的第一个字符串指针赋值给first_str，然后计算第一个字符串的长度并将其赋值给common_suffix_len，以作为公共后缀的初始长度。

    for (int i = 1; i < n; i++) {
        char* current_str = strs[i];
        int j = 0;
        
        while (first_str[j] != '\0' && current_str[j] != '\0' && first_str[j] == current_str[j]) {
            j++;
        }
        
        if (j < common_suffix_len) {
            common_suffix_len = j;
        }
    }

这是一个循环，从第二个字符串开始遍历整个字符串数组。在循环中，我们将当前字符串指针赋值给current_str，然后使用j来遍历两个字符串的字符。在内部的while循环中，我们比较first_str[j]和current_str[j]，并同时确保两个字符都不是字符串结尾（\0），并且字符相等。当字符不相等或有一个字符串到达结尾时，while循环结束，此时j表示两个字符串的公共前缀长度。

如果j小于当前已知的common_suffix_len，则更新common_suffix_len，因为我们寻找的是公共后缀，所以只有当新的公共前缀长度小于已知的公共后缀长度时，我们才更新后缀长度。

    char* common_suffix = malloc(common_suffix_len + 1);
    strncpy(common_suffix, first_str, common_suffix_len);
    common_suffix[common_suffix_len] = '\0';

    return common_suffix;
}

在这里，我们使用malloc函数分配了足够大小的内存来存储公共后缀，然后使用strncpy函数将first_str中的公共后缀部分复制到common_suffix中。最后，我们在common_suffix的末尾添加一个空字符，以确保字符串的终止。

int main() {
    char* strings[] = {"abcbcd", "zxcbcd", "kmibcd"};
    int n = sizeof(strings) / sizeof(strings[0]);

    char* common_suffix = find_common_suffix(strings, n);

    printf("Common Suffix: %s\n", common_suffix);

    free(common_suffix);

    return 0;
}

这是主函数。我们定义了一个字符串指针数组strings，其中包含一些字符串。然后，我们通过计算数组长度（数组元素个数除以单个元素的大小）来得到n。接下来，我们调用find_common_suffix函数，传递字符串数组和长度作为参数，并将返回的公共后缀赋值给common_suffix。然后，我们使用printf函数将公共后缀输出到终端。最后，我们使用free函数释放之前分配的内存，以防止内存泄漏。最后，main函数返回0，表示程序成功结束。

4.10分钟时间，输入一周股价，算出买入卖出的最大利润，（典型DP问题）

def max_profit(prices):
    if not prices:
        return 0

    n = len(prices)
    dp = [0] * n
    min_price = prices[0]

    for i in range(1, n):
        dp[i] = max(dp[i - 1], prices[i] - min_price)
        min_price = min(min_price, prices[i])

    return dp[n - 1]
# 示例股价列表
prices = [7, 1, 5, 3, 6, 4]
result = max_profit(prices)
print("最大利润:", result)

5.一个高并发的题（可以只说思路）

1.什么是高并发？

高并发是指系统在同一时刻处理大量用户请求的能力。这些请求可能是同时到达的，因此系统需要有效地处理这些请求，保证性能和响应速度。

2.如何衡量系统的并发能力？

系统的并发能力可以通过多个指标来衡量，如每秒请求数（QPS）、并发连接数、吞吐量等。QPS表示每秒处理的请求数，而并发连接数表示系统同时处理的连接数量。

3.什么是负载均衡？

负载均衡是将请求分发到多个服务器上，以平衡每台服务器的负载，提高系统的性能和可靠性。负载均衡器可以根据不同的算法来决定将请求发送到哪个服务器。

4.什么是分布式缓存？

分布式缓存是一种用于存储和管理数据的高速存储系统，将数据存储在内存中，以提供快速的访问。主要目标是可以减轻数据库负载，提高数据访问速度。特别是在高并发的情况下。
分布式缓存通常由多台服务器构成，这些服务器构成了一个缓存集群。每台服务器都具有一部分数据的副本，这样可以提供冗余和可靠性。当客户端请求数据时，分布式缓存系统会首先检查缓存中是否存在该数据，如果存在则直接返回，从而避免了对底层数据库的访问。
分布式缓存系统通常具有以下特点：
高性能：由于数据存储在内存中，分布式缓存可以实现快速的读取和写入操作，提供低延迟的数据访问。
可扩展性：分布式缓存可以通过添加更多的缓存服务器来扩展容量和性能，以适应不断增长的访问量。
分布式：数据在多台服务器上分布，保证数据的冗余性和高可用性。
缓存失效策略：分布式缓存可以设置缓存数据的失效策略，以确保缓存数据的新鲜度。
分片：数据可以被分成多个分片，分布在多个服务器上，以提高并发性能。
数据一致性：分布式缓存通常提供不同的一致性级别，如强一致性、最终一致性等，以满足不同的应用需求。
缓存穿透处理：分布式缓存可以处理缓存穿透问题，即当请求不存在的数据时，不会对底层数据库产生无谓的压力。
缓存击穿处理：分布式缓存可以处理缓存击穿问题，即在高并发下，某个缓存失效导致大量请求直接访问数据库。
分布式缓存常用于需要快速访问大量数据的场景，如Web应用、电子商务平台、社交媒体等。一些流行的分布式缓存系统包括Redis、Memcached、Apache Ignite等。它们提供了丰富的功能和配置选项，以满足不同应用场景的需求。

5.数据库连接池的作用是什么？

数据库连接池管理数据库连接的创建、复用和释放，避免频繁地创建和关闭连接，从而提高数据库访问效率。

6.如何处理并发写入？

并发写入可能导致数据一致性问题，可以通过使用锁、事务和乐观锁等机制来解决。锁可以防止多个线程同时写入同一资源，而事务可以保证一组操作的原子性。乐观锁基于版本或时间戳来进行冲突检测。

7.CAP定理是什么？

CAP定理指出，分布式系统无法同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition Tolerance）这三个属性。在设计系统时需要权衡这些属性。

8.什么是分布式锁？

分布式锁用于在分布式环境中实现互斥访问。通过分布式锁，只有一个线程能够访问共享资源，从而避免并发访问带来的问题。
分布式锁是一种用于在分布式系统中实现互斥访问的机制，确保在多个节点上同时只有一个节点可以访问共享资源。在分布式环境中，由于多个节点同时执行，如果不加控制，可能会导致数据不一致或冲突的问题。分布式锁通过协调多个节点之间的访问，保证只有一个节点可以成功获取锁，从而避免了并发冲突。
分布式锁通常具有以下特点：
互斥性：在任意时刻，只有一个节点能够获取到分布式锁，其他节点需要等待。
超时机制：分布式锁可以设置一个超时时间，确保即使锁没有显式释放，也不会永久占用资源。
容错性：即使有节点崩溃或网络中断，分布式锁应该仍然能够正常工作，不会导致资源无法释放。
可重入性：允许同一个节点在持有锁的情况下再次获取锁，避免死锁情况。
释放机制：锁的持有者在完成操作后应该显式地释放锁，使其他节点有机会获取锁。
性能和可扩展性：分布式锁的实现需要保证在高并发情况下性能良好，且能够支持系统的水平扩展。
避免死锁：分布式锁的设计要避免死锁，即互斥循环等情况。
常见的分布式锁实现方式包括：
基于数据库的锁：使用数据库表记录锁状态，获取锁时插入一条记录，释放锁时删除记录。适用于关系型数据库。
基于缓存的锁：使用分布式缓存，将锁状态存储在缓存中，通过缓存的原子操作来实现加锁和解锁。
基于ZooKeeper： ZooKeeper是一个分布式协调服务，可以用于实现分布式锁。
基于Redis： Redis提供了原子操作，可以使用它的SETNX（set if not exists）命令来实现分布式锁。
分布式锁的设计和实现需要考虑数据一致性、性能、高可用性等多个方面的问题，以确保在分布式环境中正常工作。

9.怎么解决热点访问问题？

热点访问可能导致某些资源成为性能瓶颈。可以通过缓存、数据分片、负载均衡等方法来分散热点访问，保证系统的平稳运行。

10.说说消息队列的用途和优势。

消息队列用于解耦系统组件，实现异步处理，削峰填谷，提高系统性能和可靠性。优势包括异步通信、系统解耦、高可用性和扩展性。

11.什么是悲观锁和乐观锁？

悲观锁假设在并发环境下会发生冲突，因此在访问资源之前会加锁。乐观锁假设冲突不常见，因此在更新资源时会检查冲突，通常使用版本号或时间戳。

12.如何保证数据一致性？

在分布式系统中，可以使用分布式事务、最终一致性等方法来保证数据一致性。分布式事务可以保证多个操作的原子性和一致性，而最终一致性允许一段时间内的数据不一致，最终达到一致状态。

13.什么是无锁编程？

无锁编程是一种并发控制方法，通过原子操作和CAS（比较和交换）来实现，避免使用锁，从而提高并发性能。

何进行系统水平的扩展？

系统的水平扩展可以通过添加更多的服务器来实现，以分担负载。垂直扩展则是增加服务器的硬件资源，如内存、CPU等。

什么是反向代理和CDN？

反向代理是位于服务器前端的代理服务器，用于分发客户端请求到多个后端服务器。CDN是一种内容分发网络，将内容缓存在多个服务器上，以提供更快的内容访问。
反向代理（Reverse Proxy）和内容分发网络（CDN，Content Delivery Network）是用于优化网络性能、提高网站可用性和加速内容传输的关键技术。它们在网络中起到不同但相互补充的作用。
反向代理（Reverse Proxy）：
反向代理是一种服务器，它代表客户端与目标服务器之间进行通信。客户端发送请求到反向代理，然后反向代理将请求转发到适当的目标服务器。这种代理隐藏了后端服务器的真实地址，可以用于负载均衡、安全性、SSL终止等目的。
主要特点：
负载均衡：反向代理可以分发客户端请求到多个后端服务器，实现负载均衡，减轻单个服务器的负担。
SSL终止：反向代理可以在服务器上终止SSL连接，减少服务器的SSL处理负担。
安全性：可以通过反向代理来过滤恶意请求、防止DDoS攻击等。
缓存：反向代理可以缓存静态资源，提高访问速度。
内容分发网络（CDN，Content Delivery Network）：
CDN是由一系列位于不同地理位置的服务器组成的网络，它旨在将内容分发给最终用户，从而提高访问速度和减少网络延迟。CDN通常会缓存静态资源，如图片、视频、CSS和JavaScript文件，使用户可以从最近的服务器获取内容。
主要特点：
缓存： CDN会将内容缓存在多个服务器上，从而减少源服务器的负载，提高用户访问速度。
就近访问：用户会从距离最近的CDN节点获取内容，减少网络延迟。
分发： CDN会动态地将内容分发到多个节点，以确保内容能够快速到达用户。
高可用性：通过在多个地理位置部署服务器，CDN可以提供高可用性，即使某个服务器失效，用户仍可以从其他服务器获取内容。
综合来说，反向代理和CDN都是用于优化网络性能和提高网站可用性的重要工具。反向代理主要用于负载均衡、安全性和SSL终止，而CDN主要用于缓存和就近访问，以提高内容传输速度和用户体验。

反向代理和正向代理

反向代理（Reverse Proxy）和正向代理（Forward Proxy）是代理服务器的两种不同类型，它们的作用和工作方式有所不同。
反向代理（Reverse Proxy）：
反向代理位于服务器端，它代表服务器接收客户端的请求，并将请求转发到后端的目标服务器。客户端不直接访问目标服务器，而是通过反向代理与之通信。反向代理隐藏了后端服务器的真实地址，可以用于负载均衡、安全性、SSL终止等目的。
主要特点：
反向代理隐藏了后端服务器的真实地址，客户端不直接与目标服务器通信。
可以实现负载均衡，将请求分发到多个后端服务器，从而提高性能和可用性。
可以提供SSL终止，将SSL连接解密，然后在服务器上进行处理。
可以用于安全性，过滤恶意请求、防止DDoS攻击等。
正向代理（Forward Proxy）：
正向代理位于客户端端，它代表客户端发送请求到代理服务器，然后由代理服务器将请求转发给目标服务器。客户端通过正向代理来访问其他服务器，隐藏了客户端的真实地址。
主要特点：
正向代理代表客户端发出请求，目标服务器不知道请求的真实来源。
通常用于绕过网络限制，访问受限网站，或在内部网络中访问外部资源。
可以用于实现匿名性，客户端的真实IP地址对目标服务器是不可见的。
总结区别：
位置不同：反向代理位于服务器端，正向代理位于客户端端。
隐藏不同：反向代理隐藏了后端服务器，正向代理隐藏了客户端。
功能不同：反向代理用于负载均衡、安全性等，正向代理用于访问控制、绕过网络限制等。
需要注意的是，代理服务器的作用在于中间处理和转发请求，无论是反向代理还是正向代理，都可以用于保障安全性、性能优化和访问控制等目的。

6.一个遥控器，说说如何优化（开放题）

优化遥控器可以从多个方面考虑，以提升用户体验、功能扩展和性能改进。以下是一些优化遥控器的建议：
1.用户界面和人机交互：
简洁的设计：优化遥控器的界面，保持简洁明了的设计，避免过多的按钮和选项，使用户容易理解和操作。
直观的布局：将常用的功能放置在易于访问的位置，避免用户在不同屏幕间切换太多次。
易于操作：选择易于按压、反应敏捷的按钮，减少误操作的可能性。
可自定义：提供一些可以自定义的按钮或快捷键，让用户根据个人偏好设置遥控器的功能。
2.多设备支持：
通用性：如果遥控器用于多个设备，确保它可以适应不同品牌和类型的设备，或者提供多种设备的预设设置。
智能匹配：使用智能匹配技术，使遥控器能够自动识别并连接到用户周围的设备。
3.语音和手势控制：
语音识别：集成语音识别技术，使用户可以通过语音指令控制设备。
手势识别：支持手势识别，让用户可以通过简单的手势完成操作。
4.无线技术和连接：
蓝牙和Wi-Fi：使用蓝牙或Wi-Fi技术，以便遥控器可以连接到更多类型的设备，并提供更稳定的连接。
无线充电：集成无线充电功能，让用户不必频繁更换电池。
5.应用和智能手机连接：
移动应用：开发一个移动应用，使用户可以通过智能手机控制和配置遥控器，提供更多交互和功能。
智能手机连接：支持智能手机与遥控器的无线连接，使用户可以在手机上操作遥控器。
6.电池寿命和节能：
低功耗模式：遥控器可以进入低功耗模式，以延长电池寿命。
自动关闭：添加自动关闭功能，如果一段时间内没有操作，遥控器会自动关闭以节省能源。
7.可维护性和升级：
固件升级：支持在线固件升级，以便在后期添加新功能、修复漏洞或改进性能。
模块化设计：采用模块化设计，使硬件和软件部分可以独立升级和维护。
8.用户支持和故障排除：
用户手册：提供详细的用户手册，帮助用户了解遥控器的功能和操作方法。
在线支持：提供在线帮助和故障排除指南，以帮助用户解决常见问题。
综上所述，优化遥控器需要综合考虑用户界面、功能拓展、连接技术、能源效率等多个方面。根据目标用户群体和使用场景，可以选择适合的优化策略。
三面：
线下了，boss气场很足
1.谈项目中遇到的问题，如何解决的，做了哪些方案，为什么选最终方案

2 谈谈遇到不公平待遇怎么办

遇到不公平待遇是一种普遍的职场挑战，如何妥善处理可以影响你的职业发展和工作满意度。以下是一些可能的应对策略：
保持冷静和理性：首先，面对不公平待遇时要保持冷静，不要情绪化地做出决定或表现。理性思考可以帮助你更好地应对问题。
了解全貌：在作出任何决定之前，先试着了解整个情况。可能是存在误解、沟通问题或信息不足，而不是故意的不公平。
收集证据：如果你认为遭遇了不公平待遇，收集相关证据是非常重要的。这可以是邮件、聊天记录、项目文档等，以便在需要时能够清楚地表述情况。
与直接上级沟通：优先与直接上级进行沟通，说明你的感受和观点，解释你认为存在的问题，听取他们的解释和观点。
寻求支持：如果直接上级无法解决问题，可以考虑寻求人力资源部门或其他管理层的支持。他们可能能够提供中立的意见和解决方案。
自我反省：有时候不公平待遇也可能与个人表现或态度有关。进行自我反省，确保自己在工作中表现出专业、积极的态度。
寻求咨询：如果情况严重且无法得到解决，你可能需要寻求法律或职业咨询。了解你的权益，决定是否采取进一步行动。
专业发展计划：如果不公平待遇成为长期问题，你可能需要重新考虑自己的职业发展计划。有时候，换一个更好的工作环境可能是解决问题的最佳方式。
保持积极：尽管面临困难，保持积极的态度和工作表现非常重要。这有助于你在职业生涯中保持专业形象，无论遇到什么挑战。
总之，处理不公平待遇需要冷静和成熟的态度，同时积极采取行动，以寻找解决方案并保护自己的职业利益。

3.谈如何处理压力

处理压力是在工作和生活中保持良好心态的关键。以下是一些应对压力的方法和策略：
认识和接受压力：首先要认识到压力是正常的生活和职业的一部分。接受压力的存在可以帮助你更好地应对它。
时间管理：有效的时间管理可以减轻压力。制定任务清单、设置优先级、合理规划工作和休息时间，有助于更好地控制压力。
放松技巧：学习放松技巧，如深呼吸、冥想、瑜伽、渐进性肌肉松弛等，可以缓解身体和心理上的紧张。
锻炼和身体健康：定期锻炼有助于释放紧张情绪，增强体力，改善心情。同时，保持良好的饮食和充足的睡眠也是重要的。
寻求支持：和朋友、家人、同事或心理健康专家进行交流，分享自己的感受和挑战，得到理解和支持。
分解任务：将庞大的任务分解成小步骤，逐步完成，可以减少压力感，同时获得成就感。
设定目标：设定明确的目标可以帮助你集中精力，避免分散注意力，从而减轻压力。
积极思维：培养积极的思维方式，看到问题中的机会和挑战，而不是仅关注问题本身。
创造性释放：从事你喜欢的活动，如艺术、音乐、阅读等，可以提升心情，释放创造力。
寻找乐趣：让生活更有乐趣，保持兴趣爱好，与朋友共度时光，可以缓解紧张情绪。
限制多任务：避免同时处理多个任务，专注于一项任务可以提高效率，减少焦虑感。
寻求帮助：如果压力持续且影响到日常生活和工作，不要犹豫寻求专业的心理健康支持。
每个人的应对方式可能会有所不同，关键是找到适合自己的方法，有效地管理和减轻压力，以保持身心健康。
4.找我之前的面试评价，貌似找到之后直接就送我去HR了
5. 熟练掌握基础算法及数据结构，了解后端服务性能优化；
6. 有挑战大规模集群管理的兴趣，有强烈的上进心、求知欲；
7. 要求自我驱动，积极主动参与到产品设计开发维护中来；

8.深刻理解分布式系统架构，大规模并发处理技术

分布式系统架构和大规模并发处理技术是现代计算机系统中非常重要的领域，特别是在处理复杂应用、高并发请求和大量数据的情况下。下面对这两个主题进行深入理解：
（1）分布式系统架构：
一.分布式系统定义：分布式系统是由多个独立的计算机节点通过网络连接，协同工作来完成共同任务的系统。节点可以位于不同的地理位置，通过消息传递或远程调用进行通信。
二.关键概念：
1.分布式计算：任务被分割成子任务，由多个节点并行处理，以提高整体性能。
2.数据共享：数据在不同节点之间共享和传输，需要解决数据一致性和可用性问题。
3.通信机制：节点之间通过消息传递、远程调用等方式进行通信。
4.容错性：分布式系统需要考虑节点故障、网络故障等情况，实现容错和高可用性。
三.架构模式：
客户端-服务器模式：客户端发送请求，服务器处理请求并返回结果。
微服务架构：将应用拆分为一组小型、独立的服务，每个服务可以独立部署和维护。
大数据架构：处理大量数据的系统，如Hadoop、Spark等。
（2）大规模并发处理技术：
1.并发与并行：
并发：多个任务交替执行，共享资源，通过时间片轮转等方式实现。
并行：多个任务同时执行，利用多核处理器等实现。
2.线程与进程：
进程：操作系统分配的独立内存空间，包含多个线程。
线程：轻量级的执行单元，共享进程的资源，可以并发执行。
3.并发模型：
多线程：多个线程共享进程的内存，适用于I/O密集型任务。
协程（Coroutine）：轻量级线程，可以在代码中进行切换，适用于I/O和计算密集型任务。
事件驱动：基于事件和回调的方式，如Node.js。
4.并发控制：
锁机制：使用锁来控制共享资源的访问，但可能引发死锁和性能问题。
无锁（Lock-Free）：使用无锁数据结构和原子操作来避免锁的竞争。
分布式锁：在分布式环境中确保互斥访问，避免冲突。
5.消息队列：使用消息队列来处理异步任务，减少对资源的竞争。
6.负载均衡：将请求分发到多个服务器，平衡各个服务器的负载，提高系统性能和可用性。
7.缓存：使用缓存来减轻数据库的负载，提高数据访问速度。

企业

1、定位
滴滴出行是全球卓越的移动出行科技平台，在亚太、拉美、非洲和俄罗斯提供出租车召车、网约车、顺风车、公交、共享单车、共享电单车、代驾、汽车服务、配送、货运及物流、金融等多元化服务。
根据2021年6月11日滴滴出行向美国证监会提交的招股书披露的信息，滴滴将其现有业务划分为三大主线，分别为中国出行业务、国际业务和其他业务。
2、核心数据
据艾媒数据，2020年4月到8月滴滴出行APP月活跃用户数远超于其他APP，其中4月滴滴出行月活跃用户数为5064.1万人，8月滴滴出行月活跃用户数为5487.1万人。
截止2021年Q1，滴滴的业务共覆盖了15个国家和地区，在全球拥有4.93亿年活跃用户，2020年的GTV为2146亿人民币，核心订单量达到91亿单。
02 中国出行业务
滴滴的中国出行业务板块主要包括网约车、网约出租车、顺风车等服务。2020年，滴滴中国出行业务的营收占比为94.3%，是其最主要的收入来源。2019年后，滴滴中国出行业务板块开始逐渐盈利，随着疫情影响的消退，2021年Q1盈利规模显著扩大，2018-2021Q1调整后的EBITA利润率分别为-0.21%、2.6%、3.0%和9.2%，盈利能力得以稳步改善。
1、滴滴快车
服务定位：属于滴滴出行APP上的营利性搭车服务
服务种类：①优享：为城市新锐提供高性价比、人性化的出行服务；②拼车：提供一口价、叫车快、超顺路、更节省的拼车服务
发展概要：滴滴快车于2015年上线，为司机创造了灵活的就业机会，让乘客享受更经济便捷的乘车服务，这使得移动出行市场迅猛拓展。目前滴滴快车也为滴滴运营过程中的主流订单类型
2、礼橙专车
服务定位：以高端车型、优质服务为高端商务出行人群提供品质出行体验
发展概要：2018年滴滴专车宣布品牌和服务全新升级，正式启用“礼橙专车”为新的品牌名称，这一决定正是伴随着消费者消费体验升级而来的。因此为了保障用户体验，礼橙专车成立了独立客服热线，提供24小时中英文服务。在原有服务基础上，打造了更贴心、更细致的个性化服务，如提供更多的出行服务装备等。今年5月27日，滴滴出行宣布，其旗下“礼橙专车”更名为“滴滴专车”，新名称将在滴滴出行APP端和小程序端同步更新。专车有舒适、商务、豪华等车型可选，满足了不同人群的出行需求。
3、滴滴出租车
服务定位：滴滴出租车是滴滴的初创业务，连接乘客与传统出租车，属于网约车出租车融合发展的服务模式
发展概要：2012年滴滴打车和快的打车推出线上出租车服务，改变了人们的出行方式，截至2020年每周有近90万出租车司机在滴滴上接单。2020年9月，滴滴发布公告将旗下的“滴滴出租车”业务升级为“快的新出租”，同时宣布投入1亿元转型补贴，为出租车乘客发放打车券，以此来打动消费，帮助司机们提升单量和收入。推出此活动后，平台订单量突破500万单，创历史新高。
4、滴滴顺风车
服务定位：分享互助出行平台，让路程相似的通勤者和私家车主拼车出行，分摊油费
发展概要：滴滴顺风车于2015年6月1日上线，平台通过算法智能匹配，可以让路程相似的通勤者和私家车主拼车出行，让通勤变得更加经济、便利。同时，滴滴顺风车提高了车辆利用率，减少了能源消耗，缓解空气污染状况。截至2020年6月，滴滴顺风车宣布已在全国300个城市开通服务。
5、滴滴企业版
服务定位：为企业提供安全、合规、透明的多场景出行服务及出行管理解决方案
核心数据：2016年开通滴滴企业版的客户已近15000家，其中5000家核心用户的日订单数就已超10万，覆盖1700万职场人群。截至目前，滴滴企业版已在400座城市开通服务，共有6种车型涵盖商务出行、加班、接送客户、代叫车、代驾、接送机、差旅不同场景。
发展概要：滴滴企业版于2015年1月正式宣布上线，旨在帮助企业管理者利用出行数据实现线上化、数据化、智能化管理。2015年7月，滴滴企业版在提供标准化企业出行服务的基础上，推出滴滴企业开放平台，即向客户开放API接口，企业可基于该API接口开发自己的用车服务，企业可以自己通过后台设置费用额度、用车时间段、出发地、目的地等信息，并查看用车行为分析。
6、滴滴公交
服务定位：在智慧公交领域提供基础的出行信息服务和实时公交查询功能，智能化解决用车的服务
服务功能：①换乘查询、②线路查询、③通勤班车（便捷查询匹配班车）
核心数据：数据显示截止2016年11月，滴滴公交已开通上线25个城市，覆盖过亿公共出行用户。
发展概要：滴滴公交于2016年6月由滴滴巴士品牌升级而来。除了提供基础的出行信息服务和实时公交查询功能外，滴滴公交还可以基于滴滴出行全平台大数据和人工智能技术辅助支持公交线路的新设和调整优化，进一步辅助公交企业的运营调度。
滴滴公交具有两个特色功能：一、地图实时显示模式，随时看见车在哪。借助滴滴出行的大数据优势，并将机器学习应用到预估任意起终点所需的行驶时间技术以及结合实时路况对车辆到站时间进行准确预估，使滴滴实时公交能够实现超过95%的准确率。二、安卓客户端在线路详情页面锁屏后可直接在手机屏幕中展示车辆到站信息等相关内容。
7、滴滴代驾
服务定位：致力于为车主提供便捷、专业、可信赖的多元化代驾司机服务
核心数据：2015年10月，上线不足百日的滴滴代驾，用户覆盖率以70.4%居首位。
发展概要：滴滴代驾是滴滴继“滴滴打车”、“滴滴专车”、“滴滴顺风车”、“滴滴快车”以及滴滴企业出行服务后，在移动出行领域推出的又一产品。2015年7月28日滴滴快的宣布正式上线滴滴代驾业务。滴滴代驾采取“起步价+公里费”的计费方式，不同时段的起步价均包含了10公里，超出10公里后，收取固定的里程费。
8、滴滴豪华车
服务定位：为高端用户品质出行提供服务：豪华车型（一线豪华车品牌中高档轿车）、尊享服务（五星级酒店和航空头等舱服务标准）、司务员（私人出行管家）、个性化
发展概要：2019年8月，滴滴出行宣布与万达酒店及度假村达成战略合作。用户可在万达酒店微信公众号内使用滴滴叫车。万达酒店旗下的礼宾部也将植入一键代叫服务，并设置滴滴车站。酒店礼宾部可通过滴滴代叫车系统，根据用户需求，呼叫礼橙专车或滴滴豪华车等车型。滴滴车站可实时动态展示酒店前往机场、火车站、核心商圈和景点等地点的时长，提前为行程做出参考。
03 国际业务
根据招股书披露的信息，滴滴的海外业务主要涵盖国际出行和外卖两个部分，且主要把市场确定在了巴西、墨西哥、印度和南非等人口密度较大的发展中国家。
2018-2020年，滴滴国际业务的营收占比分别为0.3%、1.3%和1.7%，呈现逐年提高的趋势。
04 其他业务
2018-2021Q1，其他业务收入占比分别为1.23%、3.15%、4.06%和5.04%，呈现逐年提升趋势。但从盈利情况看，随着社区团购、自动驾驶等领域投入的持续加大，目前其他业务处于持续亏损状态，且规模明显放大，是导致滴滴亏损的关键原因。
1、青桔单车
服务定位：共享单车服务
核心数据：根据易观发布的《2020中国共享两轮车市场专题报告》，2020年10月青桔单车月度活跃用户规模高达3491.6万，占据共享两轮车行业小程序端用户规模榜首。同时，截至2020年9月，全国实施动态配额管理制度城市中，青桔单车在60%的城市获得第一名。
发展概要：2018年1月25日，滴滴出行的自有共享单车品牌青桔单车正式在成都上线。青桔单车基于滴滴平台海量的大数据，对供需能精准预测，以指挥车辆高效率调度，避免车辆淤积。同时，滴滴在成都搭建了运维人员团队，按区域细分网格化、精细化管理，确保车辆摆放整齐有序，对车辆热点区及时介入，确保道路畅通。
2、滴滴金融
服务定位：致力于打造安全可信赖的金融科技服务平台，推出滴水贷、点滴保等产品，为用户提供滴滴保险、信贷、理财、支付等服务
核心数据：截至2019年5月初，滴滴金融的用户数超过1000万。
3、橙心优选
服务定位：围绕居民日常生活所需的“新零售”平台。
核心数据：2020年7月30日橙心优选上线45天，日单量突破10万单。同年9月，全国日单量突破280万单。目前滴滴已经将橙心优选进行了分析，仅保留了32.8%的少数股权。
发展概要：2020年6月15日，“橙子优选社区电商”微信小程序证实上线，首站落户成都。2020年9月25日，诚信优选独立APP正式上线，用户可选择微信小程序或这下载APP进行。同年10月，橙心优选密集进入河南、福建、浙江、江西、河北、江苏南京、广东等14个省市。同年11月，国家农业农村部与滴滴橙心优选达成合作，双方将在农产品采购、仓储、品牌推广等方面进行对接，共同推动农民合作社产品直达社区，带动农产品“源头触网”销售。
4、自动驾驶
简介：自动驾驶的终局时实现高级别自动驾驶的规模化商业落地。从底层逻辑来说，技术持续演进后的自动驾驶可以带来超越人力驾驶的行车体验、成本优势以及缓解驾驶过程中的安全问题，因此具有巨大的商业价值。基于自动驾驶的Robotaxi业务将最有可能成为滴滴的增长曲线。
发展概要：滴滴的自动驾驶业务始于2016年，基于其出行服务主体，选择了相对容易落地的自动驾驶出租车（Robotaxi）领域，根据中金证券的测算，预计市场规模在1.4万亿人民币。