MySQL学习笔记十六：锁机制

1.数据库锁就是为了保证数据库数据的一致性在一个共享资源被并发访问时使得数据访问顺序化的机制。MySQL数据库的锁机制比较独特，支持不同的存储引擎使用不同的锁机制。

2.MySQL使用了三种类型的锁机制，分别为：表级锁，行级锁，页级锁，它们的特性如下所示。

表级锁：实现逻辑较为简单，加锁速度快，开销小，不会发生死锁；但粒度最大，发生锁冲突的几率最大，并发度最小，适用于以查询为主，极少量更新的系统。

行级锁：加锁慢，开销大，会发生死锁；但粒度最小，锁冲突率小，并发度最高，使用于并发查询大，有大量按索引条件并发更新少量不同数据的系统。

页级锁：介于表级锁和行级锁之间。

3.MyISAM表锁

MyISAM存储引擎只支持表级锁，它的锁模式分为两种：表共享读锁和表独占写锁。MyISAM的读操作会阻塞其他用户的写操作，但不会阻塞其他用户的读操作。MyISAM的写操作会堵塞其他用户的读写操作。MyISAM的读写操作是串行的。

查询表锁的争用情况:

mysql> show status like ‘table_locks%‘;
+-----------------------+-------+
| Variable_name         | Value |
+-----------------------+-------+
| Table_locks_immediate | 51    |
| Table_locks_waited    | 0     |
+-----------------------+-------+
2 rows in set (0.00 sec)
-----Table_locks_immediate 立即释放表锁数
-----Table_locks_waited  等待表锁数，该值如较高，说明表锁争用较严重

MyISAM表写操作阻塞示例：

SESSION1 SESSION2

获取stu表的写锁

mysql> lock table stu write;
Query OK, 0 rows affected (0.03 sec)

  

可以进行查询，更新，插入操作

mysql> select * from stu;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010404 | 祝小贤 | A1012 | 20 | 1 |
| 4010405 | 肖小杰 | A1013 | 22 | 0 |
| 4010406 | 钟小喜 | A1014 | 24 | 1 |
| 4010407 | 钟小惠 | A1015 | 26 | 0 |
| 4010408 | 肖小杰 | A1114 | 21 | 1 |
| 4010409 | 钟小兆 | A1114 | 22 | 0 |
| 4010410 | 程小锦 | A1114 | 22 | 1 |
+---------+--------+-------+------+--------+
7 rows in set (0.03 sec)

mysql> update stu set gender=0 where sno=4010408;
Query OK, 1 row affected (0.11 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> select * from stu;

查询被阻塞，等待锁释放

释放表写锁

mysql> unlock tables;
Query OK, 0 rows affected (0.00 sec)

 等待
 
获得锁，查询返回

mysql> select * from stu;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010404 | 祝小贤 | A1012 | 20 | 1 |
| 4010405 | 肖小杰 | A1013 | 22 | 0 |
| 4010406 | 钟小喜 | A1014 | 24 | 1 |
| 4010407 | 钟小惠 | A1015 | 26 | 0 |
| 4010408 | 肖小杰 | A1114 | 21 | 0 |
| 4010409 | 钟小兆 | A1114 | 22 | 0 |
| 4010410 | 程小锦 | A1114 | 22 | 1 |
+---------+--------+-------+------+--------+
7 rows in set (4 min 27.54 sec)

MyISAM表加锁

MyISAM表在执行select语句前会自动给涉及的所有表加上表读锁，执行update,delete,insert等更新语句前，会自动给所有涉及的表加写锁，一般不需要显式地给表加锁。显示地给表加锁，必须要同时取得所有涉及表的锁，并且不支持锁升级。在执行lock tables后，只能访问加锁的被加锁的表，不能访问未加锁的表。示例如下：

SESSION1 SESSION2

给表stu加上读锁

mysql> lock table stu read;
Query OK, 0 rows affected (0.49 sec)

  

可以查询stu表

mysql> select * from stu limit 2;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010404 | 祝小贤 | A1012 | 20 | 1 |
| 4010405 | 肖小杰 | A1013 | 22 | 0 |
+---------+--------+-------+------+--------+
2 rows in set (0.15 sec)

  

不能查询stu以外的表

mysql> select * from student limit 2;
ERROR 1100 (HY000): Table ‘student‘ was not locked with LOCK TABLES

 可以查询或更新未锁定的表

mysql> select * from student limit 2;
+---------+-----------+--------+------+---------+
| sno | sname | sclass | sage | sgender |
+---------+-----------+--------+------+---------+
| 4010404 | zhumuxian | A1114 | 20 | 男 |
+---------+-----------+--------+------+---------+
1 row in set (0.29 sec)

不能对stu表进行insert,update等操作

mysql> update stu set gender=1 where sno=4010408;
ERROR 1099 (HY000): Table ‘stu‘ was locked with a READ lock and can‘t be updated
更新操作会被阻塞

mysql> update stu set gender=1 where sno=4010408;

释放锁

mysql> unlock tables;
Query OK, 0 rows affected (0.00 sec)

  等待
 
获得锁，更新完成

mysql> update stu set gender=1 where sno=4010408;
Query OK, 1 row affected (5 min 23.36 sec)
Rows matched: 1 Changed: 1 Warnings: 0

使用lock tables锁定表时，如果查询用到该表的别名，则须要对别名也进行锁定，否则会报错，如下所示：

mysql> lock table stu read;
Query OK, 0 rows affected (0.00 sec)

mysql> select a.sno from stu a;
ERROR 1100 (HY000): Table ‘a‘ was not locked with LOCK TABLES
mysql> lock table stu as a read;
Query OK, 0 rows affected (0.00 sec)

mysql> select a.sno from stu a;
+---------+
| sno     |
+---------+
| 4010404 |
| 4010410 |
| 4010405 |
| 4010408 |
| 4010409 |
| 4010406 |
| 4010407 |
+---------+
7 rows in set (0.00 sec)

MyISAM并发插入，总体而言，MyISAM的读写操作是串行的，在某些条件下，也是支持查询和插入操作的并发进行，MyISAMy引擎有一个系统变量concurrent_insert，可以用来控制并发插入行为，该值有6个内置值选择，如下所示：

Value Description

NEVER (or
0)

 禁止并发插入行为

AUTO (or
1)

 在没有空洞时运行并发插入

ALWAYS
(or 2)

 不管有没有空洞允许表尾并发插入

并发插入示例：

SESSION1 SESSION2

锁定表t1

mysql> lock table t1 read local;
Query OK, 0 rows affected (0.00 sec)

  

不能进行更新，删除的等操作

mysql> update t1 set id=5 where id=1;
ERROR 1099 (HY000): Table ‘t1‘ was locked with a READ lock and can‘t be updated
可以插入记录，但更新会阻塞

mysql> insert into t1 values (10);
Query OK, 1 row affected (0.12 sec)

mysql> update t1 set id=70 where id=60;

不能查看到其他session插入的数据

mysql> select * from t1;
+----+
| id |
+----+
| 1 |
| 4 |
| 30 |
| 60 |
+----+
4 rows in set (0.00 sec)

  

释放锁

mysql> unlock tables;
Query OK, 0 rows affected (0.00 sec)

  等待

可以查看其他SESSION更新的数据

mysql> select * from t1;
+----+
| id |
+----+
| 1 |
| 4 |
| 10 |
| 30 |
| 70 |
+----+
5 rows in set (0.00 sec)
更新完成

mysql> update t1 set id=70 where id=60;
Query OK, 1 row affected (7 min 44.10 sec)
Rows matched: 1 Changed: 1 Warnings: 0

MyISAM锁调度

MyISAM的读锁和写锁是互斥的，读操作和写操作是串行的，一般情况下，写进程优先获得锁，即使是读进程请求先到锁等待队列，写进程后到。这样很容易造成大量的更新操作导致查询操作被永久阻塞，不过可以通过设置low_priority_updates变量值来调节MyISAM引擎的调度机制。

在mysql服务启动时，指定low_priority_updates参数让myisam引擎默认给予读请求更高的优先。

在session中，通过set low_priority_updates来降低当前的会话写请求的优先级。

4.InnoDB锁相关

InnoDB引擎对比MyISAM引擎，最大的不同之处在于，InnoDB支持事务和行级锁。

查看行级锁争用情况

mysql> show status like ‘innodb_row_lock%‘;
+-------------------------------+-------+
| Variable_name                 | Value |
+-------------------------------+-------+
| Innodb_row_lock_current_waits | 0     |
| Innodb_row_lock_time          | 0     |
| Innodb_row_lock_time_avg      | 0     |
| Innodb_row_lock_time_max      | 0     |
| Innodb_row_lock_waits         | 0     |
+-------------------------------+-------+
5 rows in set (0.00 sec)
-------如果Innodb_row_lock_waits和Innodb_row_lock_time_avg值较高，则说明行级锁争用比较严重

InnoDB行锁分为两种类型：共享锁和排他锁。

共享锁：允许一个事务去读一行，阻止其他事务获得相同数据集的排他锁。

给记录集加共享锁，前提是当前没有线程对该结果集中的任何行使用排他锁，否则申请会阻塞，方式如下：

SELECT * FROM table_name WHERE ... LOCK IN SHARE MODE
mysql> select * from stu lock in share mode;

使用共享锁线程可对其锁定记录进行读取，其他线程同样也可对锁定记录进行读取操作，并且这两个线程读取的数据都属于同一个版本。

对于写入操作，使用共享锁的线程需要分情况讨论，当只有当前线程对指定记录使用共享锁时，线程是可对该记录进行写入操作（包括更新与删除），这是由于在写入操作前，线程向该记录申请了排他锁，然后才进行写入操作；当其他线程也对该记录使用共享锁时，则不可进行写入操作，系统会有报错提示。不对锁定记录使用共享锁的线程，当然是不可进行写入操作了，写入操作会阻塞。

使用共享锁线程可再次对锁定记录申请共享锁，系统并不报错，但是操作本身并没有太大意义。其他线程同样也可以对锁定记录申请共享锁。

使用共享锁进程可对其锁定记录申请排他锁；而其他进程是不可以对锁定记录申请排他锁，申请会阻塞。

示例如下：

SESSION1 SESSION2

对stu表所有记录加共享锁

mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from stu lock in share mode;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010404 | 祝小贤 | A1012 | 20 | 1 |
| 4010405 | 肖小杰 | A1013 | 22 | 0 |
| 4010406 | 钟小喜 | A1014 | 24 | 1 |
| 4010407 | 钟小惠 | A1015 | 26 | 0 |
| 4010408 | 肖小杰 | A1114 | 21 | 0 |
| 4010409 | 钟小兆 | A1114 | 22 | 0 |
| 4010410 | 程小锦 | A1114 | 22 | 1 |
+---------+--------+-------+------+--------+
7 rows in set (0.00 sec)

  
 
可以对加锁记录进行读取操作，且也可以对该记录加共享锁

mysql> select * from stu lock in share mode;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010404 | 祝小贤 | A1012 | 20 | 1 |
| 4010405 | 肖小杰 | A1013 | 22 | 0 |
| 4010406 | 钟小喜 | A1014 | 24 | 1 |
| 4010407 | 钟小惠 | A1015 | 26 | 0 |
| 4010408 | 肖小杰 | A1114 | 21 | 0 |
| 4010409 | 钟小兆 | A1114 | 22 | 0 |
| 4010410 | 程小锦 | A1114 | 22 | 1 |
+---------+--------+-------+------+--------+
7 rows in set (0.00 sec)

对锁定记录进行更新操作，等待锁

mysql> update stu set gender=0 where sno=4010406;

  
 
也对锁定记录进行更新操作，发生死锁

mysql> update stu set gender=0 where sno=4010406;
ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction

获得锁，更新完成

mysql> update stu set gender=0 where sno=4010406;
Query OK, 1 row affected (10.07 sec)
Rows matched: 1 Changed: 1 Warnings: 0

  

排他锁：允许获得排他锁的事务更新数据，阻止其他事务取得相同数据集的共享读锁和排他写锁。

给记录集添加排他锁，前提是当前没有线程对该结果集中的任何行使用排他锁或共享锁，否则申请会阻塞。方式如下：

SELECT * FROM table_name WHERE ... FOR UPDATE
mysql> select * from stu for update;

使用排他锁线程可以对其锁定记录进行读取，读取的内容为当前事物的最新版本；而对于不使用排他锁的线程，同样是可以进行读取操作，这种特性是一致性非锁定读。

使用排他锁线程可对其锁定记录进行写入操作；对于不使用排他锁的线程，对锁定记录的写操作是不允许的，请求会阻塞。

使用排他锁进程可对其锁定记录申请共享锁，但是申请共享锁之后，线程并不会释放原先的排他锁，因此该记录对外表现出排他锁的性质；其他线程是不可对已锁定记录申请共享锁，请求会阻塞。

使用排他锁进程可对其锁定记录申请排他锁（实际上并没有任何意义）；而其他进程是不可对锁定记录申请排他锁，申请会阻塞。

示例如下：

SESSION1 SESSION2

对表stu所有记录加排他锁

mysql> select * from stu for update;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010404 | 祝小贤 | A1012 | 20 | 1 |
| 4010405 | 肖小杰 | A1013 | 22 | 0 |
| 4010406 | 钟小喜 | A1014 | 24 | 0 |
| 4010407 | 钟小惠 | A1015 | 26 | 0 |
| 4010408 | 肖小杰 | A1114 | 21 | 0 |
| 4010409 | 钟小兆 | A1114 | 22 | 0 |
| 4010410 | 程小锦 | A1114 | 22 | 1 |
+---------+--------+-------+------+--------+
7 rows in set (0.00 sec)

  
 
以查询该记录，但是不能对该记录加排他锁，会等待获得锁

mysql> select * from stu;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010404 | 祝小贤 | A1012 | 20 | 1 |
| 4010405 | 肖小杰 | A1013 | 22 | 0 |
| 4010406 | 钟小喜 | A1014 | 24 | 1 |
| 4010407 | 钟小惠 | A1015 | 26 | 0 |
| 4010408 | 肖小杰 | A1114 | 21 | 0 |
| 4010409 | 钟小兆 | A1114 | 22 | 0 |
| 4010410 | 程小锦 | A1114 | 22 | 1 |
+---------+--------+-------+------+--------+
7 rows in set (0.00 sec)

mysql> select * from stu for update;

可以对锁定记录进行更新，完成后锁释放

mysql> update stu set gender=1 where sno=4010406;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0

mysql> commit;
Query OK, 0 rows affected (0.00 sec)

  
 
获取锁，返回查询记录并加上排他锁

mysql> select * from stu for update;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010404 | 祝小贤 | A1012 | 20 | 1 |
| 4010405 | 肖小杰 | A1013 | 22 | 0 |
| 4010406 | 钟小喜 | A1014 | 24 | 1 |
| 4010407 | 钟小惠 | A1015 | 26 | 0 |
| 4010408 | 肖小杰 | A1114 | 21 | 0 |
| 4010409 | 钟小兆 | A1114 | 22 | 0 |
| 4010410 | 程小锦 | A1114 | 22 | 1 |
+---------+--------+-------+------+--------+
7 rows in set (7.65 sec)

InnoDB行锁实现方式：InnoDB行锁是通过给索引上的索引项加锁来实现的，这一点MySQL与Oracle不同，后者是通过在数据块中对相应数据行加锁来实现的。InnoDB这种行锁实现特点意味着：只有通过索引条件检索数据，InnoDB才使用行级锁，否则，InnoDB将使用表锁！

表stu的索引如下所示：

mysql> show index from stu\G
*************************** 1. row ***************************
        Table: stu
   Non_unique: 0
     Key_name: PRIMARY
 Seq_in_index: 1
  Column_name: sno
    Collation: A
  Cardinality: 7
     Sub_part: NULL
       Packed: NULL
         Null:
   Index_type: BTREE
      Comment:
Index_comment:
*************************** 2. row ***************************
        Table: stu
   Non_unique: 1
     Key_name: idx_name
 Seq_in_index: 1
  Column_name: sname
    Collation: A
  Cardinality: 7
     Sub_part: NULL
       Packed: NULL
         Null: YES
   Index_type: BTREE
      Comment:
Index_comment:

不使用索引时，会使用表所，示例如下：

SESSION1 SESSION2

给gender=0的记录加上排他锁

mysql> select * from stu where gender=0 for update;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010405 | 肖小杰 | A1013 | 22 | 0 |
| 4010407 | 钟小惠 | A1015 | 26 | 0 |
| 4010408 | 肖小杰 | A1114 | 21 | 0 |
| 4010409 | 钟小兆 | A1114 | 22 | 0 |
+---------+--------+-------+------+--------+

  
 
给gender=1的记录加排他锁，被阻塞

mysql> select * from stu where gender=1 for update;

使用索引检索时，使用行锁，示例如下：

SESSION1 SESSION2

给sname="祝小贤"的记录加上排他锁

mysql> select * from stu where sname=‘祝小贤‘ for update;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010404 | 祝小贤 | A1012 | 20 | 1 |
+---------+--------+-------+------+--------+

  
 
给sname="程小锦"的记录加上排他锁

mysql> select * from stu where sname=‘程小锦‘ for update;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010410 | 程小锦 | A1114 | 22 | 1 |
+---------+--------+-------+------+--------+
1 row in set (0.04 sec)

由于MySQL的行锁是针对索引加的锁，不是针对记录加的锁，所以虽然是访问不同行的记录，但是如果是使用相同的索引键，是会出现锁冲突的。如下所示：

SESSION1 SESSION2

给sname="祝小贤"和age=20的记录加上排他锁

mysql> select * from stu where sno=4010404 and age=20 for update;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010404 | 祝小贤 | A1012 | 20 | 1 |
+---------+--------+-------+------+--------+

  
 
给sname="祝小贤"和age=21的记录加上排他锁，发生阻塞

mysql> select * from stu where sno=4010404 and age=21 for update;

即便在条件中使用了索引字段，但是否使用索引来检索数据是由MySQL通过判断不同执行计划的代价来决定的，如果MySQL认为全表扫描效率更高，比如对一些很小的表，它就不会使用索引，这种情况下InnoDB将使用表锁，而不是行锁。因此，在分析锁冲突时，别忘了检查SQL的执行计划，以确认是否真正使用了索引。

间隙锁

当我们用范围条件而不是相等条件检索数据，并请求共享或排他锁时，InnoDB会给符合条件的已有数据记录的索引项加锁；对于键值在条件范围内但并不存在的记录，叫做“间隙（GAP)”，InnoDB也会对这个“间隙”加锁，这种锁机制就是所谓的间隙锁（Next-Key锁）。

举例来说，假如emp表中只有101条记录，其empid的值分别是 1,2,...,100,101，下面的SQL：

Select * from  emp where empid > 100 for update;

是一个范围条件的检索，InnoDB不仅会对符合条件的empid值为101的记录加锁，也会对empid大于101（这些记录并不存在）的“间隙”加锁。

InnoDB使用间隙锁的目的，一方面是为了防止幻读，以满足相关隔离级别的要求，对于上面的例子，要是不使用间隙锁，如果其他事务插入了empid大于100的任何记录，那么本事务如果再次执行上述语句，就会发生幻读；另外一方面，是为了满足其恢复和复制的需要。

如下所示：

   

给sno>4010409的记录加排他锁

mysql> select * from stu where sno>4010409 for update;
+---------+--------+-------+------+--------+
| sno | sname | class | age | gender |
+---------+--------+-------+------+--------+
| 4010410 | 程小锦 | A1114 | 22 | 1 |
+---------+--------+-------+------+--------+
1 row in set (0.03 sec)

  
 
向stu中插入一条

mysql> insert into stu values (4010411,‘zhangsan‘,‘A1114‘,30,1);

释放next-key锁

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)

  
 
更新成功

mysql> insert into stu values (4010411,‘zhangsan‘,‘A1114‘,30,1);
Query OK, 1 row affected (27.06 sec)

使用insert into tbl_name select * from tbl_name或create table tbl_name as select * from tbl_name语句时，innodb会自动对源表加上共享锁。

时间： 2024-07-31 00:07:25

MySQL学习笔记十六：锁机制的相关文章

Mysql学习笔记（六）增删改查

原文:Mysql学习笔记(六)增删改查 PS:数据库最基本的操作就是增删改查了... 学习内容: 数据库的增删改查 1.增...其实就是向数据库中插入数据.. 插入语句 insert into table_name values("要插入的数据"); 比如说,我们先创建一个宠物表,用来记录宠物的基本信息以及所有者... create table pet ( name varchar(20), owner varchar(20), species varchar(20), sex cha

C++学习笔记十六-模板和泛型编程(二)

C++学习笔记十六-模板和泛型编程(二) 16.4 类模板成员 1.模板作用域中模板类型的引用: 通常,当使用类模板的名字的时候,必须指定模板形参.这一规则有个例外:在类本身的作用域内部,可以使用类模板的非限定名.例如,在默认构造函数和复制构造函数的声明中,名字 Queue 是 Queue<Type> 缩写表示.实质上,编译器推断,当我们引用类的名字时,引用的是同一版本.因此,复制构造函数定义其实等价于: Queue<Type>(const Queue<Type> &a

MYSQL进阶学习笔记十六：MySQL 监控！（视频序号：进阶_35)

知识点十六:MySQL监控(35) 一.为什么使用MySQL监控 随着软件后期的不断升级,myssql的服务器数量越来越多,软硬件故障的发生概率也越来越高.这个时候就需要一套监控系统,当主机发生异常时,此时通过监控系统发现和处理. 这个监控实际上是在我们的开发完成之后,这个时候软件就开始在运行,这个运行我们就需要去关注到mysql服务器是否正常,那么我们要观察它就需要给它提供一些监控,这监控就是当它发生故障之后, 那么我们这个监控就会告诉我们到底什么地方发生了一些异常或者一些错误,这个时候我们就

马哥学习笔记十六——MySQL进阶之事务和隔离级别

连接管理器:  接受请求  创建线程  认证用户  建立安全连接 并发控制: mbox:MDA C/S: 100   10分钟: 多版本并发控制: MVCC 锁: 读锁:共享锁 写锁:独占锁 LOCK TABLES tb_name {READ|WRITE}; UNLOCK TABLES 锁粒度:从大到小,MySQL服务器仅支持表级锁,行锁需要由存储引擎完成: 表锁: 页锁:(block) 行锁: 事务:  RDBMS: ACID (原子性,一致性,隔离性,持久性) MyISAM:  不支持事务

python学习笔记十六 django深入学习一

django 请求流程图 django 路由系统 在django中我们可以通过定义urls,让不同的url路由到不同的处理函数 from . import views urlpatterns = [ url(r'^articles/2003/$', views.special_case_2003), #精确匹配 url(r'^articles/([0-9]{4})/$', views.year_archive), #动态路由 url(r'^articles/([0-9]{4})/([0-9]{2

MySQL学习笔记（六）—— MySQL自连接

有的时候我们需要对同一表中的数据进行多次检索,这个时候我们可以使用之前学习过的子查询,先查询出需要的数据,再进行一次检索. 例如:一张products表,有产品id,供应商id(vend_id),产品名称等等. mysql> select * from products; +---------+---------+-----------+------------+-----------+ | prod_id | vend_id | prod_name | prod_price | prod_de

MySQL学习笔记十二：数据备份与恢复

数据备份 1.物理备份与逻辑备份 物理备份 物理备份就是将数据库的数据文件,配置文件,日志文件等复制一份到其他路径上,这种备份速度一般较快,因为只有I/O操作.进行物理备份时,一般都需要关闭mysql服务器,或者对需要备份的对象进行锁定,要不很容易造成备份的不一致性,恢复时可能会丢失数据.物理备份的方式有很多,如操作系统命令copy(cp),scp,mysqlbackup,以及MyISAM表的mysqlhotcopy. 逻辑备份 逻辑备份是对数据库的逻辑结构(create database,cr

一千行MySQL学习笔记（六）

/* 备份与还原 */ ------------- 备份,将数据的结构与表内数据保存起来. 利用 mysqldump 指令完成. -- 导出 1. 导出一张表 mysqldump -u用户名 -p密码 库名 表名 > 文件名(D:/a.sql)2. 导出多张表 mysqldump -u用户名 -p密码 库名 表1 表2 表3 > 文件名(D:/a.sql)3. 导出所有表 mysqldump -u用户名 -p密码 库名 > 文件名(D:/a.sql)4. 导出一个库 mysqldump

Redis学习笔记~Redis并发锁机制

回到目录 redis客户端驱动有很多,如ServiceStack.Redis,StackExchange.Redis等等,下面我使用ServiceStack.Redis为例,介绍一下在redis驱动中实现并发锁的方式,并发就是多线程同时访问和操作同一个资源,而对于redis来说,如果你多个线程共同修改一个key的value,这时就会出现并发,为了保证数据完整性,这时需要使用并发锁,在各大语言中,都有自己的实现方法,无论的C,C#,java还是sqlserver都有这个概念! using (IRe