后端面试题

Java 面试题

1. Java 内存模型（JMM）是什么？

Java 内存模型定义了线程如何与内存交互，包括：

• 主内存：存储共享变量
• 工作内存：线程私有的内存空间
• 内存屏障：保证内存操作的可见性和有序性

2. 什么是 Java 垃圾回收机制？

Java 的垃圾回收机制包括：

• 标记-清除算法
• 复制算法
• 标记-整理算法
• 分代收集算法

垃圾收集器：

• Serial GC
• Parallel GC
• CMS GC
• G1 GC

3. 什么是 Java 并发编程？

Java 并发编程的核心：

• 线程创建和生命周期
• 线程同步（synchronized, volatile）
• 线程通信（wait/notify）
• 并发工具类（CountDownLatch, CyclicBarrier）
• 线程池（ThreadPoolExecutor）

Python 面试题

1. Python 的 GIL 是什么？

GIL（Global Interpreter Lock）是 Python 解释器的全局锁，它确保同一时间只有一个线程执行 Python 字节码。

影响：

• 多线程程序在 CPU 密集型任务中性能受限
• I/O 密集型任务不受影响
• 多进程可以绕过 GIL 限制

2. Python 的装饰器是什么？

装饰器是 Python 的一种语法糖，用于修改或增强函数的功能。

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result
    return wrapper

@my_decorator
def my_function():
    print("Inside function")

3. Python 的生成器是什么？

生成器是一种特殊的迭代器，使用 yield 关键字实现。

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

数据库面试题

1. 数据库索引是什么？有什么优缺点？

索引是数据库中用于加速查询的数据结构。

优点：

• 加快查询速度
• 保证数据唯一性
• 加速表连接

缺点：

• 占用存储空间
• 降低写入速度
• 需要维护

2. 什么是数据库事务？

事务是数据库操作的原子单位，具有 ACID 特性：

• 原子性（Atomicity）
• 一致性（Consistency）
• 隔离性（Isolation）
• 持久性（Durability）

3. 数据库的隔离级别有哪些？

• 读未提交（Read Uncommitted）
• 读已提交（Read Committed）
• 可重复读（Repeatable Read）
• 串行化（Serializable）

微服务面试题

1. 什么是微服务架构？

微服务架构是一种将应用程序拆分为多个小型、独立服务的架构风格。

特点：

• 服务独立部署
• 技术栈灵活
• 可扩展性强
• 容错性好

2. 微服务通信方式有哪些？

• REST API
• gRPC
• 消息队列（RabbitMQ, Kafka）
• GraphQL

3. 微服务治理包含哪些内容？

• 服务注册与发现
• 负载均衡
• 熔断降级
• 限流
• 监控告警
• 链路追踪

系统设计面试题

1. 如何设计一个高并发系统？

• 使用缓存（Redis, Memcached）
• 数据库优化（读写分离, 分库分表）
• 消息队列削峰
• CDN 加速
• 负载均衡

2. 如何设计一个分布式系统？

• 一致性哈希
• CAP 理论
• 分布式事务
• 分布式锁
• 分布式 ID

3. 如何保证系统的高可用？

• 多机房部署
• 故障转移
• 限流降级
• 监控告警
• 灰度发布

实践案例

1. 实现一个简单的线程池

public class SimpleThreadPool {
    private BlockingQueue<Runnable> taskQueue;
    private List<WorkerThread> threads;
    
    public SimpleThreadPool(int poolSize) {
        taskQueue = new LinkedBlockingQueue<>();
        threads = new ArrayList<>();
        
        for (int i = 0; i < poolSize; i++) {
            WorkerThread worker = new WorkerThread();
            worker.start();
            threads.add(worker);
        }
    }
    
    public void execute(Runnable task) {
        taskQueue.offer(task);
    }
    
    private class WorkerThread extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    Runnable task = taskQueue.take();
                    task.run();
                } catch (InterruptedException e) {
                    break;
                }
            }
        }
    }
}

2. 实现一个简单的缓存系统

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.order = []
    
    def get(self, key):
        if key in self.cache:
            self.order.remove(key)
            self.order.append(key)
            return self.cache[key]
        return -1
    
    def put(self, key, value):
        if key in self.cache:
            self.order.remove(key)
        elif len(self.cache) >= self.capacity:
            oldest = self.order.pop(0)
            del self.cache[oldest]
        self.cache[key] = value
        self.order.append(key)

学习资源

在线教程

• Java 官方文档
• Python 官方文档
• MySQL 官方文档
• Redis 官方文档
• Spring 官方文档

书籍推荐

• 《Java 并发编程实战》
• 《Python 核心编程》
• 《高性能 MySQL》
• 《Redis 设计与实现》
• 《微服务设计》

练习平台

• LeetCode
• HackerRank
• CodeSignal
• Codewars