MySQL优化
一、MySQL优化
MySQL优化从哪些方面入手：
（1）存储层（数据）
构建良好的数据结构。可以大大的提升我们SQL语句的性能。
（2）设计层(单台服务器)
表结构的设计，表的引擎的选择，字段的索引的选择。
（3）架构层(多台服务器)
多台服务器协同工作的时候的一种架构！主从服务器，一主多从的实现！
主服务器，负责我们的写操作。从服务器就可以实现我们的读操作！
（4）SQL语句层
写出一个符合我们业务的SQL语句是很重要。但是你能写出一个继符合业务的，又能在性能上有所要求的SQL就是更重要了 。
二、MyISAM与InnoDB的索引结构
数据结构：B+Tree
现在我们硬盘上的数据，基本上都是使用的这种数据结构来进行存储数据的。
操作系统上面的文件也是使用这种B+Tree的数据结构！
1、非聚簇（集）结构
myisam主键索引：
主键索引有2个文件，有一个是索引文件，一个是数据文件。
通过索引查找数据的时候，是通过找到索引下面挂载的数据编号，通过这个编号找到我们的数据区，取出数据。
myisam的普通索引与主键索引在硬盘上面的存储方式，都是一样的。
Mysql服务器实现的不同点是主键是唯一不能重复的，普通是可以重复的。
2、聚簇（集）结构
innodb主键索引：
主键与数据是在一起的，所有的Innodb引擎，表数据与表索引在一起，只有一个文件。
索引的作用：
索引是排过序数据，索引会让我们在遍历的时候，少遍历很多数据，所以会加速我们的查询。
使用索引是SQL语句的where条件，必须是有索引的字段！
innodb如果使用非主键进行查询的时候，会出现我们常说的二次遍历！
第一次是遍历普通索引，找到普通索引上面的主键编号；
第二次是遍历主键索引，找到想要的数据，返回查询结果。
索引覆盖：查询的时候使用到了索引，并且想要获取的数据，都是建立索引的字段，就会出现索引覆盖现象。
innodb主键索引的重要性：innodb引擎的表，必须有主键！
不创建主键索引时，它就会去找这个表里面某个字段来进行主键索引创建。找不到合适的字段，innodb会自动创建一个主键索引 。
无论如何Mysql服务器都会给innodb引擎的表创建主键！
我们在创建innodb引擎表的时候，必须给innodb创建主键。
一定要创建一个整型的主键，并且是自增长的，主键不能用于业务处理。
自增长的重要性：
innodb引擎的表，插入操作的时候，一定要让主键字段是顺序插入的；如果非顺序插入，每次插入的时候，都会进行排序，数据就会整体移动。移动过程要消耗IO，数据量特别大时，占用的时间会特别的长。
使用自增长，将不会有这些问题！
创建表的时候，默认选择innodb就好，可以实现更多的业务需求。
三、MySQL存储引擎
1、什么是存储引擎
存储引擎就是存储数据到硬件或者内存中的一种技术！
2、MyISAM与InnoDB引擎的区别
myisam是支持表锁，innodb是支持行锁（有条件的行锁，必须有索引字段）
myisam是不支持事务，innodb是支持事务的
myisam是支持地理空间索引，innodb是在5.6.2版本之上才支持
myisam是支持压缩的，innodb是不支持压缩
myisam是支持全文索引的，innodb是不支持全文索引
3、存储引擎插入数据的执行顺序
innodb的表会自动的排序；myisam的表不会自动排序。所以以后你在请求别人的接口的时候，一定要注意，不要相信别人的排序。自己排一下。
4、MyISAM引擎的压缩
（1）对myisam引擎表数据进行压缩
找到相应的工具，linux为例，在目录/usr/local/bin/下，压缩工具：myisampack，解压工具：myisamchk
（2）压缩工具介绍：
使用：myisampack 表的绝对路径(没有表的后缀)
eg：/usr/local/mysql/bin/myisampack /usr/local/mysql/data/test/myisam
如果数据表太小，则会提示不能压缩。
虽然可以压缩成功，但是索引会损坏，所以在压缩完成后应该重建索引。
（3）重建索引
myisamchk -rq 表的绝对路径(没有表的后缀)
eg：/usr/local/mysql/bin/myisamchk -rq /usr/local/mysql/data/test/myisam
执行结束后，索引会修复成功
（4）刷新数据回硬盘【重点】
进入mysql中，执行flush tables;即可
说明：压缩的表，只能是只读的。不能修改，不能更新。
（5）解压缩
myisamchk --unpack 表的绝对路径（没有表的后缀）
eg：/usr/local/mysql/bin/myisamchk --unpack /usr/local/mysql/data/test/myisam
完成后可以查看表数据：在linux下执行ll -h /usr/local/mysql/data/test/
（6）必须刷新回硬盘：
在MySQL下执行：flush tables;
5、MyISAM引擎与InnoDB引擎的备份与还原
（1）mysql服务器的备份与还原：
备份
备份表：mysqldump –u root –p 库 [表] > 备份的路径
eg：/usr/local/mysql/bin/mysqldump -u root -p test innodb > /
备份库：mysqldump -u root –p 库 > 备份的路径
eg：/usr/local/mysql/bin/mysqldump -u root -p test > /tmp/test.sql
备份：带库名：mysqldump -uroot –p –B 库 > 备份的路径
eg：/usr/local/mysql/bin/mysqldump -u root -p -B test > /tmp/testb.sql
还原
还原表：mysql –u root -p 库名 < 备份sql的文件路径
eg：/usr/local/mysql/bin/mysql -u root -p test < /tmp/innodb.sql
还原库：mysql –uroot –p < 备份SQL的库的路径
备份文件里面是sql语句，是可以修改的。但是我们不应该修改它。备份就是数据的拷贝，修改了之后，一切都变味了。
6、其他存储引擎介绍
（1）Memory
数据置于内存的存储引擎，拥有极高的插入，更新和查询效率。但是会占用和数据量成正比的内存空间。并且其内容会在MySQL重新启动时丢失 。
（2）Archive
归档存储引擎，只支持数据的查询和写入。
经常用于存储日志等相关信息。
（3）merge
这个可以把很多myisam表连接在一起，我们查询数据的时候，就感觉在一张里面表里面使用。myisam表使用量大的时候，merge引擎是经常的出现。
查看MySQL引擎：show engines;
如果是merge，则会显示mrg_myisam = merge
四、列类型的选择
1、数值类型的选取
tinyint占的字节数；int占的字节数；
有符号（-128，127）与无符号（0，255）的范围。
有一个字段，我们一定要判断它所在的范围，如果判断的不准，可以适当放大一点，保存数据能够全部存储进去。
选择类型的时候，尽量是选择最小的类型，就能够把字段所有的范围包含进去的。
示例：年龄（人）：0 - 200
选择tinyint 无符号的
对ID选值的说明：目前来说ID默认选择int，无符号即可！
float 是取近似值！
double 四舍五入；很多商店都是选择的这种方式。
单位很重要：单位是元的时候，取2个小数点是没有问题的。
2、字符串类型的选取
char(10) varchar(10) ：这个10是10个字符
char ：0 – 255个字符！无论是utf8还是gbk！
varcahr ：0-65535个字节！
utf8 ：一个汉字占3个字节； gbk ：一个汉字占2个字节。
varchar 最大长度是：
utf8：(65535 – 1 - 2) / 3 = 21844能够存储的字符
gbk： (65535 – 1 - 2) / 2 = 32766能够存储的字符
varchar可以使用的宽度是动态变化的 。
blob的是存储二进制的：如果MySQL要存储图片，选择longblob即可。
创建char字段的表，存储的字符数超过255时会报错，但是5.5版本的时候，超过的长度会自动截取；5.7版本的时候，会报错。
至于是自动截取还是报错，都是可以配置的。
对于varchar对宽度的影响：
创建表时：CREATE TABLE varc(name varchar(21844),age int)ENGINE=MYISAM CHARSET=utf8;
这时因为多加了个age int这个字段，就创建失败了。
把多加的字段的空间留出来，就可以创建成功了：CREATE TABLE varc(name varchar(21842),age int)ENGINE=MYISAM CHARSET=utf8;
3、时间类型的选取
时间戳
PHP：time();
MYSQL：unix_timestamp();
如果存储时间的时候，不显示要求的时候，就使用时间戳存储，选择int就好 。
4、枚举类型与集合类型
set与enum底层是使用整型来实现的。只是我们传输的时候，是传的相应的值过来。但是这种设置不够灵活。
tinyint实现：1 = > man 2 => woman 3 => ...
php配置文件： array(1=>man, 2=>woman)
php代码使用的时候，直接拿来替换就可以。
5、IP与整型数据的转换
mysql ：inet_aton ；IP地址转成整型
select inet_aton('192.168.111.110');此时这个IP会转成3232264046
mysql ：inet_ntoa ；整型转成IP地址
select inet_ntoa(3232264046);此时这个整型会转成192.168.111.110这个IP
php：ip2long ；ip转成整型
echo ip2long('192.168.111.110');会打印出-1062703250
php ：long2ip ；整型转成IP
echo long2ip(-1062703250);会打印出192.168.111.110
使用php转成的整型，就要使用PHP的函数转成IP地址。
不同的语言转出来的值可以不一样。所有一定要使用什么语言转的，就要使用什么转回去。
六、MySQL中的执行计划
1、什么是MySQL执行计划
就是把SQL语句的执行效果显示出来。
2、执行计划的作用
让我们清楚的知道SQL语句干了什么，满足不满足我们的理想！
3、执行计划的基本语法
explain 查询SQL语句
eg：explain select * from innodb limit 1;
4、explain详解
上节的查询语句会查询出的信息，解释如下：
type ：const | ref | range | index | all
小 大
const ：基本上使用等于的时候才会出现这个值
ref ：小范围结果的时候，就会这个值
range ：大范围结果的时候，就会这个值
index ：整个索引查询，遍历索引
all ：全表查询，使用索引了。
Extra：
Using filesort ：文件排序，这个就很慢了。可以优化
Using temporary ：使用了临时表，这个就可以优化
Using index ：使用了索引覆盖
Using where ：使用了数据过滤
索引长度：创建表的时候，只是通知数据库帮助创建了索引。索引是怎么创建的，如何创建的，都是mysql服务器自己做的事情。所有这个长度，你只需要拿来对性能优化的时候，对比即可。
5、数据库中索引的设计
（1）什么是索引
存储引擎以一种数据结构进行存储的数据。
这种数据结构的数据让我们查询数据时非常的高效。
（2）非常重要的索引类型
① 主键索引（primary key）
删除主键：alter table table_name drop primary key
eg：alter table innodb drop primary key;但是此时会报错，因为主键是自动增长的，因此不能删除。
删除自动增长：alter table table_name modify id int(11) unsigned not null;
eg：alter table innodb modify id int(11) unsigned not null;此时自动增长就删除了，再进行删除主键就能执行成功。
添加主键：alter table table_name add primary key (id)
eg：alter table innodb add primary key (id);
② 唯一索引（unique key）
主键：一张表里面只能有一个；主键值是不能够重复的。可以使用自动增长。
唯一：一张表里面可以有多个；主键值是不能够重复的。可以使用自动增长。
添加唯一索引：alter table table_name add unique key 取个索引名(字段) ;
eg：alter table innodb add unique key myname(name);
删除索引：alter table table_name drop key 索引名;
eg：alter table innodb drop myname;
③ 普通索引（key）
普通：普通索引在值是可以重复的，一张表可以创建多个，没有限制的。
添加普通索引：alter table table_name add key 取个名称(字段);
eg：alter table innodb add key yourage(age);
删除普通索引：alter table table_name drop key 索引名称;
eg：alter table innodb drop key yourage;
重点说明：普通索引才是使用的非常广泛，而且经常需要我们操作的。
④ 复合（联合）索引
创建索引的，以多个字段共同创建就是复合索引。复合索引的类型根据创建的关键字来决定 。这些关键字，就是上面的三种索引。所以你创建的是哪一个索引，就有哪一种索引的特性。
复合索引：很多时候，都是普通形式存在的。
添加：alter table table_name add key 取个索引名(字段1,字段2,……) ;
eg：alter table innodb add key name_age(name, age);
删除符合索引：alter table table_name drop key 索引名;
eg：alter table innodb drop key name_age;
⑤ 总结
添加索引的时候：
主键索引：表里面唯一的，值不能重复
alter table table_name add primary key (id)
唯一索引：表里面可以有多个，值不能重复
alter table table_name add unique key 索引名(字段)
普通索引：表里面可以有多个，值可以重复
alter table table_name add key 索引名(字段)
普通复合索引：
alter table table_name add key 索引名(字段,字段,……)
删除索引的时候：
主键索引：
alter table table_name drop primary key
唯一索引|普通索引|普通复合索引
alter table table_name drop key 索引名
复合索引 === 联合索引， 这2个名称是一个意思！
（3）索引字段的使用原则
1）等于匹配
验证只有使用id的时候，才会使用到主键索引
explain select * from innodb where name = 'xiao1'\G
上面的语句中，name字段是没有索引的，索引没有办法使用到索引。
explain select * from innodb where id = 1\G
使用索引字段的时候，使用到了索引，并且范围还是很小。
能不能使用索引，根据where后面的条件的来决定的。
2）大于，小于匹配
说明：在实际工作，大于小于尽量不使用，能够使用in替代的，就使用in代替。
大于：explain select * from innodb where id > 0\G
小于：explain select * from innodb where id < 0\G
大于小于在目前看来都使用了索引；但是如果数据量变化了，这个结果会改变的。
3）最左原则
like查询：explain select * from innodb where name like 'xiao1%'\G
结果：数据会影响索引的使用。
如果将%写在左边：explain select * from innodb where name like %xiao1'\G
结果：没有使用索引。
说明：在使用索引的时候，值的左边一定要保持是定值。定值就是不会改变的。
4）列独立
explain select * from innodb where id + 1 = 2\G此时，这个id + 1不是一个定值，因此不能使用索引。
修改一下：explain select * from innodb where id = 2 - 1\G，字段id这边不要有其它值时，就会使用到索引
5）复合索引
创建复合索引：alter table innodb add key name_fu(name,age,sex);
使用索引进行查询：explain select * from innodb where name = 'xiao1' and age = 18 and sex = 1\G
此时使用到了索引，此时索引的长度key_len: 64
只使用name和age索引查询：explain select * from innodb where name = 'xiao1' and age = 18\G
此时的索引的长度key_len: 63
只使用name字段索引查询：explain select * from innodb where name = 'xiao1'\G
此时的索引的长度key_len: 62
创建复合索引的时候：name字段的索引长度是62；age与sex分别是1
只使用name和sex字段索引查询：explain select * from innodb where name = 'xiao1' and sex = 1\G
说明：只使用了name字段长度的索引。sex是没有被使用的。
只使用age和sex字段索引查询：explain select * from innodb where age= 18 and sex = 1\G
此时没有使用到索引。
只使用age字段的索引查询：explain select * from innodb where age= 18\G
只使用sex字段的索引查询：explain select * from innodb where sex= 1\G
此时这两种查询也都没有使用到索引。
总结：复合索引在创建的时候的顺序，影响了使用的顺序。
创建的时候是什么顺序，使用的时候就是什么顺序。
创建的时候是最左边是name 然后是age ; 最后是sex；所以你使用的时候，要保持最左原则。从左边开始使用。
sql发送给mysql服务器的时候，mysql服务器会解析，然后在优化。优化的时候，就会重新拼接sql语句。
6）OR表达式：or最好不要使用，性能特别低。
7）mysql对索引的自动判断介绍
mysql服务器才是管理索引的使用者。我们只能告诉mysql服务器，去创建一个什么样的索引。你在使用索引的时候，一切的规则都是按MYSQL服务器，内部的规则去运行的。所以你只需要记住这些规则就可以了。通过explain看出来效果。选择出最佳的就可以了 。
比如：当你的字段有索引的时候。但是你查询的数据，有很多的时候。MYSQL服务器就会自动的判断。使用索引与直接在硬盘上面查数据，那个更快。经过它自己的判断 。会决定最终使用那一个。如果它认为直接扫描硬盘更快。就会不经过索引。直接使用全表扫描。
4、适合使用索引的应用场景
（1）索引的选择性：
字段里面不重复的值的总数 / 字段值的总数 = 0 - 1
这个值应该大于0.4制作索引的效果就可以了。
统计总数：
count：select count(age) from innodb;
显示统计字段里不重复的值：select distinct sex from innodb;
统计不重复的总数：select count(distinct sex) from innodb;
计算：select count(distinct sex) / count(sex) from innodb;
这个值匹配度太低了，所以不适合做索引。所有性别是不能做索引。做索引就太浪费资源。
（2）数据的量：
数据表的数据量，在1000以上的就可以制作索引 。重复值太多的字段不适合做索引。
5、SQL语句优化
myisam表在使用统计的时候，直接使用count(*)就好了。因为我们myisam表的最后面有一个隐藏的值就是我们表的数量。你使用count(*)其实就是把这个值给取出来。
innodb表在使用统计的时候，直接使用count(字段名)就好了，各种说明都说的不适合使用*。但是当测试数据量在200W的时候，使用*比字段名要快一些！
在使用group by时，它会自动排序，可以使用order by null取消排序
非常重要的性能说明：大量数据的时候，分页的实现！ limit N, 10;
比如：select * from myisam limit 300000, 10;此时查询出结果说消耗的时间很长
优化：select * from myisam where id > 300000 limit 10;此时消耗的是就就很少了。
所以：id：请一定不要更新或者删除它。
七、两种特殊的索引结构
1、全文索引（MyISAM）
其它索引：之前章节介绍的4种索引，都是把列的值作为索引。
全文索引：是把列里面的值进行分词，然后把每一个分词作为索引。
文章：标题，作者，内容，发布时间
内容从几千到几万字不等，存储内容需要使用大文本字段。
搜索内容里面含有某一个词的文章，曾经学习的搜索方式唯有使用like ‘%词%’进行匹配。
改善搜索的查询速度，需要对文章内容里面的每一个词，进行索引。让查询的时候可以使用到索引，提升查询的性能。
myisam引擎支持的全文索引，就可以完成这样的功能。该引擎支持英文，不支持中文！
英文分词：空格进行分词。
添加全文索引：alter table table_name add fulltext 取个名称(字段);
删除全文索引：alter table table_name drop index 取的名称;
之前介绍的3种索引与全文索引删除时都可以使用index或者key
搜索：select * from table_name where match('字段') against('搜索词') ;
（1）创建全文索引表
create table `fulltext`(
id int(11) unsigned not null auto_increment comment 'id',
content text comment 'hello world',
primary key(id)
)engine=myisam charset=utf8;
（2）创建全文索引
在插入一些数据后，创建全文索引：
alter table `fulltext` add fulltext fullcon(content);
mysql里面，关键词。一定要加反引号！
（3）进行搜索
搜索词：you，
select * from `fulltext` where match(content) against('you');
eg:select * from `fulltext` where match(content) against('you');
查看表结果
show create table `fulltext`\G
如果显示FULLTEXT KEY `fullcon` (`content`)，则说明全文索引是添加成功的
（4）进行搜索
搜索词：Dream
select * from `fulltext` where match(content) against('Dream');
再搜索：
select * from `fulltext` where match(content) against('relationship');
总结：写文章的时候，you与is在英文文章中，是经常出现的，所以就没有搜索的必要。所以像这类的词，全文索引会过滤掉，这些词是全文索引定义的。
能够使用搜索的词，只有那些能够区分出内容的词，才能被搜索到。
（5）删除全文索引
alter table `fulltext` drop index 索引名;
eg：alter table `fulltext` drop index fullcon;
（6）总结
搜索不到的词，每篇文章中出现的机会都很多，搜索的时候就没有意义。分词就过滤掉了这些词，不对这些词建立索引。过滤词是全文索引定义的，可以不必在意这些。
中文文章内容搜索是可以实现的，需要使用中间件（第三方工具），来帮助mysql完成功能。
2、前缀索引
其它索引：之前介绍的4种索引，都是把列的值作为索引。
前缀索引：是把列前面的一部份值作为索引。
比如：张三的张；李四的李；王五的王
建立索引的数据是字段的前面一部分，查询返回值是需要一个完整的字段值。查询返回值是前缀索引时，为了返回一个完整的字段值，就必须要去数据区找到值。
前缀索引制作的要求：都是长字段。
字段值前面的一部分，能够很好的代表整个字段的时候，才有必要制作前缀索引。
索引的选择性
计算公式：字段不重复值的总数 / 字段值的总数 = 0 - 1
select count(distinct 字段值) / count(字段) = 0 -1
前缀索引的选择性
计算公式：字段前面的几个值不重复的总数 / 字段值的总数 = 0 - 1
select count(distinct left(字段值, number)) / 字段值的总数 = 0 - 1
number的确定：
前缀索引的选择性结果 === 索引的选择性结果
left的示例：
select left('abcd', 2);打印出ab
select left('abcd', 3);打印出abc
添加前缀索引：前缀索引很多时候都有重复的值，使用普通索引即可！
alter table table_name add key 取个索引名(字段(number))
number ：表示取字段值的前面多少个！是由前缀索引的选择性计算出来的值！
（1）创建一个表
create table prefix(
id int(11) unsigned not null auto_increment comment 'id',
name var varchar(20) not null comment 'name',
passwd char(32) not null comment 'passwd',
primary key(id)
)engine=innodb charset=utf8;
（2）准备脚本
$db = mysqli_connect('127.0.0.1', 'root', '123456', 'test');
mysqli_query($db, "set names utf8");
$sql = "insert into prefix (`name`, `passwd`) select concat('xiao', convert(round(rand() * 20000), char)) as name,
md5(
substring('qwerop[]\|{PLKJH}asdfghjkl;:zxc567vbnm,./<>?`~1234890-=!@tyui#$%^&*()_+……%QWERTYUIOGFDSAZXCVBNM<>?:;[]F86892652jdmjwolbvxzm2',
ceiling( rand() * 128),
ceiling( rand() * 50 + rand() * 30 - 1)
)
) as passwd";
for($i = 0; $i < 4444; $i++){
mysqli_query($db, $sql);
}
（3）运行脚本
将这个准备好的脚本放到linux站点目录下，并用浏览器访问该页面。此时浏览器刷新图标会一直在转，等到不转了表示请求成功了。
转的时候，等的很着急；你就会再次刷新页面。这个时候会出现什么情况呢？
刷新页面，就是再次发送请求。以当前页面来说这个问题。刚才我们刷新了二次，第一次没有等待结果返回，就再次刷新了。我们的数据结果是执行了完整的二次。
当你第一次刷新的时候，浏览器已经把请求发送给了服务器。服务器接收到任务，已经开始执行。你再次刷新的时候，浏览器发送了第二个任务给服务器，服务器接收到任务，然后开始执行。
服务器把第一次任务执行完成，准备返回的时候，找不到回家的路了，就没有办法返回。第二次任务执行完成，准备返回的时候，回家的路还在，因此就直接返回给浏览器了。
将该PHP文件可以在php解析器直接执行一下：
/working/php7/bin/php /站点目录/www/MySQL.php
在查看一下数据库：select count(*) from prefix;。此时结果多了一个4444，证明运行成功了。
PHP程序在执行PHP文件的时候，连接数据的地址写的是：127.0.0.1。所以你的保证php连接的地址能够正常被访问到。127.0.0.1表示的是本地，所以php与mysql应该在同一台服务器上面。
（4）索引的选择性
select count(distinct passwd) / count(*) from prefix;
（5）前缀索引的选择性
select count(distinct left(passwd, 6)) / count(*) from prefix;
当取的字段前面6个字符的时候，计算出来的结果，就与索引选择性的结果是一样的。
（6）添加前缀索引
alter table prefix add key 取个名(passwd(6));
eg：alter table prefix add key prepass(passwd(6));
（7）确定搜索的值
select * from prefix limit 1;
查询出的结果，确定passwd的值为4e1d9fdd24906a3256a0c2bafa3f532f
（8）使用值进行搜索
select * from prefix where passwd='4e1d9fdd24906a3256a0c2bafa3f532f';
此时使用了索引，且索引的长度为：key_len : 18
（9）删除前缀索引
alter table prefix drop key 索引名;
eg：alter table prefix drop key prepass;
（10）创建普通索引
alter table prefix add key passwd(passwd);
（11）使用普通索引进行搜索
explain select * from prefix where passwd = "4e1d9fdd24906a3256a0c2bafa3f532f";
此时的索引的长度：key_len: 96
（12）结果总结
使用前缀索引的长度是：18
使用普通索引的长度是：96
前缀索引是普通索引的 5 倍速！
前缀索引制作的字段，一般情况是比较长的才使用它，工作中很少有这样的字段出现！
八、MySQL中的其他功能
1、慢日志查询
慢[日志]查询：把sql语句执行慢的，都记录到日志文件里面。
定时检查日志文件内容，把sql语句执行慢进行优化！
慢[日志]查询中的“慢”指的是：人为设定的时间，超过了就是慢。
（1）慢[日志]查询配置
show variables like 'slow_query%';
显示出的结果：
slow_query_log OFF：代表开关，OFF的时候是关闭的；ON的时候是开启的。
slow_query_log_file /usr/local/mysql/data/localhost-slow.log；慢日志的存储位置，请不要修改它，因为修改就有权限的问题！
（2）慢[日志]查询时间配置
show variables like 'long_query%';
查询出的结果：
long_query_time 10.000000；中10.000000的小数点后面代表单位是秒
（3）开启慢[日志]查询
set global slow_query_log = 1;
此时在进行第（1）步的操作，可以看到slow_query_log的值是ON，这就代表开启了。
这些内容，是mysql服务器管理人员设定的。一般情况都是默认设定在配置文件里面的。我们现在使用的临时有效的，重启就没有效果了。
（4）设定慢[日志]查询时间
set long_query_time = 1.111111;
此时经过第（2）步操作，可以看到long_query_time的值变为1.100000
这个就是设定的慢，SQL查询时间，超过这个的时候，就会记录到慢日志里面去。
（5）查看慢[日志]查询日志文件位置
日志文件在/usr/local/mysql/data/目录下的localhost-slow.log文件。
学习一个全新的查看方式：
参数 ： -f 是打开文件，占用当前窗口，只要文件有新内容从尾部插入，就立即展示出来。
eg：tail -f /usr/local/mysql/data/localhost-slow.log
此时打开之后，当前的窗口就会被占用了。
这种打开方式在工作中是经常使用的。
（6）总结
慢[日志]查询：开启的时候，可以把sql语句执行慢的记录下来。可以针对性的对sql语句优化。
-f参数非常的重要。工作中，集群服务器出现问题。访问的时候，有时候出bug，有时候没有出bug 。
此时，使用-f打开全部服务器日志文件。请求服务器内容时没有出现bug，可以立即查看哪台服务器日志文件有新消息，可以立即排除这台服务器了。
2、SQL语句缓存
执行sql语句的时候，直接把执行的结果，存储在服务器上面。下次再一次执行相同的SQL语句时，立即返回缓存结果。
（1）确定服务器是否支持
show variables like '%query_cache%';
得到的结果的参数解释：
have_query_cache ：值是yes的时候，就是支持sql语句缓存 。
query_cache_limit ：每条sql语句，可以占用（最大）的空间大小是1M。
query_cache_min_res_unit ：最少占用的空间大小4K 。
query_cache_size ：缓存大小 。（5.5版本时，是没有设定的，要自己设定！ ）
query_cache_type ： ON是开启，OFF是关闭 。（5.5版本时，默认是开启！ ）
（2）查看缓存状态
show status like '%qcache%';
得到参数解释：
Qcache_free_memory ：可以使用的空间，即剩余空间
Qcache_hits ：命中，使用了多少次缓存
Qcache_inserts ：插入的缓存数量
Qcache_lowmem_prunes ：内存不够，放弃缓存的数量
Qcache_not_cached ：不缓存的数量
Qcache_queries_in_cache ：已经缓存的数量
（3）开启缓存
set global query_cache_type = 1;
如果是5.7版本的缓存开启，请进入配置文件：vim /etc/my.cnf
[mysqld]
prot = 3306
user = mysql
datadir = /usr/local/mysql/data/
socket = /tmp/mysql/sock
query_cache_type = 1 #将此行写在这个段落的这个位置
修改完配置文件后记得重启MySQL服务器！
（4）设定缓存的大小
set global query_cache_size = 1024 * 1024 * 80;
执行完成后可以在show variables like '%query_cache%';中查询出query_cache_size的值。
设定好后，每次执行一次sql语句，都会在show variables like '%query_cache%';记录中Qcache_inserts和Qcache_queries_in_cache`的值加1。
（5）重复执行sql语句
重复执行一条sql时，会在show variables like '%query_cache%';中的Qcache_hits值加1， 重复执行的，所以增加了命中。
（6）修改sql语句
执行的sql语句中只要任何地方有变化，都会增加缓存的值，哪怕之前写的是where，之后是WHERE，这样也会增加缓存数。多写一个空格也会增加。
总结：意味着SQL的缓存，是区分大小写的。
缓存是必须SQL一模一样的，才会认定是同一条SQL。不然就会是新的缓存。
因为我们的SQL的查询结果进行缓存的时候，存储的数据格式是key=>value。这个key就是SQL语句HASH之后的值；value就是SQL的查询结果。sql的HASH结果，只要SQL有任何一点的变化，这个HASH结果，都会不一样的 。
（7）修改数据或者增加数据
更新一条sql语句时，执行完成完成时，再查看缓存状态，可以看到Qchche_queries_in_cache的值变少了。
说明：当表的SQL语句，被缓存的时候。然后这个表有任何的修改（更新，插入，表结构）都会清空这个表的缓存。
（8）强制不缓存
select sql_no_cache * from table_name，其中sql_no_cache：告诉服务器不缓存，查询结果。
在执行完成后，缓存状态里的Qcache_not_cached的值增加了。
（9）清空缓存
reset query cache;
（10）总结
sql缓存使用的地方特别少，现在很多数据都要更新，或者添加数据。交互的内容越来越多。
数据经常发生变化的时候，不适合使用sql缓存。
开启sql缓存，每次查询请求，都会把sql语句作hash取值操作。去缓存中查询有没有缓存。数据经常变化，缓存常被清空，查询的命中就低。整个去缓存的过程，就经常变成无意义的操作，浪费了服务器资源！
九、MySQL分区与分表
当表数据达到一定的数量级时。SQL语句的查询会非常的慢。 解决这个问题，就要把数据拆分到不同的表里面去。这个时候，就要使用分区或者是分表的技术。
1、分区与分表的区别
分区：mysql服务器帮助实现的数据分表功能，就是分区。
mysql把数据存储在拆分的不同表里面，对用户是无感知的，还是像一张表一样操作。
分表：是程序员，自己实现的拆表。把相同的数据，存储到不同的表里面。就是分表。
要分表的非常好，需要一定的算法功底。
2、分区的类型
类型说明：
key ：指定id作为hash值，来进行划分。内部会有一定算法实现的。 key可以不是整型 。
hash ：指定整型作为hash值，来进行划分。
range ：指定整型，作为范围，来进行划分。
list：指定整型，作为固定的区域，来进行划分。
3、key分区操作
（1）创建表
create table goods_key(
id int unsigned not null auto_increment comment '主键id',
name varchar(32) not null comment '名称',
price decimal(10,2) not null default 0 comment '价格',
pubdate datetime not null comment '出厂时间',
primary key (id)
)engine=myisam charset=utf8
partition by key (id) partitions 4;
执行完成后在查看表文件时，可以看到文件goods_key.par为分区结构。
（2）合并分区
alter table table_name coalesce partition 2;
当执行表操作的时候，一定要关注数据。
表文件已经只有2个了，但是数据还是存在的，这就证明了，我们的表数据已经移动了。合并的时候，表数据会移动，移动数据，就会有IO的操作。所以大家在数据量大的时候，一定一定不要随便的操作合并。在夜深人静的时没什么人访问网站的时候进行这种操作。
（3）增加分区
alter table table_name add partition partitions 2;
说明：新增加的2个表文件都有数据的，就证明添加的时候，数据也会被移动的。会重新的进行数据的分区操作。这样的话，数据就会占用IO资源。谨慎操作。
（4）移除分区
alter table table_name remove partitioning;
移除分区后，数据还在，但是分区的表文件都被移除了，只剩下原来普通的模式了。
（5）总结
添加与合并：都会进行数据的重新移动，这个时候，就会占用IO资源。所以操作的时候，一定要谨慎操作。
移除的时候，会把分区删除掉。也会进行数据的移动的操作。
这三个操作，数据还会存在。
4、hash分区操作
（1）创建表
create table goods_hash(
id int unsigned not null auto_increment comment '主键id',
name varchar(32) not null comment '名称',
price decimal(10,2) not null default 0 comment '价格',
pubdate datetime not null comment '出厂时间',
primary key (id,pubdate)
)engine=myisam charset=utf8
partition by hash (month(pubdate)) partitions 4;
（2）合并分区
alter table table_name coalesce partition 2;
说明：合并的时候，数据会进行移动。也就是io操作。合并操作，并不会影响数据库里面的数据 。
（3）添加分区
alter table table_name add partition partitions 2;
说明：新分区的文件里面也是包含了数据的。也就是说当有新分区的时候。数据会重新进行分区操作。会占用IO资源。
（4）移除分区
alter table table_name remove partitioning;
（5）总结
合并与添加都会进行数据重新分区的操作。这种操作会占用IO资源。数据量大了就会非常的危险。所以操作的时候，一定要注意。
移除的时候也会进行数据移动操作。
上面三个操作，都会保证数据的正常。
小结：
key | hash 分区：
添加分区：
alter table table_name add partition partitions number（添加表的个数）
合并分区：
alter table table_name coalesce partition number（合并表的个数）
移除分区：
alter table table_name remove partitioning;
使用分区的字段，必须是主键！
分区的时候，字段的选择？
一般情况下，要尽量让分区的表，每一张表的数量尽可能的保持一致！100W数据的表，分成2张表，尽量保持是50W一张表！
在表结构里面，什么样的字段，能够满足这样的需求，你就可以去选择这个字段，来制作分区表！
5、range分区操作
（1）创建表
create table goods_range(
id int unsigned not null auto_increment comment '主键id',
name varchar(32) not null comment '名称',
price decimal(10,2) not null default 0 comment '价格',
pubdate datetime not null comment '出厂时间',
primary key (id,pubdate)
)engine=myisam charset=utf8
partition by range (year(pubdate))(
partition year60 values less than (1970), //注意，从这行开始往下必须从小到大
partition year70 values less than (1980),
partition year80 values less than (1990),
partition year90 values less than (2000)
);
创建完成后，再进行插入数据。insert into goods_range values (1,'htc', 3451.3,'1975-02-14 12:30:12');插入总共几条条类似这种的语句。
此时如果插入一个比分区范围更大的值。比如insert into goods_range values (6,'nokia', 3451.3,'2018-07-24 12:30:12');此时会报错，因为2018不在分区数据里面。
重点说明：我们的这个范围分区设置的时候，一定要把所有可能的值，全部包含。这样插入数据的时候，才不会报错。
（2）设置一个最大的分区
包含所有的可能性：alter table table_name add partition(partition 分区名称 values less than MAXVALUE);
eg：alter table goods_range add partition(partition yearmax values less than MAXVALUE);
再查看数据时，数据都存在。
再重新插入insert into goods_range values (6,'nokia', 3451.3,'2018-07-24 12:30:12');此时就可以成功插入了。
注意：添加分区的时候，只能添加越来越大的。
（3）删除分区
alter table table_name drop partition 分区名称 ;
eg：alter table goods_range drop partition year 70;
强调：删除分区的时候，数据也会一并被删除，所以请注意了。
（4）移除分区
alter table table_name remove partitioning;
eg：alter table goods_range remove partitioning;
此时，分区文件已经被删除了；只有普通的样子了。
（5）总结
删除分区，会直接删除掉数据。所以请操作之前，三思。
添加分区，只能添加越来越大的分区。
移除分区，数据是还存在的，就会存在IO资源的使用。
合并分区也是有的 。
6、list分区操作
（1）创建分区
create table goods_list(
id int unsigned not null auto_increment comment '主键id',
name varchar(32) not null comment '名称',
price decimal(10,2) not null default 0 comment '价格',
pubdate datetime not null comment '出厂时间',
primary key (id,pubdate)
)engine=myisam charset=utf8
partition by list (month(pubdate))(
partition spring values in (3,4,5),
partition summer values in (6,7,8),
partition autumn values in (9,10,11),
partition winter values in (12,1,2)
);
再进行插入数据。
（2）删除分区
alter table table_name drop partition 分区名称;
eg：alter table goods_list droppartition winter;
删除分区的时候，数据会一并被删除的。
（3）修复分区
修复一下刚刚删除的"winter"分区，其实就是重新添加一下
alter table table_name add partition(partition winter values in (12,1,2));
此时，虽然有重新创建了分区，但是在删除了数据，删除了分区的话，数据是不会回来的，现在只是相同的名称的分区，已经和曾经的分区不一样了。
（4）移除分区
alter table table_name remove partitioning;
此时，表文件恢复到了没有分区时的样子了。
（5）总结
删除分区：就是把分区表删除，表删除了，里面的数据也就一起删除了。
添加分区：添加的分区是一个全新的，里面是没有任何数据的。
移除分区，会进行数据的移动，会占用IO资源。
小结：
range 与 list 分区
添加分区：
alter table table_name add partition (
partition 分区名称 values less than (整型)
或者
partition 分区名称 values in (整型,整型,整型)
)
删除分区：
alter table table_name drop partition 分区名
移除分区：
alter table table_name remove partitioning;
注意：移除分区是会进行数据的移动的；所以请注意，一定要在夜深人静的时候操作。
删除分区与添加分区，都不会进行数据操作，所以请操作的时候三思而行！
range与list也有合并分区；合并的时候，都是会进行数据移动的！
7、水平分表
数据有很多的时候，存储在多张表里面；这些表的表结构肯定是一模一样的。
表结构一模一样的表，在存储数据的时候，我们就可以理解成水平分表！
数据有1000W的时候，我们进行水平分表；分成2张表；
策略一：前500W数据，分在表1里面；后500W数据，分在表2里面；
策略二：id是单数的，分在表1里面；id是双数的，分在表2里面。
完成策略一：首先1000W的数据；新增数据。
读取曾经的数据，跑前500W在表1里面；跑后500W在表2里面；
新增数据：需要一直维护一个id值，通过id值去判断，我们的数据应该存储在那张表里面了。假如1001W，这个时候就存储在表3里面；到达1501W，这个时候就存储在表4里面。
查询数据的时候：
查询数据的，必须给数据维护好id值，查询的时候，尽量使用id查询，通过id值，就能区分它在哪一个表里面了！
merge引擎；它可以把myisam引擎的多张表连接起来，你查询的时候，直接查询这张表，它就会把所有的myisam引擎的表，都遍历一次，这样就获得了数据。
非myisam引擎的表，就要使用中件间（第三方工具）实现同merge引擎一样的效果！
完成策略二：首先1000W的数据；新增数据。
读取曾经的数据，跑数据id，id是单数的就存储在表1里面；跑数据id，id是双数的就存储在表2里面。
新增数据：需要一直维护一个id值，通过id值去判断， 只要id是单数就存储在表1里面；id是双数就存储在表2里面。
面试常考：有一个用户信息表，数据量有点大了，我们要进行分表，应该怎么划分?
id ，姓名，年龄，性别，登录时间，籍贯，time
用户信息表：
1）新用户注册的时候，注册信息
2）用户登录的时候，登录获得信息
用户信息表，经常都是回答使用用户名进行划分的。
用户名是一个字符串，可以通过hash转成整型，整型在进行取余就可以了。
要拿的值，一定是尽量是唯一的，不要重复的，不可修改的。
完成一下策略二：
分表的数据先定义好：2张表；
分表的算法要定义好：id进行取余；
通过算法，就会发现表名可以设计的有点意思：
id = 3；
3 % 2 = 1；
id = 4；
4 % 2 = 0；
它的值，只有0或者是1；
确定一个表前缀，然后加上这个取余的结果，就可以组装成表名！
表前缀是:goods_ ; 取余结果：0 ;组装：goods_0（表名）
（1）创建好2个表
create table goods_0(
id int unsigned not null auto_increment comment '主键id',
name varchar(32) not null comment '名称',
price decimal(10,2) not null default 0 comment '价格',
pubdate datetime not null default '0000-00-00 00:00:00' comment '出厂时间',
primary key (id)
)engine=myisam charset=utf8;
create table goods_1(
id int unsigned not null auto_increment comment '主键id',
name varchar(32) not null comment '名称',
price decimal(10,2) not null default 0 comment '价格',
pubdate datetime not null default '0000-00-00 00:00:00' comment '出厂时间',
primary key (id)
)engine=myisam charset=utf8;
（2）创建维护id的表
这个id一定要是自增长的！
create table goods_id_incr(
id int unsigned not null auto_increment comment '主键id',
primary key (id)
)engine=myisam charset=utf8;
插入数据：insert into goods_id_incr values (null);
（3）代码实现
//连接数据库
$db = mysqli_connect('127.0.0.1', 'root', '123456', 'test');
//表前缀
$table_pre = 'goods_';
//表的数量
$table_num = 2;
//有数据来了
$data = ['name' => 'chuizi', 'price' => 3299, 'pubdate' => '2018-05-15 19:00:00'];
//数量时没有ID的，要给它准备一个id值
$i_sql = "insert into goods_id_incr values (null)";
mysqli_query($db, $i_sql);
//获得生成的id值
$auto_id = mysqli_insert_id($id);
//取余计算表明
$table_last = $auto_id % $table_num;
//拼接表名
$table_name = $table_pre . $table_last;
//写入数据的sql
$sql = "insert into $table_name values ('{$auto_id}', '{$data['name']}', '{$data['price']}', '{$data['pubdate']}')";
mysqli_query($db, $sql);
（4）发现一个问题：goods_id_incr
查询一下good_id_incr表，得知有5条数据，那么以后会有多少条呢？
这些数据，只是在组装id的时候，才会有用。之后都将没有作用。所以我们应该清空它！
delete from goods_id_incr; ：清空表数据，不清空自动增长！
truncate goods_id_incr : 清空表数据，并且把自动增长清空，所以不能使用它。
8、垂直分表
表里面有很多字段，有一些是常用的，有一些是不常用的。
把常用的分成一张表，把不常用的分成一张表。
假如：用户表
id name age sex phone email wechat address content .....
不常用的：
id fid address content .....
补充说明：垂直分表的真实内涵
我们的数据是存储到硬盘里面的，那么一行数据的内容都是存储在一起的。而IO一次性读取的数据，也是整块读取的。当io读取一次的时候，里面有很多数据，是不需要的。这次读取就浪费太多资源。
进行垂直分表。那一行数据里面，都是需要的。现在IO一次性读取出来的内容，都是需要的。
十、锁
1、什么是锁
就是对数据的访问控制的一种技术。
2、mysql里面的锁的几种形式
共享锁（读锁）：加了共享锁的，大家都可以读它。
排它锁（写锁）：加了排它锁的，只有加锁的这个人可以去读写它。
锁的范围：
表锁：就是把一张表给锁住，就是表锁。myisam引擎，实现的就是表锁。表锁的颗粒大，加锁快，并发访问低。
行锁：就是把一张表里面的一行锁住，就是行锁。innodb引擎，实现的就是行锁，颗粒小，加锁慢，并发访问高。
加锁的时机：
悲观锁：当我想使用数据的时候，我就认为别人有可能会使用，我就赶紧加锁。
乐观锁：当我想使用数据的时候，认为别人不会使用。那我就修改的时候才加锁。
当我们使用乐观锁的时候，想要去修改它。这个时候，我们要读取数据出来。改变这些数据。
改变之后，就要更新。但是在更新之前检查一下version号是否一致。一致就更新。不一致，就先重新获取一下数据。然后修改数据在更新。
锁冲突：
当前用户进行加锁的时候，其它用户加锁会出现锁等待的情况。
并发访问的情况：
A ：对ID是1的加锁，执行访问ID是2的，出现锁等待
B ：对ID是2的加锁，执行访问ID是1的，出现锁等待
这个就是锁冲突。
3、表锁myisam引擎（表锁）
读锁：
开始加锁：lock tables table_name read
解锁：unlock tables
写锁：
开始加锁：lock tables table_name write
解锁：unlock tables
开始实践：准备2个用户！
说明：用户是以session来区分的，不是以用户名来分区的。
读锁：
加锁：lock tables myisam read;
当前用户：读操作！
当前用户再操作其它表时，会报错。你给谁加了锁，你就要操作哪张表，直到解锁。
其他用户：读操作时是可以进行读的。
但是进行写操作时，会出现锁等待。
当前用户：写操作。此时会报错，写操作是不可以执行的，读的锁，不能写。
解锁：unlock tables;
总结：myisam表的读锁，满足所有用户可读；所有用户不可写。
写锁：
加锁：lock tables myisam write;
当前用户进行读操作时可以进行，但是其他用户在此时进行读、写操作时会进行锁等待。
说明：其他用户是不能再写锁的时候操作读与写的。
当前用户：写操作时可以执行。
解锁：unlock tables;
总结：写锁是当前用户可以读与写的。其他用户是不可以读不可以写的。
4、行锁innodb引擎（行锁）
事务（Transaction）及其ACID属性：
原子性（Atomicity）：事务是一个原子操作单元，其对数据的修改，要么全都执行，要么全都不执行。
一致性（Consistent）：事务开始和完成，数据都必须保持一致状态。这意味着所有相关的数据规则都必须应用于事务的修改，以保持数据的完整性；事务结束时，所有的内部数据结构也都必须是正确的。
隔离性（Isolation）：数据库系统提供一定的隔离机制，保证事务在不受外部并发操作影响的“独立”环境执行。这意味着事务处理过程中的中间状态对外部是不可见的，反之亦然。
持久性（Durable）：事务完成之后，它对于数据的修改是永久性的，即使出现系统故障也能够保持。
事务级别有所不同：4个级别！
事务里面操作：
开始事务：
begin：
结束事务：
commit：
读锁：sql + lock in share mode
写锁：sql + for update
当前用户加个读锁
开始事务：begin;
当前用户：读锁select * from innodb where id = 1 lock in share mode'
其他用户：读锁select * from innodb where id = 1 lock in share mode;
其他用户：写操作update innodb set name = '6666' where id = 1;此时出现了锁等待。
其他用户：写操作非加锁的行update innodb set name where id = 2;，执行成功，当前用户确实是加的行锁。
当前用户：写操作：update innodb set name = '5555' where id = 1;
在innodb引擎的时候，在加了读锁的时候，依赖能够写操作成功。因为当你写操作的时候，自动就转成了写锁了。
写锁是排它的。所以使用其他用户，查询一下：select * from innodb where id = 1 lock in share mode;，此时出现锁等待。
提交一下事务：commit;
总结：当Innodb引擎加读锁的时候，是共享锁。大家都可以读。其他用户不能写。如果当前用户写数据了。锁就会修改成写锁，具有排它性。
当前用户加个写锁
开始事务：begin;
当前用户可以正常读操作，但是其他用户进行读操作和写操作时出现锁等待。
当前用户可以正常写操作。
提交事务：commit;
总结：写锁是当前用户可以写可以读；其它用户是排它性的，不能读不能写。
事务：就是拷贝了一份，单独的拿出来操作。在事务没有提交的时候，事务与源数据，是拷贝关系。
innodb总结：innodb是有条件的行锁，当使用索引的字段值的时候，才能加上行锁，非索引字段加的是表锁。
表锁是mysql服务器实现的，不是innodb引擎实现的。所有当有表锁冲突的时候，我们的innodb引擎没有办法解决这个问题。
行锁冲突的时候，innodb引擎会自动帮助我们解决这个问题！
查看表结构：有一个复合索引KEY name_fu (name, age, sex)
删除复合索引：alter table innodb drop key name_fu;
开始事务：begin;
当前用户：写锁。select * from innodb where name = '8888' for update;
name字段现在没有索引，所以加的是表锁
可以测试一下：其他用户进行读操作，非name=8888的字段查询，select * from innodb where name = 'xiao15' lock in share mode;，查询非id=1的出现了锁等待，就证明了加了表锁。
提交事务：commit;
给name字段创造一个普通索引：alter table innodb add key name(name);
开始事务：begin;
当前用户：写锁。select * from innodb where id = 1 for update;
说明：现在的name字段是有普通索引的，所以加的是行锁。
再测试一下：其他用户进行非加锁行操作：select * from innodb where name = 'xiao15' lock in share mode;
数据是可以查出。
说明：已经证明了，非加锁行，都可以正常操作。
其他用户：对加锁行操作 时，出现了锁等待
总结：只有加锁的行，其他用户操作的时候，才出现了锁等待。就证明了。innodb的表锁，是在使用的时候，没有索引的情况下产生的。
提交事务：commit;
当使用范围的时候。只要范围的都会被加锁！
id > 10 ; 锁不是绝对的。这个和事务的级别有关系。
5、php实现锁
需求：把访问人数，统计到我们表里面！
（1）创建一张表，记录人数
create table lock_num(
id tinyint(1) unsigned not null comment 'id',
num int unsigned not null
)engine=myisam charset=utf8;
num字段就是把我们有多少人访问，把统计的结果，存储在这里！
（2）提前数据预热
insert into lock_num values(1,0);
很多时候，我们都需要把数据提前预热；因为我们的访问一但来了，这个时候，我们没有准备好数据，就只能让mysql服务器硬抗，抗不住的。
（3）代码实现
//文件名：lock.php
//配置mysql服务器
$db = mysqli_connect('127.0.0.1', 'root', '123456', 'test');
mysqli_query($db, "set names utf8");
//等待一个人的到来
$person = 1;
//把曾经的访问数据取出来
$s_sql = "select num from lock_num where id = 1";
$res = mysqli_qyery($db, $s_sql);
$data = mysqli_fetch_assoc($res);
$num = $data['num']; //曾经的访问总人数
//曾经的人与现在访问人相加
$num = $num + $person;
//更新到数据库里面
//update自带写锁，select自带读锁，但是它们的作用范围都是一行语句
//所以有多行语句，或者要处理sql语句的记过，再操作就需要手动的加锁
$u_sql = "update lock_num set num = $num where id = 1";
mysqli_query($db, $u_sql);
（4）模拟多人并发访问
在linux中执行/working/httpd-2.4/bin/ab -n 500 -c 50 http://127.0.0.1/lock.php
执行完后查看数据库，发现：并发问题，当同时有多个人要操作同一个地方的数据的时候。如果不加锁，直接操作。有的就会被抹掉。
解决这个问题，就只能加锁！
（5）实现加锁功能
让请求实现我们的效果：
//文件名：lock.php
//配置mysql服务器
$db = mysqli_connect('127.0.0.1', 'root', '123456', 'test');
mysqli_query($db, "set names utf8");
//等待一个人的到来
$person = 1;
//加好写锁
mysqli_query($db, 'lock tables lock_num write');
//把曾经的访问数据取出来
$s_sql = "select num from lock_num where id = 1";
$res = mysqli_qyery($db, $s_sql);
$data = mysqli_fetch_assoc($res);
$num = $data['num']; //曾经的访问总人数
//曾经的人与现在访问人相加
$num = $num + $person;
//更新到数据库里面
//update自带写锁，select自带读锁，但是它们的作用范围都是一行语句
//所以有多行语句，或者要处理sql语句的记过，再操作就需要手动的加锁
$u_sql = "update lock_num set num = $num where id = 1";
mysqli_query($db, $u_sql);
//操作完成，解锁
mysqli_query($db, 'unlock tables');
再用ab来测试一下：/working/httpd-2.4/bin/ab -n 500 -c 50 http://127.0.0.1/lock.php
结果：加了写锁的，都是串行的。速度就会变慢的。为了数据的完整性，变慢也必须这样做。
6、文件锁
手册内容：
参数：
handle
文件系统指针，是典型地由 fopen() 创建的 resource(资源)。
operation
operation 可以是以下值之一：
◦ LOCK_SH取得共享锁定（读取的程序）。
◦ LOCK_EX 取得独占锁定（写入的程序。
◦ LOCK_UN 释放锁定（无论共享或独占）。
如果不希望 flock() 在锁定时堵塞，则是 LOCK_NB（Windows 上还不支持）。
//文件名：lock.php
//配置mysql服务器
$db = mysqli_connect('127.0.0.1', 'root', '123456', 'test');
mysqli_query($db, "set names utf8");
//等待一个人的到来
$person = 1;
//加好写锁
$fp = fopen('./lock.txt', 'w');
if(flock($fp, LOCK_EX))
{
//把曾经的访问数据取出来
$s_sql = "select num from lock_num where id = 1";
$res = mysqli_qyery($db, $s_sql);
$data = mysqli_fetch_assoc($res);
$num = $data['num']; //曾经的访问总人数
//曾经的人与现在访问人相加
$num = $num + $person;
//更新到数据库里面
//update自带写锁，select自带读锁，但是它们的作用范围都是一行语句
//所以有多行语句，或者要处理sql语句的记过，再操作就需要手动的加锁
$u_sql = "update lock_num set num = $num where id = 1";
mysqli_query($db, $u_sql);
flock($fp, LOCK_UN);
}
fclose($fp);
再用ab来测试一下：/working/httpd-2.4/bin/ab -n 500 -c 50 http://127.0.0.1/lock.php
确实添加进数据了。
再查看项目目录：确实出现了lock.txt这个文件
文件锁只能在单台服务器使用。
mysql锁可以在多台服务器使用。
十一、主从服务器
1、什么是主从服务器
主从服务器：一台服务器设置成为主服务器，一台服务器设置成为从服务器。
mysql服务器的抗压能力有限。
假设一台服务器最多能够接受的并发请求数是500个。当并发超过500的时候，很显然一台服务器就不能正常工作了，就需要更多的服务器来支持。
保证服务器之间的数据及时同步问题，需要使用主从的技术解决方案实现数据同步。
众多业务之中，查询请求为主，修改与写请求相对来说非常少。
应对项目中的实际情况。设置一台服务器专门接受修改与写的请求，这台服务器就会被设置成主服务器；设置一台服务器专门接受查询的请求，这台服务器就会被设置成从服务器。
主服务器的数据变更时，快速的同步到从服务器，保证主从服务器的数据是相同的。这样的架构就是主从架构，同时也实现了读写分离。
2、主从服务器的实现原理
主服务器：
1）开启二进制日志，让修改与写操作的SQL语句，记录到bin日志（二进制日志）。
2）设置集群的唯一id。
3）创建一个从服务器登录主服务器的账户。
从服务器：
1）设置集群的唯一id。
2）使用主服务器提供的账户与其它信息连接上主服务器。
3）从服务器的I/O进程，去主服务器的bin日志里面读取内容，然后保存到从服务器的中继日志里面。
4）从服务器的SQL进程，去中继日志里面读取内容，把读取到的 SQL语句在服务器上面执行一次。
注意：主从服务器开启同步的时候，一定要让主从服务器在同步之前，所有数据保持一致。
例如：主服务器的写SQL语句，同步保存到从服务器。从服务器的SQL进程执行该SQL语句，发现没有这张表，就会报错，同步操作就会异常中断！
注意事项：
1）主从服务器的网络是能够连通的
2）主服务器开启端口允许访问或者关闭防火墙
3、MySQL服务器添加（授权）账号
添加与删除账户
启用新的账户，并且设定密码与权限！
grant 权限 on 库.表 to 账号@IP地址 identified by 密码;
权限：select ：查询权限；all ：所有权限
库： 指定某一个库，使用*代表所有的库
表： 指定某一个表，使用*代表所有的表
账号：设置数据库里面没有的账户名
IP地址：限制账户在指定IP地址上面，才能使用账户登录系统
192.168.182. 53 ：只能是拥有这个IP地址的电脑，才能使用它对应的账户登录系统 。
% :代表所有的IP地址，有的版本不包含127.0.0.1
删除账户：drop user '用户名'@'ip地址';
如果删除账户之前该账户已经登录MySQL了，在删除之后如果没有登出就还是可以继续使用，一旦登出就不能再使用了。
bin-log日志
开启bin-log日志功能
找到MySQL的配置文件：/etc/my.cnf
打开它并修改内容：
[mysqld]
log-bin = filename #这个是文件名
server-id = 1 #一定要设置一个serverid
port = 3306
user = mysql
datadir = /usr/local/mysql/data #bin日志是保存在这个目录下面，不能有重名
socket = /tmp/mysql.sock
query_cache_type = 1
修改完后重启MySQL，每一次重启都会生成一个新的bin日志文件
和bin-log日志相关的一些函数
命令生成新的日志文件
在MySQL下输入：flush logs;
说明：每一个bin日志文件，都会因为长时间存储，文件足够大了。文件大了，就应该生成一个新的文件，把曾经的旧文件，备份起来，存储好。以备以后使用 。
删除全部日志文件，生成新日志文件
reset master
使用这个命令。是删除原来的所有二进制日志文件。生成一个全新的二进制日志文件。
查看日志状态
show master status;
4、可以使用log-bin日志完成数据恢复
bin日志里面，记录的都是sql语句。如果数据丢失，再把里面的sql语句拿出来执行，就实现数据恢复。
说明：开启二进制日志之后，修改或者写的SQL语句，才会记录到bin日志里面。曾经的修改或者写的SQL语句，都已经是过眼云烟！
产生二进制日志数据
执行修改或者写的SQL语句
写SQL：insert into innodb values (null, 'xiao12', 18, 1, 'fjsd');
更新SQL：update innodb set name = '123456654321' where id = 1;
查看二进制日志内容：工具应用
找到查看工具：/usr/local/mysql/bin/目录下的mysqlbinlog文件。
使用一下：/usr/local/mysql/bin/mysqlbinlog --base64-output=decode-rows -v /usr/local/mysql/data/bin-log.000001
查看二进制日志内容：命令应用
show binlog events;用于查看当前正在使用的二进制日志文件。
查看指定的二进制文件：show binlog events in '二进制文件文件名';
这个是5.7版本升级之后的效果，5.5版本的效果不是这个样子！5.7版本的查看这些就已经非常的难了。
数据消失应采取的措施
误操作：删除表。
恢复手段：使用innodb备份文件：/tmp/innodb.sql，可以直接恢复。
查看二进制日志与show binlog events确定位置
时间恢复 | 起始位置与结束位置来进行恢复！
时间的问题：1秒可以插入10条数据；数据掉了5条，想恢复只是这5条。以时间来进行恢复，就会把10条数据都恢复。有重复的5条数据，就会报错。
恢复工具：/usr/local/mysql/bin/mysqlbinlog --help
--start-datetime ：时间
--start-position ：开始位置
确定以位置来进行恢复！
--stop-position ：结束位置
mysqlbinlog –start-position=开始位置 --stop-position=结束位置 二进制日志文件路径 | mysql –u root –p [库名]
恢复表数据
第一步：还原一下：/usr/local/mysql/bin/mysql/ -u root -p test < /tmp/innodb/sql
第二步：使用二进制日志进行恢复
在日志中可以找到update开始位置和结束的位置。
按照我的日志显示是开始位置：219；结束位置：762
进行恢复：/usr/local/mysql/bin/mysqlbinlog --start-position=219 --stop-position=762 /usr/local/mysql/data/filename.000001 | /usr/local/mysql/bin/mysql -u root -p -test
十二、主从复制的配置
1、配置主服务器
设定主从服务器：一定是主服务器版本低于或者相同于从服务器。最佳的情况是主从服务器的版本一致。
说明：linux上面的mysql是5.7版本的；win上面的mysql是5.5版本的。
确定主服务器是win上面的。
（1）开启二进制日志
打开在windows上mysql.ini配置文件，设置集群的唯一id：
[mysqld]
log-bin = bin-log
server-id = 8 #集群里面，不要有重复的
......
重启服务器。
（2）创建从服务器登录主服务器的授权账户
权限：replication slave
grant replication slave on *.* to 'slave'@'%' identified by '123456';
关闭防火墙。
2、配置从服务器
（1）设置集群的唯一id
在linux中打开mysql配置文件：vim /etc/my.cnf
[mysqld]
log-bin = bin-log
server-id = 1 #集群里面，不要有重复的
......
保存重启mysql服务器
（2）连接主服务器设置
需要主服务器提供如下信息：
change master to
master_host=’192.168.182.52’
master_port=3306
master_user=’slave’
master_password=’123456’
master_log_file=’log-bin.000001’ #这个的值是主服务器的二进制文件的文件名
master_log_pos=250 #这个值是主服务器的二进制文件最新的位置
重点说明：开始进行主服务器与从服务器的数据同步！把所有的主服务器的内容都复制到从服务器上面。
因为数据的同步，就是在从服务器上面再次执行SQL语句，没有库没有表，就会执行报错。
假装同步：
配置从服务器：
change master to master_host='192.168.182.52',
master_port=3306,
master_user='slave',
master_password='123456',
master_log_file='log-bin.000001',
master_log_pos=250;
3、从服务器管理
查看从服务器状态：show salve status\G;
启动从服务器：start slave;
停止从服务器：stop slave;
清空从服务器配置：reset slave all ;
在查看从服务器状态时，Slave_IO_Running和Slave_SQL_Running的值都是yes时，才是启动成功
出现错误信息时，记录在Last_Errno和Last_Error中
从服务器已经停止了在主服务器上面把拿数据过来，此时不会再同步了 。
每一次从服务器去主服务器取数据的时候，都会记录最后一次取数据的位置。然后下一次去取的时候，就是从这个位置开始向下取的。
从服务器的修改与写入操作，都不会记录到主服务器上面的。所以修改或者写操作，必须由主服务器完成。
4、读写分离的配置
PHP代码层面实现：
主服务器：192.168.182.52;
从服务器：192.168.182.53;
$db1 = mysqli_connect(); 主服务器
$db2 = mysqli_connect(); 从服务器
$sql = “select” 这条sql是你写的。你知道它是查询，请使用$db2操作mysqli_query($db2, $sql);
$sql = “insert” 这条sql是你写的。你知道它是写的，请使用$db1操作mysqli_query($db1,\ $sql);
十三、定时任务
查看程序所在路径：whereis vim
也可以使用find，但是这种方式搜文件名比较慢。
date指令：
%M是分钟数；%S是秒数：date +%M----%S显示出的结果41----55
可以使用转义符：\
date +\%M----\%S
创建一个文件：名称由当前的分与秒组成
touch ./file-$(date +\%M-\%S).php创建后的文件名：file-44-09.php
$()：在这里面可以写Linux的命令，会解析LINUX的命令。
1、什么是定时任务
指定时间自动运行的程序，就是定时任务。
2、为什么需要定时任务
很多工作需要定时定点完成，这个时候就需要定时任务！
例：按天分析用户的访问数据。
用户的一天时间是0 – 23 点，当一天结束之后，项目立即需要对用户访问数据进行分析，然后处理入库。
提早把数据分析，处理入库的代码写好，测试通过；设定一个定时任务，0晨执行该代码，就可以完成数据处理。
定时任务充斥着整个项目。完整的一个项目，有许多的定时任务。他们在指定的时间，运行这些程序，完成项目中各种各样的需求。
3、定时任务语法介绍
语法：
时间参数 执行命令（绝对路径） 命令参数 [ &> /dev/null ]
语法分解：
/dev/null ：这个设备叫数据黑洞，无论写入多少内容，直接吞掉，无法恢复。
&> ：成功或者失败的消息，全部写入设备 /dev/null
命令参数 ：根据执行命令决定参数内容
执行命令 ：根据需求，选择合适的命令
时间参数 ：
分 时 天 月 星期 ：对应的5个位置，必须有值！
* * * * * ：重点【*】使用【每】来代表。
1 * * * * ：每小时的第1分钟，执行命令
2 * 1 * * ：每月第1天每小时的第2分钟，执行命令
1 * * * 1 ：每周一的每月每天每小时第1分钟，执行命令
*/2 * * * * ：每小时的每2分钟，执行命令
*/4 * * * 2 ：每周二的每小时的每4分钟，执行命令
1 */3 * * * ：每天的每三个小时的第1分钟，执行命令
1 1-5 * * * ：每天的第1小时到第5小时的第1分钟，执行命令
1 1 * * 1,3 ：星期一和星期三的每天第1小时第1分钟，执行命令
1 1,4 * * * ：每天的第1小时和第4小时的第1分钟，执行命令
4、定时任务命令介绍
crontab 选项参数
-l : 查看已经设定好的定时任务
-e: 编辑定时任务：使用方式和vim的操作一致
添加一个定时任务：添加定时任务语法即可！
删除一个定时任务：删除该行任务内容即可！
-r： 清除所有的定时任务
确定一个定时任务：
每2分钟创建一个文件，并且文件名包含当前分与秒！
crontab -e
*/2 * * * * /bin/touch /root/file-$(date +\%M-\%S).txt &> /dev/null
等待2分钟后可以查看结果。
清空创建任务
crontab -r
crontab -l