锁机制
定义:锁是计算机协调多个进程或线程并发访问某一资源的机制。
锁的分类:
从对数据操作的类型分:
读锁(共享锁):针对同一份数据,多个读操作可以同时进行而不会互相影响。
写锁(排它锁):当前写操作没有完成前,它会阻断其他写锁和读锁。
从对数据操作的粒度分:
表锁
行锁
表锁(偏读)
use testdb;
【表级锁分析--建表SQL】
create table mylock(
id int not null primary key auto_increment,
name varchar(20)
)engine myisam;
insert into mylock(name) values('a');
insert into mylock(name) values('b');
insert into mylock(name) values('c');
insert into mylock(name) values('d');
insert into mylock(name) values('e');
select * from mylock;
【手动增加表锁】
lock table 表名字1 read(write),表名字2 read(write),其它;
#给book添加读锁,staffs表添加写锁
mysql> lock table book read,staffs write;
【查看表上加过的锁】
show open tables;
mysql> show open tables;
mysql> show open tables where In_use>0;
+----------+--------+--------+-------------+
| Database | Table | In_use | Name_locked |
+----------+--------+--------+-------------+
| testdb | staffs | 1 | 0 |
| testdb | book | 1 | 0 |
+----------+--------+--------+-------------+
2 rows in set (0.00 sec)
#可以看到
【释放表锁】
unlock tables;
mysql> unlock tables;
Query OK, 0 rows affected (0.00 sec)
mysql> show open tables where In_use>0;
Empty set (0.00 sec)
【如何分析表锁定】
可以通过检查table_locks_waited和table_locks_immediate状态来分析系统上的表锁定
mysql> show status like 'table%';
+----------------------------+-------+
| Variable_name | Value |
+----------------------------+-------+
| Table_locks_immediate | 95 |
| Table_locks_waited | 0 |
| Table_open_cache_hits | 29 |
| Table_open_cache_misses | 15 |
| Table_open_cache_overflows | 0 |
+----------------------------+-------+
5 rows in set (0.00 sec)
Table_locks_immediate:产生表级锁定的次数,表示可以立即获取锁的查询次数,每立即获取锁值加1;
Table_locks_waited:出现表级锁征用而发生等待的次数(不能立即获取锁的次数,没等待一次锁值加1),此值高则说明严重的表级锁争用情况
加读锁
我们为mylock表加read锁(读阻塞写例子)
session_1
#给mylock表上读锁
mysql> lock table mylock read;
Query OK, 0 rows affected (0.00 sec)
#可以查询上锁的表
mysql> select * from mylock;
+----+------+
| id | name |
+----+------+
| 1 | a |
| 2 | b |
| 3 | c |
| 4 | d |
| 5 | e |
+----+------+
5 rows in set (0.00 sec)
#不能查询未上锁的表
mysql> select * from book;
ERROR 1100 (HY000): Table 'book' was not locked with LOCK TABLES
#不能更新表的数据
mysql> insert into mylock(name) value('e');
ERROR 1099 (HY000): Table 'mylock' was locked with a READ lock and can't be updated
mysql> update mylock set name='k' where id=1;
ERROR 1099 (HY000): Table 'mylock' was locked with a READ lock and can't be updated
#释放锁
mysql> unlock tables;
session_2
#可以查看上读锁的表
mysql> select * from mylock;
+----+------+
| id | name |
+----+------+
| 1 | a |
| 2 | b |
| 3 | c |
| 4 | d |
| 5 | e |
+----+------+
5 rows in set (0.00 sec)
#可以更新未上锁的表
mysql> update staffs set name='z2' where id=1;
Query OK, 1 row affected (0.02 sec)
Rows matched: 1 Changed: 1 Warnings: 0
#session_1对mylock表上读锁时,session_2的数据更新操作进入阻塞状态
mysql> insert into mylock(name) value('e');
#当session_1释放锁以后,session_2完成插入操作
mysql> insert into mylock(name) value('e');
Query OK, 1 row affected (4 min 13.24 sec)
加写锁
我们为mylock表加write锁(MyISAM存储引擎的写阻塞读例子)
session_1
#给mylock表加写锁
mysql> lock table mylock write;
Query OK, 0 rows affected (0.00 sec)
#可查询mylock表
mysql> select * from mylock;
+----+------+
| id | name |
+----+------+
| 1 | a |
| 2 | b |
| 3 | c |
| 4 | d |
| 5 | e |
| 6 | e |
+----+------+
6 rows in set (0.00 sec)
#可更新mylock表
mysql> update mylock set name='a4' where id=1;
Query OK, 1 row affected (0.01 sec)
Rows matched: 1 Changed: 1 Warnings: 0
#不可读未上锁的表
mysql> select * from book;
ERROR 1100 (HY000): Table 'book' was not locked with LOCK TABLES
#释放锁
mysql> unlock tables;
Query OK, 0 rows affected (0.00 sec)
session_2
#由于session_1对mylock表上写锁,session_2的读操作被阻塞
mysql> select * from mylock;
#当session_1释放写锁以后,查询完成
mysql> select * from mylock;
+----+------+
| id | name |
+----+------+
| 1 | a4 |
| 2 | b |
| 3 | c |
| 4 | d |
| 5 | e |
| 6 | e |
+----+------+
6 rows in set (11.18 sec)
注:在锁表前,如果session2有数据缓存,锁表以后,在锁住的表不发生改变的情况下session2可以读出缓存数据,一旦数据发生改变,缓存将失效,操作将被阻塞住。
结论
MyISAM在执行查询语句(SELECT)前,会自动给涉及的所有表加读锁,在执行增删改操作前,会自动给涉及的表加写锁。
MySQL的表级锁有两种模式:
表共享读锁(Table Read Lock)
表独占写锁(Table Write Lock)
锁类型 | 他人可读 | 他人可写 |
---|---|---|
读锁 | 是 | 否 |
写锁 | 否 | 否 |
结论:
结合上表,所以对MyISAM表进行操作,会有以下情况:
1、对MyISAM表的读操作(加读锁),不会阻塞其他进程对同一表的读请求,但会阻塞对同一表的写请求。只有当读锁释放后,才会执行其它进程的写操作。
2、对MyISAM表的写操作(加写锁),会阻塞其他进程对同一表的读和写操作,只有当写锁释放后,才会执行其它进程的读写操作。
简而言之,就是读锁会阻塞写,但是不会堵塞读。而写锁则会把读和写都堵塞
行锁(偏写)
特点:
偏向InnoDB存储引擎,开销大,加锁慢;会出现死锁;锁定粒度最小,发生锁冲突的概率最低,并发度也最高。
InnoDB与MyISAM的最大不同有两点:一是支持事务(TRANSACTION);二是采用了行级锁
复习事务的内容:
事务具有原子性,一致性,隔离性,持久性
并发事务带来的问题:更新丢失、脏读、不可重复读、幻读
隔离级别 | 读数据一致性 | 脏读 | 不可重复读 | 幻读 |
---|---|---|---|---|
未提交读(Read uncommitted) | 最低级别,只能保证不读取物理上损坏的数据 | 是 | 是 | 是 |
已提交读(Read committed) | 语句级 | 否 | 是 | 是 |
可重复读(Repeatable read) | 事务级 | 否 | 否 | 是 |
可序列化(Serializable) | 最高级别,事务级 | 否 | 否 | 否 |
常看当前数据库的事务隔离级别:
select @@transaction_isolation;
show variables like ‘transaction_isolation’;
设置隔离级别:
set transaction_isolation=‘REPEATABLE-READ’;
案例分析
#建表sql
create table test_innodb_lock (a int(11),b varchar(16))engine=innodb;
insert into test_innodb_lock values(1,'b2');
insert into test_innodb_lock values(3,'3');
insert into test_innodb_lock values(4,'4000');
insert into test_innodb_lock values(5,'5000');
insert into test_innodb_lock values(6,'6000');
insert into test_innodb_lock values(7,'7000');
insert into test_innodb_lock values(8,'8000');
insert into test_innodb_lock values(9,'9000');
insert into test_innodb_lock values(1,'b1');
create index test_innodb_a_ind on test_innodb_lock(a);
create index test_innodb_lock_b_ind on test_innodb_lock(b);
select * from test_innodb_lock;
行锁定基本演示
session_1
#1.关闭自动提交
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
#2.更新但不提交,没有手动更新
mysql> update test_innodb_lock set b='b1' where a=1;
Query OK, 1 row affected (0.00 sec)
Rows matched: 2 Changed: 1 Warnings: 0
#3.提交更新
mysql> commit;
Query OK, 0 rows affected (0.03 sec)
session_2
#1.关闭自动提交
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
#2.由于session_1在执行2后没有提交更新,因此进入阻塞状态
mysql> update test_innodb_lock set b='b1' where a=1;
#3.session_1执行3提交更新,解除阻塞状态,继续运行
mysql> update test_innodb_lock set b='b1' where a=1;
Query OK, 0 rows affected (14.71 sec)
Rows matched: 2 Changed: 0 Warnings: 0
#4.提交
mysql> commit;
Query OK, 0 rows affected (0.01 sec)
无索引行锁升级为表锁
session_1
#正常情况,各自锁定各自的行,互不影响,一个2000另一个300
mysql> update test_innodb_lock set b='2' where b='2000';
Query OK, 0 rows affected (0.00 sec)
Rows matched: 0 Changed: 0 Warnings: 0
#由于在column字段b上面建了索引,如果没有正常使用,会导致行锁变表锁
#比如没加单引号导致索引失效,行锁变表锁
mysql> update test_innodb_lock set b='2' where b=2000;
Query OK, 0 rows affected (0.00 sec)
Rows matched: 0 Changed: 0 Warnings: 0
#提交
mysql> commit;
session_2
#正常执行
mysql> update test_innodb_lock set b='b1' where a=1;
Query OK, 0 rows affected (14.71 sec)
Rows matched: 2 Changed: 0 Warnings: 0
#由于session_1的更新操作使得行锁升级为表锁,更新被阻塞
mysql> update test_innodb_lock set b=3000 where a=3;
#session_1提交以后,阻塞解除,可继续执行
mysql> update test_innodb_lock set b=3000 where a=3;
Query OK, 0 rows affected (10.56 sec)
Rows matched: 1 Changed: 0 Warnings: 0
#提交
mysql> commit;
Select也可以加锁
读锁:
SELECT … LOCK IN SHARE MODE;
写锁:
SELECT … FOR UPDATE;
间隙锁的危害
【什么是间隙锁】
当我们用范围条件而不是相等条件检索数据,并请求共享或排他锁时,InnoDB会给符合条件的已有数据记录的索引项加锁;对于键值在条件范围内但并不存在的记录,叫做“间隙(GAP)”,
InnoDB也会对这个“间隙”加锁,这种锁机制就是所谓的间隙锁(GAP Lock)。
【危害】
因为Query执行过程中通过过范围查找的话,他会锁定整个范围内所有的索引键值,即使这个键值并不存在。
间隙锁有一个比较致命的弱点,就是当锁定一个范围键值之后,即使某些不存在的键值也会被无辜的锁定,而造成在锁定的时候无法插入锁定键值范围内的任何数据。在某些场景下这可能会对性能造成很大的危害
session_1
#查询可以看到test_innodb_lock没有a为2的行
mysql> select * from test_innodb_lock;
+------+------+
| a | b |
+------+------+
| 1 | b1 |
| 3 | 3000 |
| 4 | 4000 |
| 5 | 5000 |
| 6 | 6000 |
| 7 | 7000 |
| 8 | 8000 |
| 9 | 9000 |
| 1 | b1 |
+------+------+
9 rows in set (0.00 sec)
#更新1<a<5的行,但不提交
mysql> update test_innodb_lock set b=a*20 where a>1 and a<5;
Query OK, 2 rows affected (0.00 sec)
Rows matched: 2 Changed: 2 Warnings: 0
#提交
mysql> commit;
session_2
#虽然a=2的行并不存在,依然被session_1上了行锁,导致阻塞
mysql> insert into test_innodb_lock values(2,'200');
#session_1提交后阻塞解除
mysql> insert into test_innodb_lock values(2,'200');
Query OK, 1 row affected (23.24 sec)
#提交
mysql> commit;
面试题:如何锁定一行
mysql> begin;
mysql> select * from test_innodb_lock where a=8 for update;
mysql> commit;
分析行锁
【如何分析行锁定】
通过检查InnoDB_row_lock状态变量来分析系统上的行锁的争夺情况
mysql> show status like 'innodb_row_lock%';
+-------------------------------+--------+
| Variable_name | Value |
+-------------------------------+--------+
| Innodb_row_lock_current_waits | 0 |
| Innodb_row_lock_time | 126796 |
| Innodb_row_lock_time_avg | 25359 |
| Innodb_row_lock_time_max | 50008 |
| Innodb_row_lock_waits | 5 |
+-------------------------------+--------+
5 rows in set (0.00 sec)
对各个状态量的说明如下:
Innodb_row_lock_current_waits:当前正在等待锁定的数量;
Innodb_row_lock_time:从系统启动到现在锁定总时间长度;
Innodb_row_lock_time_avg:每次等待所花平均时间;
Innodb_row_lock_time_max:从系统启动到现在等待最常的一次所花的时间;
Innodb_row_lock_waits:系统启动后到现在总共等待的次数;
对于这5个状态变量,比较重要的主要是
Innodb_row_lock_time_avg(等待平均时长),
Innodb_row_lock_waits(等待总次数)
Innodb_row_lock_time(等待总时长)这三项。
尤其是当等待次数很高,而且每次等待时长也不小的时候,我们就需要分析系统中为什么会有如此多的等待,然后根据分析结果着手指定优化计划。
最后可以通过
SELECT * FROM information_schema.INNODB_TRX\G;
来查询正在被锁阻塞的sql语句。
优化建议
1.尽可能让所有数据检索都通过索引来完成,避免无索引行锁升级为表锁。
2.尽可能较少检索条件,避免间隙锁
3.尽量控制事务大小,减少锁定资源量和时间长度
4.锁住某行后,尽量不要去调别的行或表,赶紧处理被锁住的行然后释放掉锁。
5.涉及相同表的事务,对于调用表的顺序尽量保持一致。
6.在业务环境允许的情况下,尽可能低级别事务隔离
页锁
开销和加锁时间界于表锁和行锁之间;会出现死锁;锁定粒度界于表锁和行锁之间,并发度一般。
了解一下即可
主从复制
基本原理:
slave会从master读取binlog来进行数据同步
MySQL复制过程分成三步:
1 master将改变记录到二进制日志(binary log)。这些记录过程叫做二进制日志事件,binary log events;
2 slave将master的binary log events拷贝到它的中继日志(relay log);
3 slave重做中继日志中的事件,将改变应用到自己的数据库中。 MySQL复制是异步的且串行化的
复制的基本原则:
1.每个slave只有一个master
2.每个slave只能有一个唯一的服务器ID
3.每个master可以有多个salve
复制的最大问题:延时
一主一从常见配置
1.mysql版本一致且后台以服务运行
2.主从都配置在[mysqld]结点下,都是小写
3.修改主机配置文件
#打开配置文件
$ vim /etc/mysql/mysql.conf.d/mysqld.cnf
#1.[必须]主服务器唯一ID
server-id=1
#2.[必须]启用二进制日志
log-bin=自己本地的路径/data/mysqlbin
log-bin=/home/mysql_data/mysql/binlog
#3.[可选]启用错误日志
log-error=自己本地的路径/data/mysqlerr
log-error=/var/log/mysql/error.log
#4.[可选]根目录
basedir="自己本地路径"
basedir=/home/mysql_data/
#5.[可选]临时目录
tmpdir="自己本地路径"
tmpdir=/home/mysql_data/mysql/
#6.[可选]数据目录
datadir="自己本地路径/Data/"
datadir=/home/mysql_data/mysql/
#7.read-only=0
主机,读写都可以
#8.[可选]设置不要复制的数据库
binlog-ignore-db=mysql
#9.[可选]设置需要复制的数据库
binlog-do-db=需要复制的主数据库名字
4.修改从机配置文件
在另一台linux上安装mysql作为从机
#打开配置文件
$ vim /etc/mysql/mysql.conf.d/mysqld.cnf
#1.[必须]从服务器唯一ID
server-id=2
#2.[可选]启用二进制日志
log-bin=/var/lib/mysql/binlog
5.因修改过配置文件,请主机+从机都重启后台mysql服务
6.主机从机都关闭防火墙
关闭虚拟机linux防火墙 service iptables stop
7.在主机上建立帐户并授权slave
mysql8中创建用户和授权需分别执行
#创建账户rep1
mysql> CREATE USER `rep1`@`192.168.1.223` IDENTIFIED WITH caching_sha2_password BY '123456';
#授权slave
mysql> GRANT Replication Slave ON *.* TO `rep1`@`192.168.1.223`;
#刷新
mysql> flush privileges;
#查询master的状态
mysql> show master status;
+---------------+----------+--------------+------------------+-------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+---------------+----------+--------------+------------------+-------------------+
| binlog.000019 | 3280 | | | |
+---------------+----------+--------------+------------------+-------------------+
1 row in set (0.00 sec)
#记录下FIle和Position的值
#执行完此步骤后不要再操作主服务器MYSQL,防止主服务器状态值变化
8.在Linux从机上配置需要复制的主机
#同步slave,如果之前通不过请先停止
CHANGE MASTER TO MASTER_HOST='192.168.1.224',
MASTER_USER='rep1',
MASTER_PASSWORD='123456',
MASTER_LOG_FILE='mysqlbin.000019',MASTER_LOG_POS=3280;
#启动从服务器复制功能
mysql> start slave;
9.show slave status\G
如遇问题参考:https://blog.csdn.net/qq_36756682/article/details/109647266
下面两个参数都是Yes,则说明主从配置成功!
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
10.主机新建库、新建表、insert记录,从机复制
11.如何停止从服务复制功能
stop slave;