Java面试黄金宝典31

1. 什么是封锁协议

 

• 定义：封锁协议是在运用封锁机制时，为了保证事务的一致性和隔离性，对何时申请封锁、持锁时间以及何时释放封锁等问题制定的规则。它可防止并发操作引发的数据不一致问题，如丢失修改、不可重复读和读 “脏” 数据等。
• 要点：分为不同的级别，如一级封锁协议可防止丢失修改，二级封锁协议在一级基础上可防止读 “脏” 数据，三级封锁协议能防止不可重复读。
• 应用：在数据库并发控制中广泛应用，不同数据库系统（如 Oracle、MySQL）实现细节有差异。
• 代码示例（SQL 示意）：在 MySQL 中模拟一级封锁协议防止丢失修改。假设有一个账户表 accounts，包含 id 和 balance 字段。

sql

-- 开启事务
START TRANSACTION;
-- 对账户 1 加写锁
SELECT balance FROM accounts WHERE id = 1 FOR UPDATE;
-- 模拟业务操作，修改余额
UPDATE accounts SET balance = balance + 100 WHERE id = 1;
-- 提交事务
COMMIT;

 

2. 什么是死锁，活锁

 

死锁

• 定义：多个事务在执行过程中，因争夺锁资源而形成的一种互相等待的状态，导致所有事务都无法继续执行下去。例如事务 T1 持有锁 L1 并请求锁 L2，而事务 T2 持有锁 L2 并请求锁 L1，此时就会发生死锁。
• 要点：死锁的发生需要满足四个必要条件，即互斥条件、请求和保持条件、不剥夺条件和循环等待条件。
• 应用：在数据库并发场景中，多事务操作共享资源时可能出现。可通过死锁检测和预防来避免。
• 代码示例（SQL 示意）：

sql

-- 事务 1
START TRANSACTION;
SELECT * FROM table1 WHERE id = 1 FOR UPDATE;
-- 模拟业务处理
SELECT * FROM table2 WHERE id = 2 FOR UPDATE;
COMMIT;-- 事务 2
START TRANSACTION;
SELECT * FROM table2 WHERE id = 2 FOR UPDATE;
-- 模拟业务处理
SELECT * FROM table1 WHERE id = 1 FOR UPDATE;
COMMIT;

 

活锁

• 定义：事务虽然没有被阻塞，但由于不断地重试或等待其他事务释放锁，导致长时间无法执行。例如，一个事务在不断地尝试获取锁，但每次都因为其他事务的短暂占用而失败，从而一直处于忙碌状态。
• 要点：活锁不会像死锁那样导致系统陷入停滞，但会降低系统的性能。
• 应用：在高并发场景下，锁竞争激烈时容易出现。可通过公平锁机制避免。
• 代码示例（Java 示意）：

java

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class LiveLockExample {private static final Lock lock = new ReentrantLock();public static void main(String[] args) {Thread t1 = new Thread(() -> {while (true) {if (lock.tryLock()) {try {System.out.println("Thread 1 got the lock");break;} finally {lock.unlock();}}}});Thread t2 = new Thread(() -> {while (true) {if (lock.tryLock()) {try {System.out.println("Thread 2 got the lock");break;} finally {lock.unlock();}}}});t1.start();t2.start();}
}

 

3. 解决死锁的方法

 

死锁预防

• 定义：通过破坏死锁的四个必要条件之一来防止死锁的发生。例如，一次性获取所有需要的锁，破坏请求和保持条件；或者采用资源有序分配法，破坏循环等待条件。
• 要点：这种方法可以从根本上避免死锁的发生，但可能会降低系统的并发度。
• 应用：在对数据一致性要求较高，并发度要求相对较低的场景中使用。
• 代码示例（Java 示意）：

java

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class DeadlockPreventionExample {private static final Lock lock1 = new ReentrantLock();private static final Lock lock2 = new ReentrantLock();public static void main(String[] args) {Thread t1 = new Thread(() -> {lock1.lock();try {System.out.println("Thread 1 got lock1");lock2.lock();try {System.out.println("Thread 1 got lock2");} finally {lock2.unlock();}} finally {lock1.unlock();}});Thread t2 = new Thread(() -> {lock1.lock();try {System.out.println("Thread 2 got lock1");lock2.lock();try {System.out.println("Thread 2 got lock2");} finally {lock2.unlock();}} finally {lock1.unlock();}});t1.start();t2.start();}
}

 

死锁检测

• 定义：系统定期检查是否存在死锁，如果发现死锁，则采取相应的措施来解除死锁。常用的死锁检测算法有资源分配图算法和等待图算法。
• 要点：死锁检测可以在一定程度上提高系统的并发度，但需要消耗一定的系统资源。
• 应用：在并发度较高的数据库系统中应用，根据系统负载动态调整检测频率。
• 代码示例（此为概念示意，无直接对应代码）：数据库系统内部会有复杂的算法来实现死锁检测，一般开发者无需手动编写死锁检测代码。

死锁解除

• 定义：当检测到死锁后，选择一个或多个事务作为牺牲品，将其回滚，释放其所持有的锁，以解除死锁。
• 要点：选择牺牲品时需要考虑多个因素，如事务的优先级、已执行的时间和资源占用情况等。
• 应用：在死锁检测到后，用于恢复系统正常运行。
• 代码示例（SQL 示意）：数据库系统会自动处理死锁解除，开发者一般无需手动编写。当发生死锁时，数据库可能会回滚其中一个事务。

 

4. 两段锁协议

 

• 定义：事务在执行过程中分为两个阶段，第一阶段是扩展阶段，事务可以申请任何需要的锁，但不能释放已获得的锁；第二阶段是收缩阶段，事务只能释放已获得的锁，不能再申请新的锁。
• 要点：两段锁协议可以保证事务的可串行化，但不能避免死锁的发生。
• 应用：在数据库并发控制中保证事务的可串行化执行。
• 代码示例（SQL 示意）：

sql

-- 事务开始
START TRANSACTION;
-- 扩展阶段，申请锁
SELECT * FROM table1 WHERE id = 1 FOR UPDATE;
SELECT * FROM table2 WHERE id = 2 FOR UPDATE;
-- 业务处理
UPDATE table1 SET column1 = 'value' WHERE id = 1;
UPDATE table2 SET column2 = 'value' WHERE id = 2;
-- 收缩阶段，释放锁
COMMIT;

 

5. 什么是 GAP 锁

 

• 定义：GAP 锁是 MySQL 中 InnoDB 存储引擎在可重复读隔离级别下使用的一种锁，用于锁定索引记录之间的间隙，防止其他事务在这些间隙中插入新的记录，从而避免幻读问题。
• 要点：GAP 锁只锁定间隙，不锁定记录本身。它可以防止其他事务在间隙中插入新的记录，但不会阻止其他事务对已有记录的修改。
• 应用：在可重复读隔离级别下，防止幻读。
• 代码示例（SQL 示意）：

sql

-- 设置隔离级别为可重复读
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
START TRANSACTION;
-- 加 GAP 锁
SELECT * FROM table_name WHERE column_name BETWEEN 1 AND 10 FOR UPDATE;
-- 此时其他事务无法在 1 - 10 的间隙插入数据
COMMIT;

 

6. 什么是 next - key 锁

 

• 定义：next - key 锁是 GAP 锁和记录锁的组合，它不仅锁定索引记录本身，还锁定该记录之前的间隙。在可重复读隔离级别下，InnoDB 存储引擎默认使用 next - key 锁来防止幻读。
• 要点：next - key 锁可以保证事务在读取数据时，不会看到其他事务插入的新记录，从而避免幻读问题。
• 应用：在可重复读隔离级别下，保证数据的一致性，防止幻读。
• 代码示例（SQL 示意）：

sql

-- 设置隔离级别为可重复读
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
START TRANSACTION;
-- 加 next - key 锁
SELECT * FROM table_name WHERE id = 5 FOR UPDATE;
-- 锁定 id = 5 的记录及其前后间隙
COMMIT;

 

7. 什么是 limit20000 如何优化

 

• 定义：LIMIT 20000 通常用于从数据库中查询前 20000 条记录。当数据量较大时，直接使用 LIMIT 可能会导致性能问题，因为数据库需要扫描大量的记录来找到所需的 20000 条记录。
• 要点：优化的关键在于减少数据库的扫描范围和避免不必要的计算。
• 应用：在大数据量分页查询场景中使用。
• 代码示例（SQL 示意）：

sql

-- 未优化的查询
SELECT * FROM large_table LIMIT 20000;-- 优化后的查询（书签分页）
-- 假设上一页最后一条记录的 id 为 1000
SELECT * FROM large_table WHERE id > 1000 LIMIT 20;

 

8. drop delete truncate 区别

 

drop

• 定义：用于删除数据库对象，如表、视图、索引等。它会彻底删除对象的定义和数据，释放占用的存储空间。
• 要点：这是一个不可逆的操作，一旦执行，数据将无法恢复。
• 应用：当不再需要某个数据库对象时使用。
• 代码示例（SQL）：

sql

DROP TABLE table_name;

delete

• 定义：用于删除表中的数据，可以根据条件删除部分数据，也可以不指定条件删除全量数据。它是一条 DML（数据操作语言）语句，会记录日志。
• 要点：删除数据时会逐行删除，性能相对较低。可以通过 WHERE 子句来指定删除条件。
• 应用：需要根据条件删除部分数据时使用。
• 代码示例（SQL）：

sql

-- 删除部分数据
DELETE FROM table_name WHERE column_name = 'value';
-- 删除全量数据
DELETE FROM table_name;

truncate

• 定义：用于删除表中的所有数据，但不删除表的定义。它是一条 DDL（数据定义语言）语句，不会记录日志，执行速度比 DELETE 快。
• 要点：TRUNCATE 操作不能使用 WHERE 子句，会重置自增列的值。
• 应用：需要快速清空表数据时使用。
• 代码示例（SQL）：

sql

TRUNCATE TABLE table_name;

 

9. 什么是事务

 

• 定义：事务是一组不可分割的数据库操作序列，这些操作要么全部执行成功，要么全部不执行。事务具有四个特性，即原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability），简称 ACID 特性。
• 要点：原子性保证事务中的所有操作要么全部成功，要么全部失败；一致性保证事务执行前后数据库的状态是一致的；隔离性保证多个事务并发执行时不会相互干扰；持久性保证事务一旦提交，其对数据库的修改将永久保存。
• 应用：在需要保证数据一致性的场景中广泛应用，如银行转账等。
• 代码示例（Java + JDBC）：

java

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;public class TransactionExample {public static void main(String[] args) {String url = "jdbc:mysql://localhost:3306/test";String user = "root";String password = "password";try (Connection conn = DriverManager.getConnection(url, user, password)) {conn.setAutoCommit(false);try (Statement stmt = conn.createStatement()) {stmt.executeUpdate("UPDATE accounts SET balance = balance - 100 WHERE id = 1");stmt.executeUpdate("UPDATE accounts SET balance = balance + 100 WHERE id = 2");conn.commit();System.out.println("Transaction committed successfully");} catch (SQLException e) {conn.rollback();System.out.println("Transaction rolled back due to error: " + e.getMessage());}} catch (SQLException e) {e.printStackTrace();}}
}

10. 什么是超键、 候选键、 主键、 外键 视图

 

超键

• 定义：在关系数据库中，能够唯一标识表中每一行记录的属性或属性组称为超键。超键可以包含多余的属性。
• 要点：超键的作用是确保表中记录的唯一性。
• 应用：在数据库设计中，用于确定记录的唯一性。
• 代码示例（SQL 示意）：

sql

CREATE TABLE users (id INT,email VARCHAR(255),username VARCHAR(255),-- (id, email) 是一个超键UNIQUE (id, email)
);

候选键

• 定义：候选键是超键的子集，它是能够唯一标识表中每一行记录的最小属性集，即去掉其中任何一个属性后就不能唯一标识记录了。
• 要点：一个表可能有多个候选键。
• 应用：是选择主键的基础。
• 代码示例（SQL 示意）：

sql

CREATE TABLE products (product_id INT,product_code VARCHAR(20),-- product_id 和 product_code 都是候选键UNIQUE (product_id),UNIQUE (product_code)
);

主键

• 定义：主键是从候选键中选择的一个，用于唯一标识表中每一行记录。一个表只能有一个主键。
• 要点：主键不能为空，且值必须唯一。
• 应用：在数据库中唯一标识记录，建立表之间的关联。
• 代码示例（SQL）：

sql

CREATE TABLE orders (order_id INT PRIMARY KEY,customer_id INT,order_date DATE
);

外键

• 定义：外键是一个表中的属性或属性组，它引用了另一个表的主键。外键用于建立表与表之间的关联关系。
• 要点：外键的值必须是所引用表中主键的值，或者为空。
• 应用：保证数据的参照完整性。
• 代码示例（SQL）：

sql

CREATE TABLE order_items (item_id INT PRIMARY KEY,order_id INT,product_id INT,FOREIGN KEY (order_id) REFERENCES orders(order_id),FOREIGN KEY (product_id) REFERENCES products(product_id)
);

视图

• 定义：视图是一个虚拟表，它是从一个或多个表中导出的结果集。视图并不实际存储数据，而是根据定义的查询语句动态生成结果。
• 要点：视图可以简化复杂的查询，提高数据的安全性和保密性。
• 应用：在需要简化查询、保护数据时使用。
• 代码示例（SQL）：

sql

-- 创建视图
CREATE VIEW customer_orders AS
SELECT customers.customer_name, orders.order_date
FROM customers
JOIN orders ON customers.customer_id = orders.customer_id;-- 查询视图
SELECT * FROM customer_orders;

 友情提示：本文已经整理成文档，可以到如下链接免积分下载阅读

 https://download.csdn.net/download/ylfhpy/90562238