【MySQL】6.MySQL主从复制和读写分离

Mo_nor

已于 2024-04-18 14:35:30 修改

阅读量1.3k

点赞数 36

文章标签：服务器运维

于 2024-03-28 23:15:06 首次发布

本文链接：https://blog.csdn.net/Mo_nor/article/details/137103739

版权

主从复制

主从复制与读写分离

通常数据库的读/写都在同一个数据库服务器中进行；
但这样在安全性、高可用性和高并发等各个方面无法满足生产环境的实际需求；
因此，通过主从复制的方式同步数据，再通过读写分离提升数据库的并发负载能力
类似于sync，但sync是对磁盘文件做备份，而mysql主从复制是对数据库中的数据、语句做备份

mysql支持的复制类型

1.statement：基于语句的复制；
在服务器上执行sql语句，在从服务器上执行同样的语句；
mysql默认采用基于语句的复制，执行效率高

2.row：基于行的复制；
把改变的内容复制过去，而不是把命令从服务器上执行一遍

3.mixed：混合类型的复制；
默认采用基于语句的复制，一旦发现基于语句无法精确复制时，就采用基于行复制

主从复制的工作过程

1.mysql节点将数据的改变，记录到二进制日志(bin log)中；
当master上的数据发生改变时，就会将其写入二进制日志中

2.slave节点会在一定时间间隔内对master的二进制日志文件进行探测，看是数据否发生改变；
如果有变，就会开始一个I/O线程去请求msater的二进制日志

3.同时master 节点会为每一个I/O线程启动一个dump线程；
用于向其发送二进制事件，并保存到slave节点本地的中继日志文件(relay log)中；
slave节点将启动sql线程从中继日志中读取二进制日志，并解析成sql语句在本地逐一执行；
保证slave节点与master节点数据一致；
最后I/O线程和sql线程会进入睡眠状态，等待下一次被唤醒

ps：

中继日志通常位于 os 缓存中，所以中继日志的开销很小；
复制过程有一个很重要的限制，复制在slave上是串行化的；也就是说，msater上的并行更新操作不能在slave上操作

mysql主从复制延迟

1.master服务器高并发，形成大量事务；slave来不及复制执行
2.网络延迟
3.主从设备硬件差异(cpu主频、内存io、硬盘io)导致
4.本来就不是同步复制而是异步复制

从库优化mysql参数；增大innodb_buffer_pool_size，让更多操作在Mysql内存中完成，减少磁盘操作
从库使用高性能主机；包括cpu强悍、内存加大。避免使用虚拟云主机，使用物理主机，这样提升了i/o方面性。
从库使用SSD磁盘；
网络优化，避免跨机房实现同步(尽量在同一个路由器下做)

核心

核心为：两个日志，三个线程；工作原理和流程

实验

环境准备

master服务器：192.168.67.12    mysql5.7
slave服务器：192.168.67.13    mysql5.7
slave服务器：192.168.67.14    mysql5.7
amoeba服务器：192.168.67.11    jdk1.6，amoeba
客户端服务器：192.168.67.11


systemctl stop firewalld
systemctl disable firewalld
setenforce 0

mysql主从服务器时间同步

主服务器安装ntp

#查看是否安装ntp
[root@master ~]# rpm-q ntp
 
#安装ntp
[root@master ~]# yum -y install ntp

[root@master ~]# vim /etc/ntp.conf 
--末尾添加--
#设置本地为时钟源，注意修改网段127.127.主库网段.0
server 127.127.67.0
#设置时间层级，标准为8（限制在15内）
fudge 127.127.67.0 stratum 8

开启服务

#开启服务
[root@master ~]# service ntpd start 
Redirecting to /bin/systemctl start ntpd.service

同步为北京时间

[root@master ~]# date -R
Thu, 28 Mar 2024 00:12:07 -0700

[root@master ~]# timedatectl set-timezone Asia/Shanghai
[root@master ~]# date -R
Thu, 28 Mar 2024 15:13:59 +0800

从服务器安装ntpdate

[root@slave1 ~]# yum -y install ntpdate
[root@slave2 ~]# yum -y install ntpdate

slave开启ntpd，进行时间同步

[root@slave1 ~]# /usr/sbin/ntpdate 192.168.67.12
28 Mar 00:21:30 ntpdate[5317]: adjust time server 192.168.67.12 offset 0.005099 sec
[root@slave1 ~]# date
Thu Mar 28 00:21:45 PDT 2024
[root@slave2 ~]# /usr/sbin/ntpdate 192.168.67.12
28 Mar 00:21:30 ntpdate[5317]: adjust time server 192.168.67.12 offset 0.005099 sec
[root@slave2 ~]# date
Thu Mar 28 00:21:45 PDT 2024


#命令执行成功但是时间没有完成同步的话，就直接也同步成北京时间吧
[root@slave1 ~]# timedatectl set-timezone Asia/Shanghai
[root@slave2 ~]# timedatectl set-timezone Asia/Shanghai

报错

[root@slave1 ~]# /usr/sbin/ntpdate 192.168.67.12
28 Mar 00:03:19 ntpdate[4967]: the NTP socket is in use, exiting
#表示ntp服务被占用

#关闭防火墙和安全等级
systemctl stop firewalld.service 
setenforce 0

设置定时任务，每30分钟与master进行一次时间同步

crontab -e

* /30 * * * /usr/sbin/ntpdate 192.168.67.12

主服务器的mysql配置

[root@master ~]# vim /etc/my.cnf

server-id = 1
#添加主服务器，开启二进制日志
log-bin=master-bin
binlog_format = MIXED
#允许slave从master复制数据并写入到自己的二进制日志
log-slave-updates=true

重启mysql

[root@master ~]# systemctl restart mysqld

登录mysql，给从服务器授权

[root@master ~]# mysql -uroot -p123456

#replication slave固定格式，表示所有从服务器拥有权限
mysql> grant replication slave on *.* to 'myslave'@'192.168.67.%' identified by '123456';
Query OK, 0 rows affected, 1 warning (0.00 sec)

#刷新权限
mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)

查看主服务器的状态

mysql> show master status;
#显示如下，表示配置正确
+-------------------+----------+--------------+------------------+-------------------+
| File              | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+-------------------+----------+--------------+------------------+-------------------+
| master-bin.000001 |      603 |              |                  |                   |
+-------------------+----------+--------------+------------------+-------------------+
1 row in set (0.00 sec)
#File 列显示日志名，Position 列显示偏移量

从服务器的mysql配置

[root@slave1 ~]# vim /etc/my.cnf

#修改，注意id与Master的不同，两个Slave的id也要不同
server-id = 11
#添加，开启中继日志，从主服务器上同步日志文件记录到本地
relay-log=relay-log-bin
#添加，定义中继日志文件的位置和名称，一般和relay-log在同一目录
relay-log-index=slave-relay-bin.index
#选配项；
#当 slave 从库宕机后，假如 relay-log 损坏了，导致一部分中继日志没有处理，则自动放弃所有未执行的 relay-log，并且重新从 master 上获取日志，这样就保证了relay-log 的完整性。默认情况下该功能是关闭的，将 relay_log_recovery 的值设置为 1 时， 可在 slave 从库上开启该功能，建议开启。
relay_log_recovery = 1

[root@slave2 ~]# vim /etc/my.cnf
server-id = 12
relay-log=relay-log-bin
relay-log-index=slave-relay-bin.index
relay_log_recovery = 1


重启mysql
[root@slave1 ~]# systemctl restart mysqld
[root@slave2 ~]# systemctl restart mysqld

配置同步

#进入从库的mysql
mysql -uroot -p123


mysql> change master to master_host='192.168.67.12',master_user='myslave',master_password='123456',master_log_file='master-bin.000001',master_log_pos=603;
Query OK, 0 rows affected, 2 warnings (0.02 sec)

启动同步

#启动同步；如有报错执行 reset slave;
start slave;

查看从服务器的状态

#查看 Slave 状态
show slave status\G;
//确保 IO 和 SQL 线程都是 Yes，代表同步正常。
*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                  Master_Host: 192.168.67.12
                  Master_User: myslave
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: master-bin.000001
          Read_Master_Log_Pos: 1052
               Relay_Log_File: relay-log-bin.000002
                Relay_Log_Pos: 770
        Relay_Master_Log_File: master-bin.000001
            #负责与主机的io通信
             Slave_IO_Running: Yes
            #负责自己的slave mysql进程
            Slave_SQL_Running: Yes
              Replicate_Do_DB: 
          Replicate_Ignore_DB: 
           Replicate_Do_Table: 
       Replicate_Ignore_Table: 
      Replicate_Wild_Do_Table: 
  Replicate_Wild_Ignore_Table: 
                   Last_Errno: 0
                   Last_Error: 
                 Skip_Counter: 0
          Exec_Master_Log_Pos: 1052
              Relay_Log_Space: 975
              Until_Condition: None
               Until_Log_File: 
                Until_Log_Pos: 0
           Master_SSL_Allowed: No
           Master_SSL_CA_File: 
           Master_SSL_CA_Path: 
              Master_SSL_Cert: 
            Master_SSL_Cipher: 
               Master_SSL_Key: 
        Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
                Last_IO_Errno: 0
                Last_IO_Error: 
               Last_SQL_Errno: 0
               Last_SQL_Error: 
  Replicate_Ignore_Server_Ids: 
             Master_Server_Id: 1
                  Master_UUID: f266c8ca-e5ad-11ee-a96d-000c29ab119c
             Master_Info_File: /usr/local/mysql/data/master.info
                    SQL_Delay: 0
          SQL_Remaining_Delay: NULL
      Slave_SQL_Running_State: Slave has read all relay log; waiting for more updates
           Master_Retry_Count: 86400
                  Master_Bind: 
      Last_IO_Error_Timestamp: 
     Last_SQL_Error_Timestamp: 
               Master_SSL_Crl: 
           Master_SSL_Crlpath: 
           Retrieved_Gtid_Set: 
            Executed_Gtid_Set: 
                Auto_Position: 0
         Replicate_Rewrite_DB: 
                 Channel_Name: 
           Master_TLS_Version: 
1 row in set (0.00 sec)

ERROR: 
No query specified

一般情况下，Slave_IO_Running:No 的可能性：

1.网络不通
2.my.cnf配置有问题
3.密码、file文件名、pos偏移量配置的不对
4.防火墙没有关闭

验证主从复制

主服务器上进行执行建库、建表;
查看主服务器和从服务器上数据库的情况

如数据中途加入主从复制的库需要导出主服务器库的库文件并且导入到从服务器中

读写分离

读写分离作用：解决高并发
为什么做读写分离：锁行锁表，影响使用；

1.什么是读写分离？

一般来说是让主数据库处理事务性增、改、删操作（INSERT、UPDATE、DELETE），而从数据库处理SELECT查询操作。数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库。

2.为什么做读写分离？

数据库“写”操作是比较耗时的；但“读”是很快的(相比写快得多)
例如：有1000条数据，写可能要3分钟，读可能只要5秒钟
所以读写分离可以解决，由于数据库的写入使查询效率变慢的问题

3.什么情况下要做读写分离

程序使用数据库多，但更新少，查询多的情况下考虑使用；
利用数据库主从同步，通过读写分离来分担数据库压力，提高性能

mysql读写分离的原理

读写分离：只在主服务器上写，只在从服务器上读；

常见的mysql读写分离类型

1.基于程序代码内部实现

在代码中根据select、insert 进行路由分类；是目前生产环境应用最广泛的方法

优点：性能好，不需要额外的硬件设备
缺点：需要开发人员来实现，运维做不了；
而且并不是所有应用都适合在程序代码中实现读写分离，
大型复杂的java应用，如果在程序代码中实现读写分离，对代码改动就比较大；不合适

2.基于中间代理层实现

代理一般位于客户端和服务器之间，代理服务器接到客户端的请求通过判断后转发到后端数据库；

主要有以下的代表性程序：

mysql-proxy：是MySQL的开源项目，通过其自带的lua脚本进行sql判断

由于使用MySQL Proxy 需要写大量的Lua脚本，这些Lua并不是现成的，而是需要自己去写。这对于并不熟悉MySQL Proxy 内置变量和MySQL Protocol 的人来说是非常困难的。

altas：是由奇虎360的Web平台部基础架构团队开发维护的一个基于MySQL协议的数据中间层项目；
它是在mysql-proxy 0.8.2版本的基础上，对其进行了优化，增加了一些新的功能特性；
360内部使用Atlas运行的mysql业务，每天承载的读写请求数达几十亿条；
支持事物以及存储过程。

amoeba：由陈思儒开发，作者曾就职于阿里巴巴；
该程序由Java语言进行开发，阿里巴巴将其用于生产环境；
但是它不支持事务和存储过程。

Amoeba是一个非常容易使用、可移植性非常强的软件。因此它在生产环境中被广泛应用于数据库的代理层。

读写分离实验

amoeba服务器配置

环境

master服务器：192.168.67.12    mysql5.7
slave服务器：192.168.67.13    mysql5.7
slave服务器：192.168.67.14    mysql5.7
amoeba服务器：192.168.67.11    jdk1.6，amoeba
客户端服务器：192.168.67.11


systemctl stop firewalld
systemctl disable firewalld
setenforce 0

主、从安装jdk1.6

#上传amoeba和jdk1.6的包
[root@amoeba opt]# rz -E
rz waiting to receive.
[root@amoeba opt]# rz -E
rz waiting to receive.
[root@amoeba opt]# ls
amoeba-mysql-binary-2.2.0.tar.gz  jdk-6u14-linux-x64.bin  rh
[root@amoeba opt]# 


[root@amoeba opt]# cp jdk-6u14-linux-x64.bin /usr/local/
[root@amoeba opt]# cd /usr/local/
[root@amoeba local]# ls
bin  games    jdk-6u14-linux-x64.bin  lib64    sbin   src
etc  include  lib                     libexec  share
#给执行权限
[root@amoeba local]# chmod +x jdk-6u14-linux-x64.bin 
#执行
[root@amoeba local]# ./jdk-6u14-linux-x64.bin 
执行后，一直按空格，直到more消失、看到yes；输入yes，按回车
//按enter回车

出现下面的窗口直接点否即可

[root@amoeba local]# ls
bin  games    jdk1.6.0_14             lib    libexec  share
etc  include  jdk-6u14-linux-x64.bin  lib64  sbin     src
[root@amoeba local]# mv jdk1.6.0_14/ /usr/local/jdk1.6
[root@amoeba local]# ls
bin  games    jdk1.6                  lib    libexec  share
etc  include  jdk-6u14-linux-x64.bin  lib64  sbin     src

修改环境变量，并刷新

#配置环境变量
[root@amoeba local]# vim /etc/profile
#--G--o--在页尾添加
export JAVA_HOME=/usr/local/jdk1.6
export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib:$JAVA_HOME/jre/lib
export PATH=$JAVA_HOME/lib:$JAVA_HOME/jre/bin/:$PATH:$HOME/bin
export AMOEBA_HOME=/usr/local/amoeba
export PATH=$PATH:$AMOEBA_HOME/bin

#刷新环境变量文件
[root@amoeba local]# source /etc/profile
[root@amoeba local]# java -version
java version "1.6.0_14"
Java(TM) SE Runtime Environment (build 1.6.0_14-b08)
Java HotSpot(TM) 64-Bit Server VM (build 14.0-b16, mixed mode)

安装amoeba软件192.168.67.11

#解压amoeba包
[root@amoeba local]# cd /opt/
[root@amoeba opt]# ls
amoeba-mysql-binary-2.2.0.tar.gz  jdk-6u14-linux-x64.bin  rh
[root@amoeba opt]# mkdir /usr/local/amoeba
[root@amoeba opt]# tar zxvf amoeba-mysql-binary-2.2.0.tar.gz -C /usr/local/amoeba/

#赋权
[root@amoeba opt]# chmod -R 755 /usr/local/amoeba/
#执行amoeba，显示amoeba start|stop 说明安装成功
[root@amoeba opt]# /usr/local/amoeba/bin/amoeba
amoeba start|stop
[root@amoeba opt]#

配置 Amoeba读写分离，两个 Slave 读负载均衡

#进入数据库
[root@slave1 ~]# mysql -uroot -p123

#先在Master、Slave1、Slave2 的mysql上开放权限给 Amoeba 访问
#给master和两台slave配置一个test用户并赋权
mysql> grant all on *.* to test@'192.168.67.%' identified by '123456';
Query OK, 0 rows affected, 1 warning (0.01 sec)
mysql> grant all on *.* to test@'192.168.67.%' identified by '123456';
Query OK, 0 rows affected, 1 warning (0.00 sec)
mysql> grant all on *.* to test@'192.168.67.%' identified by '123456';
Query OK, 0 rows affected, 1 warning (0.00 sec)


#查看test用户的权限
mysql> show grants for test@'192.168.67.%';
+------------------------------------------------------+
| Grants for test@192.168.67.%                         |
+------------------------------------------------------+
| GRANT ALL PRIVILEGES ON *.* TO 'test'@'192.168.67.%' |
+------------------------------------------------------+
1 row in set (0.00 sec)

回到amoeba服务器配置amoeba服务

[root@amoeba opt]# cd /usr/local/amoeba/conf/
[root@amoeba conf]# ls
access_list.conf  dbserver.dtd   functionMap.xml  rule.dtd
amoeba.dtd        dbServers.xml  log4j.dtd        ruleFunctionMap.xml
amoeba.xml        function.dtd   log4j.xml        rule.xml
#先备份再修改，安全
[root@amoeba conf]# cp amoeba.xml amoeba.xml.bak
#修改amoeba配置文件
[root@amoeba conf]# vim amoeba.xml

--30行--user设为amoeba
<property name="user">amoeba</property>
--32行--密码设为123456
<property name="password">123456</property>
--115行--默认池为master
<property name="defaultPool">master</property>
--117-去掉注释-读为master，写为slaves
<property name="writePool">master</property>
<property name="readPool">slaves</property>

[root@amoeba conf]# ls
access_list.conf  amoeba.xml.bak  function.dtd     log4j.xml            rule.xml
amoeba.dtd        dbserver.dtd    functionMap.xml  rule.dtd
amoeba.xml        dbServers.xml   log4j.dtd        ruleFunctionMap.xml
#先备份一下
[root@amoeba conf]# cp dbServers.xml dbServers.xml,bak
#然后修改配置文件
[root@amoeba conf]# vim dbServers.xml

--23行--注释掉  作用：默认进入test库 以防mysql中没有test库时，会报错
<!-- <property name="schema">test</property> -->
--26--修改
<property name="user">test</property>
--28-30--去掉注释
<property name="password">123456</property>
--45--修改，设置主服务器的名Master
<dbServer name="master"  parent="abstractServer">
--48--修改，设置主服务器的地址
<property name="ipAddress">192.168.67.12</property>
--52--修改，设置从服务器的名slave1
<dbServer name="slave1"  parent="abstractServer">
--55--修改，设置从服务器1的地址
<property name="ipAddress">192.168.67.13</property>
--58--复制上面6行粘贴，设置从服务器2的名slave2和地址
<dbServer name="slave2"  parent="abstractServer">
<property name="ipAddress">192.168.67.14</property>
--65行--修改
<dbServer name="slaves" virtual="true">
--68行--根据67行可得1表示轮询，不用改
<property name="loadbalance">1</property>
--71行--修改
<property name="poolNames">slave1,slave2</property>

启动amoeba

#启动amoeba，&前要加空格表示后台执行
[root@amoeba conf]# /usr/local/amoeba/bin/amoeba start &
[1] 10941
[root@amoeba conf]# log4j:WARN log4j config load completed from file:/usr/local/amoeba/conf/log4j.xml
2024-03-28 03:52:58,806 INFO  context.MysqlRuntimeContext - Amoeba for Mysql current versoin=5.1.45-mysql-amoeba-proxy-2.2.0
log4j:WARN ip access config load completed from file:/usr/local/amoeba/conf/access_list.conf
2024-03-28 03:52:58,962 INFO  net.ServerableConnectionManager - Amoeba for Mysql listening on 0.0.0.0/0.0.0.0:8066.
2024-03-28 03:52:58,979 INFO  net.ServerableConnectionManager - Amoeba Monitor Server listening on /127.0.0.1:60369.
#按ctrl+c 返回
^C

[root@amoeba conf]# lsof -i:8066
COMMAND   PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
java    10941 root   55u  IPv6  74178      0t0  TCP *:8066 (LISTEN)
#查看8066端口是否开启，amoeba默认端口为TCP 8066
[root@amoeba conf]# netstat -anpt | grep java
tcp6       0      0 127.0.0.1:51646         :::*                    LISTEN      13892/java          
tcp6       0      0 :::8066                 :::*                    LISTEN      13892/java          
tcp6       0      0 192.168.67.11:35286     192.168.67.14:3306      ESTABLISHED 13195/java          
tcp6       0      0 192.168.67.11:52086     192.168.67.12:3306      ESTABLISHED 13195/java          
tcp6       0      0 192.168.67.11:46220     192.168.67.13:3306      ESTABLISHED 13195/java 
...省略

客户端配置

#安装mariadb 并开启服务
[root@amoeba ~]# yum -y install mariadb-server mariadb

[root@amoeba ~]# systemctl start mariadb.service

#连接amoeba服务器
[root@amoeba ~]# mysql -uamoeba -p123456 -h 192.168.67.11 -P8066
//通过amoeba服务器代理访问mysql ，在通过客户端连接mysql后写入的数据只有主服务会记录，然后同步给从服务器
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MySQL connection id is 1369543768
Server version: 5.1.45-mysql-amoeba-proxy-2.2.0 Source distribution

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MySQL [(none)]>

测试

#在主服务器上创建库school和表class
mysql> create database school;
mysql> use school;
mysql> create table class (id int(2) zerofill,name char(10),score decimal(5,2));
#可以看到从服务器会同步写入

#在两台从服务器上
#关闭同步
mysql> stop slave;
Query OK, 0 rows affected (0.00 sec)

#分别从master、slave1和slave2上添加一条数据，然后通过客户端查看
//在master上
mysql> insert into class values(1,'master',100);
Query OK, 1 row affected (0.00 sec)
//在slave1上
mysql> insert into class values(2,'slave1',90);
Query OK, 1 row affected (0.01 sec)
//在slave2上
mysql> insert into class values(3,'slave2',90);
Query OK, 1 row affected (0.00 sec)

从客户端查询class表数据

MySQL [school]> select * from class;
//客户端会分别向slave1和slave2读取数据，每次只会读取其中之一（轮询显示）；
//显示的只有在两个从服务器上添加的数据，没有在主服务器上添加的数据

可以看到客户机只能看到从数据库的信息，而且每次只能看到其中一个库的数据

从客户机端，向表中添加数据

#从客户机向class表写入数据
MySQL [school]> insert into class values(4,'client',70);
//只有主服务器上有此数据

开启两个从库的同步

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

mysql> start slave;                       
Query OK, 0 rows affected (0.00 sec)
//在两个从服务器上执行 start slave; 即可实现同步在主服务器上添加的数据

关闭从服务器的同步，master端删除master和slave1的一条数据

#master端删除01和02数据
mysql> delete from class where id=01;
Query OK, 0 rows affected (0.00 sec)

mysql> delete from class where id=02;
Query OK, 0 rows affected (0.00 sec)
#数据未开启同步前，两个从服务器的数据不会改变

启动从库的同步，再次查看

MySQL [school]> select * from class;

//同步开启，两个从库会同步master库执行过的sql语句；删除01和02

总结

主从复制

通过主从复制的方式同步数据，再通过读写分离提升数据库的并发负载能力

mysql支持的复制类型
mixed：混合类型的复制；
默认采用基于语句的复制，一旦发现基于语句无法精确复制时，就采用基于行复制

主从复制的核心

核心为：两个日志，三个线程；工作原理和流程

主从复制的工作过程★★★

mysql节点将改变的数据记录到二进制日志（bin log）中；
slave节点每隔一段时间会对master的二进制文件进行检测，
当数据发生变化时，会开启一个I/O线程去请求master的二进制日志；
同时master也会启动dump线程来发送二进制事件给slave的I/O线程，
I/O线程会将收到的二进制文件保存到slave节点的中继日志（relay log）中；
之后启动sql线程读取中继日志中的二进制日志，并解析成sql语句在本地逐行执行；
确保主从数据一致；
最后，I/O线程和sql线程会进入睡眠状态，等待下一次唤醒

主从复制延迟的原因有：

解决办法：

从库优化mysql参数；使用高性能主机；使用SSD磁盘；避免跨机房实现同步；

主从复制配置

关闭主、从的防火墙，防火墙自启和安全机制
主库安装ntp，从库安装ntpdate，做时间同步
   主库设置为时钟源，时间层级为8
   开启ntpd服务，同步为北京时间
   timedatectl set-timezone Asia/Shanghai
从服务器安装ntpdate，并开启ntpd
   crontabe -e设置定时任务
主服务器配置my.cnf文件，添加
   server-id = 1
   log-bin=master-bin
   binlog_format = MIXED
   log-slave-updates=true
   重启mysql，并登录
   给从服务器授权
   grant replication slave on *.* to 'myslave'@'192.168.67.%' identified by '123456';
   flush privilieges;刷新权限
   show master status;查看主的状态，file和position
从服务器配置my.cnf文件，写入
   server-id = 12
   relay-log=relay-log-bin
   relay-log-index=slave-relay-bin.index
   relay_log_recovery = 1
   配置同步
   change master to master_host='192.168.67.12',master_user='myslave',master_passsword='123456',master_log_file='master-bin.000001',master_log_pos=603;
   start slave;启动同步
   show slave status\G;#查看 Slave 状态
添加修改数据，验证主从复制