mysql调优备份恢复

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |  --存放数据库的信息对象，包括表，列，字符集，校验规则，权限，视图，触发器等
| mysql              |
| test               |

 

1，查询数据库中所有的表名，及其使用的存储引擎
mysql> select table_name,engine from tables;

2，查询数据库中有唯一性约束的表名及其哪个库(schema)
mysql> select CONSTRAINT_SCHEMA,CONSTRAINT_TYPE,table_name from TABLE_CONSTRAINTS where CONSTRAINT_TYPE='UNIQUE';

3，查询数据库中所有有索引的表，及其使用的索引名和索引类型
mysql> select TABLE_NAME,INDEX_NAME,INDEX_TYPE from STATISTICS;

4，查询emp表的列的相关信息
mysql> select COLUMN_NAME from COLUMNS where TABLE_NAME='emp';

5，查询每个库的定义信息（库名，字符集，校验规则等）
mysql> select SCHEMA_NAME,DEFAULT_CHARACTER_SET_NAME,DEFAULT_COLLATION_NAME from SCHEMATA;

6，查询数据库中的视图相关信息
mysql> select * from VIEWS\G;

7，查询root@localhost的权限
mysql> select * from USER_PRIVILEGES where grantee="'root'@'localhost'";

8，查询用户及其密码信息
mysql> select user,host,password from mysql.user;

9，查询数据库支持的字符集，校验规则，和字符集与校验规则的对应信息
mysql> select * from CHARACTER_SETS;

 

================================================================

mysql数据库的权限有四个等级

全库级(*.*)，库级(source.*)，表级(source.emp)，列级(source.emp.ename)

高等级权限覆盖低等级权限

下面的授权方式，请问aaa用户是否对emp有insert权限？
grant select on source.emp  to 'aaa'@'localhost' identified by '123';
grant all on source.*  to 'aaa'@'localhost' identified by '123';

 

例，在test库下建一张表，然后授权一个普通用户对其只有select权限

验证：使用这个被授权的普通用户登录后，发现对test库下的这张表有所有权限

 

原因：
mysql> select * from mysql.db where db='test'\G;
--这里可以看到的是test库对所有用户几乎有所有的权限；它是一个测试库；在生产环境为了安全是要删除它的

 

==============================================================

 

 

query cache的原理：简单来说就是将客户端请求的query语句（仅限select类型
的query)通过一定的hash算法进行一个计算，得到一个hash值，存放在一个hash
桶中。同时将该query的结果集（Result Set)也存放在一个内存cache中。存
放query hash值的链表中每一个hash值所在节点的同时，还存放了该query所对应
的Result Set的Cache所在的内存地址，以及该query涉及的所有table的标识等
一些其他相关信息。系统接受到任何一个select类型的query时，首先计算出其has
h值，然后通过该hash值到query cache中去匹配，如果找到了完全相同的query，
则直接将之前所缓存（cache)Result set返回给客户端，完全不须要进行后面的任
何步骤就可完成这次请求。而后端的任何一个表的任何一条数据发生变化之后，也
会通知Query cache，须要将所有与该table有关的query的cache全部失效，并释
放出之前占用的内存地址，以便后面其他的Query能够使用。

   query cache的负面影响
 1。query语句的hash运算及hash查找资源消耗。虽然hash运算和查找的
过程也已经足够的优化了，对于一条query来说消耗的资源确实是非常之少，但是当
每秒都有上千甚至几千条query时，就不能对产生的cpu消耗完全忽视了。

 2。query cache的失效问题。如果表的变更比较频繁，则会造成query
 cache的失效率非常高，表中数据，结构，或索引等的任何变更都会造成将缓存
到query cache中的cache数据被清除，导致新的相同query进来后无法使用到之前
的cache。

 3。query cache中缓存的是Result Set，而不是数据页，也就是说，存
在同一条记录被cache多次的可能性，从而造成内存资源的过渡消耗。

   使用query cache
 首先，须判断哪些表适合使用query cache；避免在查询变化频繁的table
的query上使用，而应该在那些查询变化频率较低的table的query上使用。mysql
中针对query cache有两个专用的SQL Hint(提示）：SQL＿NO＿CACHE和
SQL＿CACHE，分别代表强制不使用query cache和强制使用query cache.对于那
些变化非常少，大部分时候都是静态的数据，可以添加SQL＿CACHE的SQL Hint，
强制Mysql使用QUERY cache,从而提高该表的查询性能。

 

mysql> show variables like '%query_cache%';
+------------------------------+---------+
| Variable_name                | Value   |
+------------------------------+---------+
| have_query_cache             | YES     | mysql是否支持query_cache
| query_cache_limit            | 1048576 | query cache存放的单条query最大Result Set,默认1MB
| query_cache_min_res_unit     | 4096    | 每个result set存放的最小内存大小，默认4KB；
| query_cache_size             | 0       | query_cache_size系统用于query cache内存的大小
| query_cache_type             | ON      | 系统是否打开了query cache功能
| query_cache_wlock_invalidate | OFF     | 针对于MYISAM存储引擎，设置当有WRITE LOCK在某个table上时，读请求是要等write lock释放资源后再查询还是允许从query cache中读取结果，默认为FALSE（可以直接从Query cache中取得结果）

mysql> set global query_cache_size=1024*1024*10;  --设置为10M

 

vim /usr/local/mysql/etc/my.cnf

query_cache_size=10M  --定义query_cache的大小为10M
query_cache_type=1  

/etc/init.d/mysql5  restart

mysql> show variables like '%query_cache%';
+------------------------------+----------+
| Variable_name                | Value    |
+------------------------------+----------+
| have_query_cache             | YES      |
| query_cache_limit            | 1048576  |
| query_cache_min_res_unit     | 4096     |
| query_cache_size             | 10485760 |  --再次查看，这里就有10M的大小
| query_cache_type             | ON       |
| query_cache_wlock_invalidate | OFF      |
+------------------------------+----------+

  获取Query Cache相关的状态变量

mysql> show status like '%Qcache%';

| Variable_name           | Value |
+-------------------------+-------+
| Qcache_free_blocks      | 0     | query cache中目前还有多少多余的blocks。如果该值显示较大，则说明内存碎片过多，要找合适机会整理。
| Qcache_free_memory      | 0     | query cache中目前剩余的内存大小
| Qcache_hits             | 0     | 多少次命中
| Qcache_inserts          | 0     | 多少次未命中然后插入 命中率＝Qcache_hits/(Qcache_hits+Qcache_inserts);
| Qcache_lowmem_prunes    | 0     | 多少条query因为内存不足而被清除出query cache
| Qcache_not_cached       | 0     | 因为query_cache_type的设置而不能被缓存cache的query数量,或者是超过了query_cache_limit的单个结果集的设置
| Qcache_queries_in_cache | 0     | 当前query cache中缓存的query数量
| Qcache_total_blocks     | 0     | 当前query cache中的block总数量
+-------------------------+-------+

mysql> create table aaa (id int,name varchar(20));
Query OK, 0 rows affected (0.01 sec)

mysql> insert into aaa values('1','sfdasdf');
Query OK, 1 row affected (0.01 sec)

mysql> insert into aaa select * from aaa;

.........

mysql> insert into aaa select * from aaa;
Query OK, 524288 rows affected (5.36 sec)
Records: 524288  Duplicates: 0  Warnings: 0

mysql> show status like '%Qcache%'; --先查看一下状态

mysql> select * from aaa; --这样查看这个一百多W行的大表

mysql> show status like '%Qcache%'; --可以看到并没有cache，Qcache_not_cached增加了，说明应该是结果集超出了范围不能cache

mysql> select * from aaa limit 10; 

mysql> show status like '%Qcache%'; --可以看到 Qcache_inserts 增加1，并且Qcache_queries_in_cache也增加1

mysql> select * from aaa limit 10;  

mysql> show status like '%Qcache%';  --可以看到这次只有Qcache_hits增加1

mysql> select * FROM aaa limit 10;  --这次把from换成大写，结果是一样的，SQL语句的关键字是不区分大小写的

mysql> show status like '%Qcache%';  --可以看到 Qcache_inserts 增加1，并且Qcache_queries_in_cache也增加1;说明语句需要完全一致再能命中query cache

小实验：验证query cache加快查询速度

mysql> set global query_cache_size=1024*1024*100;  --设大点
Query OK, 0 rows affected (0.00 sec)

mysql> set global query_cache_limit=1024*1024*80; --设大点
Query OK, 0 rows affected (0.00 sec)

mysql> show status like '%Qcache%';  --重设过query cache，那么以前缓存的被清0，但命中次数等还是老数据

mysql> select * from aaa; --查100多W行需要1.5秒左右

mysql> show status like '%Qcache%';  --可以看到刚才的语句被缓存，说明把缓存限制调大能存放这100多W行

mysql> select * from aaa;   --现在只需要大概0.25秒左右；说明query cache里取结果是加快了查询速度

mysql> show status like '%Qcache%';  --确认是命中了

 

---------------------------------------------------------------------------------------------------

mysqlcheck

检查和修复myisam类型表，还可以优化和分析

-a   analyze表
-c   check表
-r   repair表
-o   optimize表

mysqlcheck客户端可以检查和修复MyISAM表。它还可以优化和分析表。

mysqlcheck的功能类似myisamchk，但其工作不同。主要差别是当mysqld服务器在运行时必须使用mysqlcheck，而myisamchk应用于服务器没有运行时。使用mysqlcheck的好处是不需要停止服务器来检查或修复表。

Mysqlcheck为用户提供了一种方便的使用SQL语句CHECK TABLE、REPAIR TABLE、ANALYZE TABLE和OPTIMIZE TABLE的方式。它确定在要执行的操作中使用使用哪个语句，然后将语句发送到要执行的服务器上。

[root@li ~]# /usr/local/mysql/bin/mysqlcheck -p123 -o source
source.dept                                        OK
source.emp                                         OK
source.login                                       OK
source.password                                    OK
source.squid_log                                   OK

[root@li ~]# /usr/local/mysql/bin/mysqlcheck -p123 -c source
source.dept                                        OK
source.emp                                         OK
source.login                                       OK
source.password                                    OK
source.squid_log                                   OK

 

数据库内部还有一个check命令可以检测表

mysql> check table source.squid_log; --check命令检测source库的squid_log表
+------------------+-------+----------+----------+
| Table            | Op    | Msg_type | Msg_text |
+------------------+-------+----------+----------+
| source.squid_log | check | status   | OK       |
+------------------+-------+----------+----------+
1 row in set (6.36 sec)

写一个脚本定期check所有的myisam存储引擎类型的表

1，查找出所有的myisam类型的表
2，做一个循环check table 库名.表名 --使用连接函数concat实现
3，crontab

[root@li ~]# vim /tmp/check_mysql_myisam_tables.sh

#!/bin/bash

findtable ()  {
        /usr/local/mysql/bin/mysql -u root -p123 --skip-column-names <<EOF
select concat(TABLE_SCHEMA,".",TABLE_NAME) from information_schema.tables where engine='MYISAM';
EOF
}

a=`findtable`

for name in $a
do
check () {
/usr/local/mysql/bin/mysql -u root -p123 --skip-column-names <<EOF
        check  table $name
EOF
}

b=`check`
c=`echo $b|awk '{print $4}'`
        if [ "$c" !=  "OK" ] ;then
                echo $name >> /tmp/check_failed.txt
        else
                echo $b >> /tmp/check_ok.txt
        fi
done

 

-------------------------------------------------------------------------------------

innodb  存储引擎，事务性存储引擎

参考官档15.2章节

事务体现

 commit  提交
 rollback 回滚

DML语句需要提交，还提供回滚机制

默认是启动了innodb存储引擎的，show engines;查看到innodb后面是yes状态

在my.cnf配置文件加上--skip-innodb可以把yes变为disable

default_storage_engine=innodb
innodb_data_home_dir=/data07
innodb_data_file_path=ibdata1:20M:autoextend
innodb_log_group_home_dir=/data07
innodb_log_files_in_group=2
innodb_log_file_size=5M

# mkdir /data07
# chown mysql.mysql  /data07

# /etc/init.d/mysql5 restart

[root@li ~]# ls /data07/ -lh
total 31M
-rw-rw---- 1 mysql mysql  20M Aug  2 13:51 ibdata1
-rw-rw---- 1 mysql mysql 5.0M Aug  2 13:52 ib_logfile0
-rw-rw---- 1 mysql mysql 5.0M Aug  2 13:51 ib_logfile1

--然后登录数据库使用show engines;查看默认存储引擎为innodb
--创建一个大表，show create table 表名；去查看，是innodb引擎

[root@li ~]# ll /data07 -lh
total 87M
-rw-rw---- 1 mysql mysql  76M Aug  2 13:56 ibdata1 --数据都会存放在这里
-rw-rw---- 1 mysql mysql 5.0M Aug  2 13:56 ib_logfile0
-rw-rw---- 1 mysql mysql 5.0M Aug  2 13:56 ib_logfile1

事务回滚演示

mysql> show variables like '%autocommit%';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | ON    | --此变量为ON，表示事务都是自动默认提交的
+---------------+-------+

mysql> set autocommit=off; --设置为off

mysql> truncate table aaa;
Query OK, 0 rows affected (0.01 sec)

mysql> select * from aaa;
Empty set (0.00 sec)

mysql> insert into aaa values (1,'dsfasf');
Query OK, 1 row affected (0.00 sec)

mysql> insert into aaa values (1,'dsfasf');
Query OK, 1 row affected (0.00 sec)

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

mysql> insert into aaa values (1,'dsfasf');
Query OK, 1 row affected (0.00 sec)

mysql> insert into aaa values (1,'dsfasf');
Query OK, 1 row affected (0.00 sec)

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

mysql> select * from aaa;
+------+--------+
| id   | name   |
+------+--------+
|    1 | dsfasf |
|    1 | dsfasf |
+------+--------+

 

----------------------------------------------------------------------

用到锁的场景：数据库，代码协同开发（SVN），共享式存储

 

数据库的锁机制

 

锁的级别：

表锁：开销小，加锁快，不会出现死锁，发生锁冲突的概率最高，并发最低，MYISAM使用表锁
行锁：开销大，加锁慢，会出现死锁，发生锁冲突的概率最低，并发度最高；innodb引擎和oracle支持行锁
页锁：介于表锁和行锁之间，BDB引擎支持，已经被innodb取代

闩锁：内存的锁

 

表锁：适合于以查询为主的业务
行锁；适合于事务处理的业务 (oltp)

oltp:联机事务处理  事务小，事务多  （比如银行的前台业务）
olap:联机分析处理  事务大，事务少    (比如数据仓库）

死锁：
 A用户占用1号资源，B用户同时要使用1号资源就产生了等待
 B用户占用2号资源，A用户同时要使用2号资源就产生了等待
  A在等待B释放2号资源，B同时又在等待A释放1号资源   --＞产生了死锁

mysql>SHOW STATUS LIKE 'Table%'; --查看当前数据库的锁定情况
+-----------------------+-------+
| Variable_name         | Value |
+-----------------------+-------+
| Table_locks_immediate | 74    |
| Table_locks_waited    | 0     |
+-----------------------+-------+
2 rows in set (0.00 sec)

 

加锁的方式：
隐式加锁和显式加锁

隐式加锁： 以MYISAM引擎为例 ，执行 select时，会隐式自动给涉及的表加 读锁
  在DML （insert,delete,update)时，会隐式自动给涉及的表加 写锁

显式加锁： DBA手动加锁  lock  table  ...;

 

加锁的方式：
隐式加锁和显式加锁

隐式加锁： 以MYISAM引擎为例 ，执行 select时，会隐式自动给涉及的表加 读锁
  在DML （insert,delete,update)时，会隐式自动给涉及的表加 写锁

显式加锁： DBA手动加锁  lock  table  ...;

 

--加读锁的实验
 

时间点   session 1  session 2
1  lock table emp  read;
   加读锁
2  select * from emp  select * from emp 
   允许   允许
3  insert into emp 操作  insert into emp 操作
   不允许   等待session 1释放读锁
4  unlock table   锁一释放，刚才等待的insert操作
   解锁   会自动insert成功

 

--加写锁的实验

时间点   session 1  session 2
1  lock table emp write;
   加写锁
2  select * from emp;  select * from emp;
   允许       不允许，在等待释放资源
3  insert into emp操作  insert into emp操作
   允许        不允许，在等待释放资源
4  unlock tables   锁一释放，先前等待的操作自动执行

 

--两个session会话，都把autocommit=off改成off，也就是手动提交

测试：在一个innodb引擎的表上，一边insert，另一边也可以insert
     一边update一行，另一边update另一行或者insert一个新行，都不可以 ???

另一种情况：
两个session；一个自动提交，一个手动提交
自动提交插入的数据
在手动提交的session不能马上看到

 

======================================================

mysql  数据库备份和恢复

备份策略：
一，数据库可以关的情况下，直接使用系统的cp命令去拷

二，sql语法备份导出 用于辅助备份

三，mysqldump备份数据库   中小型数据库 备出来的是sql语句，速度慢

四，mysqlhotcopy 备份数据库， 只能是myisam引擎 适合中小型myisam引擎数据库

五，存储层的备份，如lvm（logical volumn management)快照

六，对innodb的备份，innodb引擎的大数据使用mysqldump备份太慢，mysqlhotcopy又不能备份innodb引擎的数据。可以选用mysql自带的企业级备份工具，或者是xtrabackup开源备份工具

 

七，使用集群方案，例如AB复制   实时备份，适合大型数据库

 

1,冷备 （不推荐）  数据库可以关闭的情况下的备份

  1，关闭数据库
   cp -a 源数据文件  目标数据文件
  2，打开数据库

热备   数据库不可以关闭的情况下的备份

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

2，sql语法备份
backup table  原理是先锁表，然后拷贝数据文件，拷.frm和.MYD,不拷 .MYI索引文件

[root@li ~]# mkdir /tmp/mysqlbackup --建立一个存放备份的目录
[root@li ~]# chown mysql.mysql /tmp/mysqlbackup/ --改权限

mysql> backup table emp to '/tmp/mysqlbackup'; --备份emp表到/tmp/mysqlbackup目录
+------------+--------+----------+----------+
| Table      | Op     | Msg_type | Msg_text |
+------------+--------+----------+----------+
| source.emp | backup | status   | OK       |
+------------+--------+----------+----------+

[root@li ~]# ll /tmp/mysqlbackup/  --查看时只有.frm和.MYD文件
-rw-rw---- 1 mysql mysql 8690 08-14 15:32 emp.frm
-rw-rw---- 1 mysql mysql  512 08-14 15:32 emp.MYD

mysql> restore table emp from '/tmp/mysqlbackup'; --误删表后恢复emp表
+------------+---------+----------+----------+
| Table      | Op      | Msg_type | Msg_text |
+------------+---------+----------+----------+
| source.emp | restore | status   | OK       |
+------------+---------+----------+----------+

 

select  xxx  into outfile ...
本身是一种数据导出的方法，同时可以用来辅助备份，它可以对一个表的其中一列或者某几列做备份（导出）

mysql> select ename,sal into outfile '/tmp/mysqlbackup/emp_ename_sal.txt' from emp; --把emp表的ename,sal两列数据导出（备份）

 

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

 

3，mysqldump工具备份

导出的是sql语句文件

mysqldump客户端可用来转储数据库或搜集数据库进行备份或将数据转移到另一个SQL服务器(不一定是一个MySQL服务器)。转储包含创建表和/或装载表的SQL语句。

如果你在服务器上进行备份，并且表均为MyISAM表，应考虑使用mysqlhotcopy，因为可以更快地进行备份和恢复

 

提供三种级别的备份，表级，库级和全库级

shell> mysqldump [options] db_name [tables]

shell> mysqldump [options] ---database DB1 [DB2 DB3...]

shell> mysqldump [options] --all--database

 

全库级：

[root@li ~]# /usr/local/mysql/bin/mysqldump -p123 --all-databases > /all.sql

vim /all.sql  可以看到，全是create和insert数据的sql语句

库级:
[root@li ~]# /usr/local/mysql/bin/mysqldump -p123 --databases source > /source.sql

[root@li ~]# /usr/local/mysql/bin/mysql -p123  < /source.sql

表级：

[root@li ~]# /usr/local/mysql/bin/mysqldump -p123 source emp> /emp.sql

表级恢复：
[root@li ~]# /usr/local/mysql/bin/mysql -p123 source < /emp.sql
[root@li ~]# /usr/local/mysql/bin/mysql -p123 -e 'source /emp.sql' source

 

全库恢复演示： --注意mysqldump的恢复速度较慢，所以数据太大需要的时间较长
rm /data/*  -rf
rm /data07/* -rf     --前面做了innodb的实验，innodb表的数据在这里，所以也要删除掉

恢复步骤：
1，初始化 /usr/local/mysql/bin/mysql_install_db --datadir=/data --user=mysql
2，把数据库先启起来
3，恢复# /usr/local/mysql/bin/mysql < /tmp/mysqlbackup/all.sql

 

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

4,mysqlhotcopy

是一个perl写的程序，原理先锁表，再拷。只适用于myisam存储引擎

mysqlhotcopy是一个Perl脚本，最初由Tim Bunce编写并提供。它使用LOCK TABLES、FLUSH TABLES和cp或scp来快速备份数据库。它是备份数据库或单个表的最快的途径，但它只能运行在数据库目录所在的机器上。mysqlhotcopy只用于备份MyISAM。它运行在Unix和NetWare中。

shell> mysqlhotcopy db_name [/path/to/new_directory]

shell> mysqlhotcopy db_name_1 ... db_name_n /path/to/new_directory

备份给定数据库中的匹配正则表达式的表：

shell> mysqlhotcopy db_name./regex/

加上发音符(‘~’)前缀，表名的正则表达式可以被否定：

shell> mysqlhotcopy db_name./~regex/

 

perldoc mysqlhotcopy  --用此命令去查看帮助文件

 

备份库
[root@li ~]# /usr/local/mysql/bin/mysqlhotcopy -p 123 --socket=/var/run/mysqld/mysql5.socket  source  /tmp/mysqlbackup/

 

恢复：  拷回去就可以了，包括了db.opt文件

备份表
[root@li ~]# /usr/local/mysql/bin/mysqlhotcopy -p 123 --socket=/var/run/mysqld/mysql5.socket  source./emp/  /tmp/mysqlbackup/

--注意：  -p 和密码中间要空格

他备份的文件，也有库的目录，没有db.opt文件

恢复：
mysql> restore table emp from '/tmp/mysqlbackup/source';

 

 

 

 

有兴趣的可以提前做一下AB复制

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

AB复制前准备
把两台mysql启起来（要求两台数据一致)，/etc/hosts里都加上主机名和IP对应，时间同步好，防火墙检查一下

 

mysql AB复制开始搭建
1,主从数据必须要同步
2,主：要启用二进制日志   /usr/local/mysql/etc/my.cnf       log-bin=xxxxx
3,主和从都要设置 server-id值，并且两边要不一样
4,需要建立一个用来复制的用户，并授于相应权限

   master －－ slave
         2.2.2.36    2.2.2.37  

 

第一步；改配置文件

master的
［mysqld]
log-bin=mysql-bin
server-id=2

slave的
 [mysqld]
 server-id=3

/etc/init.d/mysql5  重启服务

 

第二步：授权

master上授权,super和replication slave都是复制要用的权限
mysql> grant super,replication slave on *.* to 'li'@'2.2.2.37' identified by '123';
mysql> flush privileges;

slave上最好使用刚才授权的用户是远程登录一下主
[root@slave src]# /usr/local/mysql/bin/mysql -u li -h 2.2.2.36 -p123
ERROR 1130 (HY000): Host '::ffff:2.2.2.36' is not allowed to connect to this MySQL server
--上面是IPV6所造成的影响，所以要去主上面重新授权

master上重新授权，写上IPv6的形式，或者使用%符号代替所以（但不建设这样做，这样就没有对slave做权限控制）
mysql> grant super,replication slave on *.* to 'li'@'::ffff:2.2.2.36' identified by '123';
mysql> flush privileges;

再验证一下，发现登陆OK

第三步：查看master的正在写的二进制文件名和位置
mysql> flush tables with read lock;  --先加锁，防止两边数据不一致
Query OK, 0 rows affected (0.00 sec)

mysql> show master status;
+------------------+----------+--------------+------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000001 |      681 |              |                  |
+------------------+----------+--------------+------------------+

二进制文件名  正在写入的位置

slave端量的配置
mysql> slave stop;
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> change master to
    -> master_user='li',
    -> master_password='123',
    -> master_host='2.2.2.36',  --主的IP
    -> master_port=3306,   --端口，如果为3307就要换成3307
    -> master_log_file='mysql-bin.000001', --主上面查到的文件名
    -> master_log_pos=681;   --主上面查到的位置号

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

mysql> show slave status\G;
*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                  Master_Host: 2.2.2.36
                  Master_User: li
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: mysql-bin.000001
          Read_Master_Log_Pos: 681
               Relay_Log_File: mysql55-relay-bin.000002
                Relay_Log_Pos: 253
        Relay_Master_Log_File: mysql-bin.000001
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes   --这里两个YES，表示两个线程OK
              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: 681
              Relay_Log_Space: 411
              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: 2
1 row in set (0.00 sec)

...................................

回到master端解锁：
mysql> unlock tables;
Query OK, 0 rows affected (0.00 sec)

进行测试：

1，先比较主，从的数据目录文件的不同

[root@master ~]# ls /data/ --主的
ibdata1      mysql             performance_schema
ib_logfile0  mysql-bin.000001  test
ib_logfile1  mysql-bin.index

[root@slave ~]# ls /data/ --从的
ibdata1                   mysql55-relay-bin.000002
ib_logfile0               mysql55-relay-bin.index
ib_logfile1               performance_schema
master.info               relay-log.info
mysql                     test
mysql55-relay-bin.000001

 

验证2：只有master写，slave可以看到
 slave写，master看不到

如果复制有问题，删除slave端/data/master.info再做

验证3：把从重启后，再上去查看状态，还是连接的，没什么影响

 把主重启后，再去slave上去查看状态，发现重试时间为60秒，等60秒后又自动连接OK了