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