mysql 锁

MySQL InnoDB 实现的是基于多版本的并发控制协议——MVCC (Multi-Version Concurrency Control) (注：与MVCC相对的，是基于锁的并发控制，Lock-Based Concurrency Control)。MVCC的特点是读的时候不加锁，所以读写不冲突，所以会增加并发能力，所以大部分关系型数据库都支持MVCC。

不过也不是所有的读都不加锁，读操作分为两种。
1. 快照读(snapshot read) 简单的select操作，属于快照读，不加锁
select * from table where
2. 当前读(current read) 特殊的读操作，插入/更新/删除操作，属于当前读，需要加锁。

select * from table where ? lock in share mode; 
select * from table where ? for update;
insert into table values (…);
update table set ? where ?;
delete from table where ?;

除了第一个是加S锁 (共享锁)外，其他的操作，都加的是X锁 (排它锁)

从图中，可以看到，一个Update操作的具体流程。当Update SQL被发给MySQL后，MySQL Server会根据where条件，读取第一条满足条件的记录，然后InnoDB引擎会将第一条记录返回，并加锁 (current read)。待MySQL Server收到这条加锁的记录之后，会再发起一个Update请求，更新这条记录。一条记录操作完成，再读取下一条记录，直至没有满足条件的记录为止。因此，Update操作内部，就包含了一个当前读。同理，Delete操作也一样。Insert操作会稍微有些不同，简单来说，就是Insert操作可能会触发Unique Key的冲突检查，也会进行一个当前读。

注：根据上图的交互，针对一条当前读的SQL语句，InnoDB与MySQL Server的交互，是一条一条进行的，因此，加锁也是一条一条进行的。先对一条满足条件的记录加锁，返回给MySQL Server，做一些DML操作；然后在读取下一条加锁，直至读取完毕。

聚簇索引 cluster index

InnoDB存储引擎的数据组织方式，是聚簇索引表：完整的记录，存储在主键索引中，通过主键索引，就可以获取记录所有的列。

2pl: Two-Phase Locking

传统RDBMS加锁的一个原则，就是2PL (二阶段锁)：Two-Phase Locking。相对而言，2PL比较容易理解，说的是锁操作分为两个阶段：加锁阶段与解锁阶段，并且保证加锁阶段与解锁阶段不相交。下面，仍旧以MySQL为例，来简单看看2PL在MySQL中的实现。

从上图可以看出，2PL就是将加锁/解锁分为两个完全不相交的阶段。加锁阶段：只加锁，不放锁。解锁阶段：只放锁，不加锁。

隔离级别 lsolation level

Read Uncommited，Read Committed，Repeatable Read，Serializable
– Read Uncommited
可以读取未提交记录。此隔离级别，不会使用，忽略。
– Read Committed (RC)
快照读忽略，本文不考虑。
针对当前读，RC隔离级别保证对读取到的记录加锁 (记录锁)，存在幻读现象。
– Repeatable Read (RR)
快照读忽略，本文不考虑。
针对当前读，RR隔离级别保证对读取到的记录加锁 (记录锁)，同时保证对读取的范围加锁，新的满足查询条件的记录不能够插入 (间隙锁)，不存在幻读现象。
– Serializable
从MVCC并发控制退化为基于锁的并发控制。不区别快照读与当前读，所有的读操作均为当前读，读加读锁 (S锁)，写加写锁 (X锁)。

Serializable隔离级别下，读写冲突，因此并发度急剧下降，在MySQL/InnoDB下不建议使用。

实践一条简单SQL的加锁实现分析

SQL1：select * from t1 where id = 10;
SQL2：delete from t1 where id = 10;

这个SQL加什么锁？就如同下面两条简单的SQL，他们加什么锁？
针对这个问题，该怎么回答？我能想象到的一个答案是：

SQL1：不加锁。因为MySQL是使用多版本并发控制的，读不加锁。
SQL2：对id = 10的记录加写锁 (走主键索引)。

必须还要知道以下的一些前提，前提不同，能给出的答案也就不同
前提一：id列是不是主键？
前提二：当前系统的隔离级别是什么？
前提三：id列如果不是主键，那么id列上有索引吗？
前提四：id列上如果有二级索引，那么这个索引是唯一索引吗？
前提五：两个SQL的执行计划是什么？索引扫描？全表扫描？

下面的这些组合，我做了一个前提假设，也就是有索引时，执行计划一定会选择使用索引进行过滤 (索引扫描)。但实际情况会复杂很多，真正的执行计划，还是需要根据MySQL输出的为准。

组合一：id列是主键，RC隔离级别

只需要将主键上，id = 10的记录加上X锁即可

组合二：id列是二级唯一索引，RC隔离级别

此组合中，id是unique索引，而主键是name列。此时，加锁的情况由于组合一有所不同。由于id是unique索引，因此delete语句会选择走id列的索引进行where条件的过滤，在找到id=10的记录后，首先会将unique索引上的id=10索引记录加上X锁，同时，会根据读取到的name列，回主键索引(聚簇索引)，然后将聚簇索引上的name = ‘d’ 对应的主键索引项加X锁。为什么聚簇索引上的记录也要加锁？试想一下，如果并发的一个SQL，是通过主键索引来更新：update t1 set id = 100 where name = ‘d’; 此时，如果delete语句没有将主键索引上的记录加锁，那么并发的update就会感知不到delete语句的存在，违背了同一记录上的更新/删除需要串行执行的约束。

结论：若id列是unique列，其上有unique索引。那么SQL需要加两个X锁，一个对应于id unique索引上的id = 10的记录，另一把锁对应于聚簇索引上的[name=’d’,id=10]的记录。

组合三：id列是二级非唯一索引，RC隔离级别

根据此图，可以看到，首先，id列索引上，满足id = 10查询条件的记录，均已加锁。同时，这些记录对应的主键索引上的记录也都加上了锁。与组合二唯一的区别在于，组合二最多只有一个满足等值查询的记录，而组合三会将所有满足查询条件的记录都加锁。

结论：若id列上有非唯一索引，那么对应的所有满足SQL查询条件的记录，都会被加锁。同时，这些记录在主键索引上的记录，也会被加锁。

组合四：id列上没有索引，RC隔离级别

由于id列上没有索引，因此只能走聚簇索引，进行全部扫描。从图中可以看到，满足删除条件的记录有两条，但是，聚簇索引上所有的记录，都被加上了X锁。无论记录是否满足条件，全部被加上X锁。既不是加表锁，也不是在满足条件的记录上加行锁。

有人可能会问？为什么不是只在满足条件的记录上加锁呢？这是由于MySQL的实现决定的。如果一个条件无法通过索引快速过滤，那么存储引擎层面就会将所有记录加锁后返回，然后由MySQL Server层进行过滤。因此也就把所有的记录，都锁上了。

注：在实际的实现中，MySQL有一些改进，在MySQL Server过滤条件，发现不满足后，会调用unlock_row方法，把不满足条件的记录放锁 (违背了2PL的约束)。这样做，保证了最后只会持有满足条件记录上的锁，但是每条记录的加锁操作还是不能省略的。

结论：若id列上没有索引，SQL会走聚簇索引的全扫描进行过滤，由于过滤是由MySQL Server层面进行的。因此每条记录，无论是否满足条件，都会被加上X锁。但是，为了效率考量，MySQL做了优化，对于不满足条件的记录，会在判断后放锁，最终持有的，是满足条件的记录上的锁，但是不满足条件的记录上的加锁/放锁动作不会省略。同时，优化也违背了2PL的约束。

组合五：id列是主键，RR隔离级别

加锁与RC一致

组合六：id列是二级唯一索引，RR隔离级别

加锁与RC一致

组合七：id列是二级非唯一索引，RR隔离级别

还记得前面提到的MySQL的四种隔离级别的区别吗？RC隔离级别允许幻读，而RR隔离级别，不允许存在幻读。但是在组合五、组合六中，加锁行为又是与RC下的加锁行为完全一致。那么RR隔离级别下，如何防止幻读呢？问题的答案，就在组合七中揭晓。

组合七，Repeatable Read隔离级别，id上有一个非唯一索引，执行delete from t1 where id = 10; 假设选择id列上的索引进行条件过滤，最后的加锁行为，是怎么样的呢？同样看下面这幅图：

此图，相对于组合三：[id列上非唯一锁，Read Committed]看似相同，其实却有很大的区别。最大的区别在于，这幅图中多了一个GAP锁，而且GAP锁看起来也不是加在记录上的，倒像是加载两条记录之间的位置，GAP锁有何用？

其实这个多出来的GAP锁，就是RR隔离级别，相对于RC隔离级别，不会出现幻读的关键。确实，GAP锁锁住的位置，也不是记录本身，而是两条记录之间的GAP。所谓幻读，就是同一个事务，连续做两次当前读 (例如：select * from t1 where id = 10 for update;)，那么这两次当前读返回的是完全相同的记录 (记录数量一致，记录本身也一致)，第二次的当前读，不会比第一次返回更多的记录 (幻象)。

如何保证两次当前读返回一致的记录，那就需要在第一次当前读与第二次当前读之间，其他的事务不会插入新的满足条件的记录并提交。为了实现这个功能，GAP锁应运而生。

如图中所示，有哪些位置可以插入新的满足条件的项 (id = 10)，考虑到B+树索引的有序性，满足条件的项一定是连续存放的。记录[6,c]之前，不会插入id=10的记录；[6,c]与[10,b]间可以插入[10, aa]；[10,b]与[10,d]间，可以插入新的[10,bb],[10,c]等；[10,d]与[11,f]间可以插入满足条件的[10,e],[10,z]等；而[11,f]之后也不会插入满足条件的记录。因此，为了保证[6,c]与[10,b]间，[10,b]与[10,d]间，[10,d]与[11,f]不会插入新的满足条件的记录，MySQL选择了用GAP锁，将这三个GAP给锁起来。

Insert操作，如insert [10,aa]，首先会定位到[6,c]与[10,b]间，然后在插入前，会检查这个GAP是否已经被锁上，如果被锁上，则Insert不能插入记录。因此，通过第一遍的当前读，不仅将满足条件的记录锁上 (X锁)，与组合三类似。同时还是增加3把GAP锁，将可能插入满足条件记录的3个GAP给锁上，保证后续的Insert不能插入新的id=10的记录，也就杜绝了同一事务的第二次当前读，出现幻象的情况。

GAP锁的目的，是为了防止同一事务的两次当前读，出现幻读的情况。而组合五，id是主键；组合六，id是unique键，都能够保证唯一性。一个等值查询，最多只能返回一条记录，而且新的相同取值的记录，一定不会在新插入进来，因此也就避免了GAP锁的使用。其实，针对此问题，还有一个更深入的问题：如果组合五、组合六下，针对SQL：select * from t1 where id = 10 for update; 第一次查询，没有找到满足查询条件的记录，那么GAP锁是否还能够省略？此问题留给大家思考。

结论：Repeatable Read隔离级别下，id列上有一个非唯一索引，对应SQL：delete from t1 where id = 10; 首先，通过id索引定位到第一条满足查询条件的记录，加记录上的X锁，加GAP上的GAP锁，然后加主键聚簇索引上的记录X锁，然后返回；然后读取下一条，重复进行。直至进行到第一条不满足条件的记录[11,f]，此时，不需要加记录X锁，但是仍旧需要加GAP锁，最后返回结束。

组合八：id列上没有索引，RR隔离级别

如图，这是一个很恐怖的现象。首先，聚簇索引上的所有记录，都被加上了X锁。其次，聚簇索引每条记录间的间隙(GAP)，也同时被加上了GAP锁。这个示例表，只有6条记录，一共需要6个记录锁，7个GAP锁。试想，如果表上有1000万条记录呢？

在这种情况下，这个表上，除了不加锁的快照度，其他任何加锁的并发SQL，均不能执行，不能更新，不能删除，不能插入，全表被锁死。

当然，跟组合四：[id无索引, Read Committed]类似，这个情况下，MySQL也做了一些优化，就是所谓的semi-consistent read。semi-consistent read开启的情况下，对于不满足查询条件的记录，MySQL会提前放锁。针对上面的这个用例，就是除了记录[d,10]，[g,10]之外，所有的记录锁都会被释放，同时不加GAP锁。semi-consistent read如何触发：要么是read committed隔离级别；要么是Repeatable Read隔离级别，同时设置了innodb_locks_unsafe_for_binlog 参数。

结论：在Repeatable Read隔离级别下，如果进行全表扫描的当前读，那么会锁上表中的所有记录，同时会锁上聚簇索引内的所有GAP，杜绝所有的并发更新/删除/插入操作。当然，也可以通过触发semi-consistent read，来缓解加锁开销与并发影响，但是semi-consistent read本身也会带来其他问题，不建议使用。

组合九：Serializable隔离级别

针对前面提到的简单的SQL，最后一个情况：Serializable隔离级别。对于SQL2：delete from t1 where id = 10; 来说，Serializable隔离级别与Repeatable Read隔离级别完全一致，因此不做介绍。

Serializable隔离级别，影响的是SQL1：select * from t1 where id = 10; 这条SQL，在RC，RR隔离级别下，都是快照读，不加锁。但是在Serializable隔离级别，SQL1会加读锁，也就是说快照读不复存在，MVCC并发控制降级为Lock-Based CC。

结论：在MySQL/InnoDB中，所谓的读不加锁，并不适用于所有的情况，而是隔离级别相关的。Serializable隔离级别，读不加锁就不再成立，所有的读操作，都是当前读。

一条复杂的SQL

Index key：pubtime > 1 and puptime < 20。此条件，用于确定SQL在idx_t1_pu索引上的查询范围。

Index Filter：userid = ‘hdc’ 。此条件，可以在idx_t1_pu索引上进行过滤，但不属于Index Key。
Table Filter：comment is not NULL。此条件，在idx_t1_pu索引上无法过滤，只能在聚簇索引上过滤。

从图中可以看出，在Repeatable Read隔离级别下，由Index Key所确定的范围，被加上了GAP锁；Index Filter锁给定的条件 (userid = ‘hdc’)何时过滤，视MySQL的版本而定，在MySQL 5.6版本之前，不支持Index Condition Pushdown(ICP)，因此Index Filter在MySQL Server层过滤，在5.6后支持了Index Condition Pushdown，则在index上过滤。若不支持ICP，不满足Index Filter的记录，也需要加上记录X锁，若支持ICP，则不满足Index Filter的记录，无需加记录X锁 (图中，用红色箭头标出的X锁，是否要加，视是否支持ICP而定)；而Table Filter对应的过滤条件，则在聚簇索引中读取后，在MySQL Server层面过滤，因此聚簇索引上也需要X锁。最后，选取出了一条满足条件的记录[8,hdc,d,5,good]，但是加锁的数量，要远远大于满足条件的记录数量。

结论：在Repeatable Read隔离级别下，针对一个复杂的SQL，首先需要提取其where条件。Index Key确定的范围，需要加上GAP锁；Index Filter过滤条件，视MySQL版本是否支持ICP，若支持ICP，则不满足Index Filter的记录，不加X锁，否则需要X锁；Table Filter过滤条件，无论是否满足，都需要加X锁。

事务的概念
事务的概念来自于两个独立的需求：并发数据库访问，系统错误恢复。

一个事务是可以被看作一个单元的一系列SQL语句的集合。

事务的特性（ACID）
A, atomacity 原子性事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行。通常，与某个事务关联的操作具有共同的目标，并且是相互依赖的。如果系统只执行这些操作的一个子集，则可能会破坏事务的总体目标。原子性消除了系统处理操作子集的可能性。

C, consistency 一致性

事务将数据库从一种一致状态转变为下一种一致状态。也就是说，事务在完成时，必须使所有的数据都保持一致状态（各种 constraint 不被破坏）。

I, isolation 隔离性由并发事务所作的修改必须与任何其它并发事务所作的修改隔离。事务查看数据时数据所处的状态，要么是另一并发事务修改它之前的状态，要么是另一事务修改它之后的状态，事务不会查看中间状态的数据。换句话说，一个事务的影响在该事务提交前对其他事务都不可见。

D, 持久性

事务完成之后，它对于系统的影响是永久性的。该修改即使出现致命的系统故障也将一直保持。

事务的隔离级别
如果不对数据库进行并发控制，可能会产生异常情况：

脏读(Dirty Read)

当一个事务读取另一个事务尚未提交的修改时，产生脏读。

同一事务内不是脏读。一个事务开始读取了某行数据，但是另外一个事务已经更新了此数据但没有能够及时提交。这是相当危险的，因为很可能所有的操作都被回滚，也就是说读取出的数据其实是错误的。

非重复读(Nonrepeatable Read)一个事务对同一行数据重复读取两次，但是却得到了不同的结果。同一查询在同一事务中多次进行，由于其他提交事务所做的修改或删除，每次返回不同的结果集，此时发生非重复读。

幻像读(Phantom Reads)事务在操作过程中进行两次查询，第二次查询的结果包含了第一次查询中未出现的数据（这里并不要求两次查询的SQL语句相同）。这是因为在两次查询过程中有另外一个事务插入数据造成的。

当对某行执行插入或删除操作，而该行属于某个事务正在读取的行的范围时，会发生幻像读问题。

丢失修改(Lost Update)

第一类：当两个事务更新相同的数据源，如果第一个事务被提交，第二个却被撤销，那么连同第一个事务做的更新也被撤销。

第二类：有两个并发事务同时读取同一行数据，然后其中一个对它进行修改提交，而另一个也进行了修改提交。这就会造成第一次写操作失效。

为了兼顾并发效率和异常控制，在标准SQL规范中，定义了4个事务隔离级别，（ Oracle 和 SQL Server 对标准隔离级别有不同的实现）

未提交读(Read Uncommitted)

直译就是”读未提交”，意思就是即使一个更新语句没有提交，但是别的事务可以读到这个改变。

Read Uncommitted允许脏读。

已提交读(Read Committed)

直译就是”读提交”，意思就是语句提交以后，即执行了 Commit 以后别的事务就能读到这个改变，只能读取到已经提交的数据。Oracle等多数数据库默认都是该级别。

Read Commited 不允许脏读，但会出现非重复读。

可重复读(Repeatable Read)：

直译就是”可以重复读”，这是说在同一个事务里面先后执行同一个查询语句的时候，得到的结果是一样的。

Repeatable Read 不允许脏读，不允许非重复读，但是会出现幻象读。

串行读(Serializable)

直译就是”序列化”，意思是说这个事务执行的时候不允许别的事务并发执行。完全串行化的读，每次读都需要获得表级共享锁，读写相互都会阻塞。

Serializable 不允许不一致现象的出现。

事务隔离的实现——锁
共享锁(S锁)

用于只读操作(SELECT)，锁定共享的资源。共享锁不会阻止其他用户读，但是阻止其他的用户写和修改。

更新锁(U锁)

用于可更新的资源中。防止当多个会话在读取、锁定以及随后可能进行的资源更新时发生常见形式的死锁。

独占锁(X锁，也叫排他锁)

一次只能有一个独占锁用在一个资源上，并且阻止其他所有的锁包括共享缩。写是独占锁，可以有效的防止“脏读”。

Read Uncommited 如果一个事务已经开始写数据，则另外一个数据则不允许同时进行写操作，但允许其他事务读此行数据。该隔离级别可以通过“排他写锁”实现。

Read Committed 读取数据的事务允许其他事务继续访问该行数据，但是未提交的写事务将会禁止其他事务访问该行。可以通过“瞬间共享读锁”和“排他写锁”实现。

Repeatable Read 读取数据的事务将会禁止写事务（但允许读事务），写事务则禁止任何其他事务。可以通过“共享读锁”和“排他写锁”实现。

Serializable 读加共享锁，写加排他锁，读写互斥。

All posts

2024-01-02 16:34:31 分享一个hyperf的grpc 日志切面
2023-10-20 10:04:42 常用便捷linux命令
2023-06-20 23:36:28 自动化部署流程
2023-06-06 15:19:37 快速清空MySQL的一张表
2023-04-11 15:06:39 MySQL事务的四大特性以及实现原理
2023-03-31 10:06:44 使用GitLab CI/CD的基本步骤
2022-09-30 15:58:36 git 脑图
2022-04-18 17:18:25 phpstan 使用指南
2021-06-19 17:02:51 wsl/wsl2 和proxifier 冲突解决
2021-04-10 18:23:27 进程间有哪些通信方式
2021-03-29 18:29:11 go学习笔记
2021-03-27 21:30:54 slice 实现原理及使用技巧
2021-03-24 12:47:38 mysql 锁
2021-03-24 12:45:23 子弹redis
2020-12-18 14:40:19 go 得到程序运行的垃圾收集器更多细节
2020-12-05 15:44:20 进程小工具
2020-11-17 16:26:54 mongodb的一些查询
2020-11-08 17:43:56 composer 2
2020-05-18 21:32:04 gitlab的介绍和安装
2020-05-04 16:34:19 redis的持久化和选择
2020-04-13 00:56:47 跳表 skip list
2020-04-06 23:30:28 MySQL主从备份
2020-04-06 23:30:00 MySQL处理常见需求
2020-04-06 23:29:05 MySQL设计规范
2020-04-01 01:49:50 排序算法
2020-03-30 01:26:59 docker的镜像与容器
2020-03-28 21:43:07 docker 安装
2020-03-26 01:54:26 看操作系统_清华大学(向勇、陈渝) 笔记 1.2 1.3
2020-03-02 15:41:24 mysql 批量更新
2020-01-15 01:11:15 递归删除
2019-11-20 16:58:40 理解inode
2019-10-05 14:32:02 TCP的三次握手
2019-10-03 09:17:24 套接字
2019-09-30 16:17:50 网络工具
2019-09-08 02:48:27 html
2019-09-07 19:10:07 认识客户端-服务端网络模型的基本概念
2019-06-20 16:56:17 mysql从myisam迁移到innodb全过程
2018-03-12 16:22:56 MVC的工作原理
2018-03-08 16:22:02 web资源防盗链
2018-03-07 10:55:04 数据库缓存层的优化
2018-03-06 08:28:27 高并发解决方案
2018-03-04 09:00:38 php的会话控制技术 session与cookie
2018-02-28 10:04:24 php的常量及其数据类型
2018-02-27 16:23:12 php的变量以及引用变量的工作原理
2018-02-26 08:34:42 laravel上手
2018-02-22 06:15:51 腾讯php面试题目训练
2018-02-07 01:01:07 centos升级gcc4.4.7到4.8.2
2018-01-29 02:49:47 window下swoole拓展的安装
2018-01-25 03:04:23 mysql启动错误，The server quit without updating PID file (/usr/local/mysql/var/VM_157_231_centos.pid)
2018-01-22 09:32:54 dht爬虫
2018-01-21 06:53:08 从想下载知乎上的视频衍生的ffmpeg
2018-01-19 01:45:54 股票估值
2018-01-17 09:49:20 鸟哥的linux私房菜读书笔记-记录一点linux的小知识
2018-01-11 02:40:47 市盈率
2018-01-05 03:14:16 自然语言处理
2017-12-26 05:55:11 netbeans的debug功能
2017-12-13 07:11:08 git比较好理解的记录
2017-12-04 07:08:49 centos,shadowsocks 服务端搭建
2017-12-01 08:31:22 使用python的you-get下载油管视频
2017-11-28 11:20:21 fping window
2017-11-28 08:09:16 linux centos配置Nginx支持HTTPS访问 Let’s Encrypt
2017-11-15 08:37:44 apache2.2 支持中文url mod_encoding的扩展的编译与安装
2017-11-10 03:01:09 linux awk,sort,uniq,head 分析apache日志文件
2017-11-08 06:42:46 php的session机制
2017-11-08 02:18:12 linux下安装phpredis拓展
2017-11-08 01:52:12 linux tar 命令详解
2017-11-06 03:16:45 Can’t connect to local MySQL server through socket ‘/var/lib/mysql/mysql.sock’ (2)
2017-11-03 05:51:50 linux设置SSH无密码登录
2017-11-02 10:02:13 lsyncd 记录
2017-11-02 03:33:33 httpd开机启动以及“service httpd does not support chkconfig”
2017-10-31 02:50:42 阿里云oss上传文件及挂载硬盘
2017-10-23 01:49:52 linux三大利器–grep|sed|awk
2017-10-11 08:34:44 elasticsearch suggester学习记录
2017-10-06 16:25:40 kibana的操作指南CURD
2017-10-06 15:10:37 倒排索引
2017-10-05 02:14:25 Elasticsearch 分布式概念
2017-09-30 09:11:45 Elasticsearch学习记录
2017-09-21 01:01:00 scrapy-redis 实现分布式爬虫
2017-09-20 13:25:22 基于window下使用tor作为python爬虫切换IP
2017-09-13 14:08:39 蜘蛛侠英雄归来
2017-09-08 08:13:51 畅想未来
2017-08-23 02:48:47 关于window底下用pip 安装 scipy
2017-08-15 10:04:09 scapy教程初接触(3)—xpath语法和css语法
2017-08-12 09:23:08 scapy教程初接触(2)—编辑main.py文件
2017-08-10 17:05:57 scapy教程初接触(1)
2017-08-08 08:34:22 nginx的重新编译
2017-08-07 15:37:02 sqlmap +dvwa +Proxifier 完整（大概）教程
2017-08-01 17:32:58 正则表达式-贪婪与懒惰 python篇
2017-08-01 08:05:49 pip install scrapy 遇到的坑
2017-07-31 14:31:33 使用virtualenv和virtualenvwrapper搭建python的虚拟环境
2017-07-30 16:44:03 爱在三部曲《爱在黎明破晓前》《爱在日落黄昏前》《爱在午夜降临前》
2017-07-27 17:07:23 极速风流 rush
2017-07-10 06:09:34 自己用的vim配置
2017-07-09 07:57:37 路边野餐有感
2017-07-06 06:09:24 线程与进程
2017-06-25 08:53:14 Restful API 实战
2017-06-17 19:37:38 牯岭街少年杀人事件–一部没有反派的电影
2017-06-17 08:33:10 nginx wordpress 伪静态规则配置
2017-05-06 17:56:44 观《摔跤吧！爸爸》
2017-04-20 11:39:03 记科目二
2017-04-18 02:30:59 香港两天之旅
2017-04-12 17:57:26 纪念重要的4月15日
2017-04-04 06:14:26 奥斯卡的游戏规则
2017-04-03 19:33:28 首次观看奇葩说
2017-03-29 16:58:21 微信ai 自动回复机器人教程
2017-03-28 17:35:00 重新开始好好做人

Other pages

Deprecated: 文件没有 comments.php 的主题自版本 3.0.0 起已弃用，且没有可用的替代。请在您的主题中包含一个 comments.php 模板。 in /www/wwwroot/liguoqi.site/wp-includes/functions.php on line 6078