mysql存储引擎MyISAM和InnoDB的性能比较与优化和mysql主从设计备份

MyISAM 表。MyISAM 存储格式自版本 3.23 以来是 MySQL 中的缺省类型，它有下列特点：

■ 如果操作系统自身允许更大的文件，那么文件比 ISAM 存储方法的大。

■ 数据以低字节优先的机器独立格式存储。这表示可将表从一种机器拷贝到另一种机器，即使它们的体系结构不同也可以拷贝。

■ 数值索引值占的存储空间较少，因为它们是按高字节优先存储的。索引值在低位字节中变化很快，因此高位字节更容易比较。

■ AUTO_INCREMENT 处理比 ISAM 的表更好。详细内容在第2章讨论。

■ 减少了几个索引限制。例如，可对含 NULL 值的列进行索引，还可以对 BLOB 和 TEXT 类型的列进行索引。

■ 为了改善表的完整性检查，每个表都具有一个标志，在 myisamchk 对表进行过检查后，设置该标志。可利用 myisamchk - fast 跳过对自前次检查以来尚未被修改过表的检查，这样使此管理任务更快。表中还有一个指示表是否正常关闭的标志。如果服务器关闭不正常，或机器崩溃，此标志可用来检测出服务器起动时需要检查的表。

InnoDb 介绍:
InnoDb 存储引擎,支持事务,行锁,外键.InnoDb 设计用来处理大数据量时提供最好的
性能.
InnoDb 提供自己的缓存(buffer pool) 还缓存数据和索引.innodb 把数据和索引存放
到表空间(tablespace) ,表空间是几个磁盘文件或者是原是设备文件(raw disk). 它
不像MyISAM 存储引擎,每个表只是一个文件.(这样在某些系统下最大2G限制). 而Innodb
没有此限制,可以无限扩展.
Mysql4.0 的以后版本都支持innodb 存储.

InnoDb 配置:
innodb 管理的两个磁盘文件是表空间文件和日志文件.
表空间定义:
innodb_data_file_path=datafile_spec1[;datafile_spec2]...
文件声明格式: file_name:file_size[:autoextend[:max:max_file_size]]
innodb_data_home_dir 声明文件存放目录.

mysql 读取配置文件的顺序:
`/etc/my.cnf' Global options.
`DATADIR/my.cnf' Server-specific options.
`defaults-extra-file' The file specified with the --defaults-extra-file option.
`~/.my.cnf' User-specific options.

[硬件配置]
CPU : AMD2500+ (1.8G)
内存: 1G/现代
硬盘: 80G/IDE

[软件配置]
OS : Windows XP SP2
SE : PHP5.2.1
DB : MySQL5.0.37
Web: IIS6

[MySQL表结构]

CREATE TABLE `myisam` (
   `id` int(11) NOT NULL auto_increment,
   `name` varchar(100) default NULL,
   `content` text,
  PRIMARY KEY   (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=gbk;

CREATE TABLE `innodb` (
   `id` int(11) NOT NULL auto_increment,
   `name` varchar(100) default NULL,
   `content` text,
  PRIMARY KEY   (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;

[数据内容]

     MySQL支持数个存储引擎作为对不同表的类型的处理器。MySQL存储引擎包括处理事务安全表的引擎和处理非事务安全表的引擎：·

 MyISAM管理非事务表。它提供高速存储和检索，以及全文搜索能力。MyISAM在所有MySQL配置里被支持，它是默认的存储引擎，除非你配置MySQL默认使用另外一个引擎。

MEMORY存储引擎提供“内存中”表。MERGE存储引擎允许集合将被处理同样的MyISAM表作为一个单独的表。就像MyISAM一样，MEMORY和MERGE存储引擎处理非事务表，这两个引擎也都被默认包含在MySQL中。 释：MEMORY存储引擎正式地被确定为HEAP引擎。

InnoDB和BDB存储引擎提供事务安全表。BDB被包含在为支持它的操作系统发布的MySQL-Max二进制分发版里。InnoDB也默认被包括在所有MySQL 5.1二进制分发版里，你可以按照喜好通过配置MySQL来允许或禁止任一引擎。

EXAMPLE存储引擎是一个“存根”引擎，它不做什么。你可以用这个引擎创建表，但没有数据被存储于其中或从其中检索。这个引擎的目的是服务，在MySQL源代码中的一个例子，它演示说明如何开始编写新存储引擎。同样，它的主要兴趣是对开发者。

看下面的测试

[插入数据-1] (innodb_flush_log_at_trx_commit=1)
MyISAM 1W：3/s
InnoDB 1W：219/s

MyISAM 10W：29/s
InnoDB 10W：2092/s

MyISAM 100W：287/s
InnoDB 100W：没敢测试

[插入数据-2] (innodb_flush_log_at_trx_commit=0)
MyISAM 1W：3/s
InnoDB 1W：3/s

MyISAM 10W：30/s
InnoDB 10W：29/s

MyISAM 100W：273/s
InnoDB 100W：423/s

[插入数据3] (innodb_buffer_pool_size=1024M)
InnoDB 1W：3/s
InnoDB 10W：33/s
InnoDB 100W：607/s

[插入数据4] (innodb_buffer_pool_size=256M, innodb_flush_log_at_trx_commit=1, set autocommit=0)

InnoDB 1W：3/s
InnoDB 10W：26/s
InnoDB 100W：379/s

[MySQL 配置文件] (缺省配置)

# MySQL Server Instance Configuration File
[client]
port=3306

[mysql]
default-character-set=gbk

[mysqld]
port=3306
basedir="C:/mysql50/"
datadir="C:/mysql50/Data/"
default-character-set=gbk
default-storage-engine=INNODB
sql-mode="STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION"
max_connections=100

query_cache_size=0
table_cache=256
tmp_table_size=50M
thread_cache_size=8
myisam_max_sort_file_size=100G
myisam_max_extra_sort_file_size=100G
myisam_sort_buffer_size=100M
key_buffer_size=82M
read_buffer_size=64K
read_rnd_buffer_size=256K
sort_buffer_size=256K

innodb_additional_mem_pool_size=4M
innodb_flush_log_at_trx_commit=1
innodb_log_buffer_size=2M
innodb_buffer_pool_size=159M
innodb_log_file_size=80M
innodb_thread_concurrency=8

【总结】

   可以看出在MySQL 5.0里面，MyISAM和InnoDB存储引擎性能差别并不是很大，针对InnoDB来说，影响性能的主要是 innodb_flush_log_at_trx_commit 这个选项，如果设置为1的话，那么每次插入数据的时候都会自动提交，导致性能急剧下降，应该是跟刷新日志有关系，设置为0效率能够看到明显提升，当然，同样你可以SQL中提交“SET AUTOCOMMIT = 0”来设置达到好的性能。另外，还听说通过设置innodb_buffer_pool_size能够提升InnoDB的性能，但是我测试发现没有特别明显的提升。

基本上我们可以考虑使用InnoDB来替代我们的MyISAM引擎了，因为InnoDB自身很多良好的特点，比如事务支持、存储过程、视图、行级锁定等等，在并发很多的情况下，相信InnoDB的表现肯定要比MyISAM强很多，当然，相应的在my.cnf中的配置也是比较关键的，良好的配置，能够有效的加速你的应用。

如果不是很复杂的Web应用，非关键应用，还是可以继续考虑MyISAM的，这个具体情况可以自己斟酌。

MyISAM和InnoDB优化：

key_buffer_size- 这对MyISAM表来说非常重要。如果只是使用MyISAM表，可以把它设置为可用内存的 30-40%。合理的值取决于索引大小、数据量以及负载 -- 记住，MyISAM表会使用操作系统的缓存来缓存数据，因此需要留出部分内存给它们，很多情况下数据比索引大多了。尽管如此，需要总是检查是否所有的 key_buffer 都被利用了 -- .MYI 文件只有 1GB，而 key_buffer 却设置为 4GB 的情况是非常少的。这么做太浪费了。如果你很少使用MyISAM表，那么也保留低于 16-32MB 的 key_buffer_size 以适应给予磁盘的临时表索引所需。

innodb_buffer_pool_size- 这对Innodb表来说非常重要。Innodb相比MyISAM表对缓冲更为敏感。MyISAM可以在默认的 key_buffer_size 设置下运行的可以，然而Innodb在默认的 innodb_buffer_pool_size 设置下却跟蜗牛似的。由于Innodb把数据和索引都缓存起来，无需留给操作系统太多的内存，因此如果只需要用Innodb的话则可以设置它高达 70-80% 的可用内存。一些应用于 key_buffer 的规则有 -- 如果你的数据量不大，并且不会暴增，那么无需使用。

innodb_additional_pool_size- 这个选项对性能影响并不太多，至少在有差不多足够内存可分配的操作系统上是这样。不过如果你仍然想设置为 20MB(或者更大)，因此就需要看一下Innodb其他需要分配的内存有多少。

innodb_log_file_size在高写入负载尤其是大数据集的情况下很重要。这个值越大则性能相对越高，但是要注意到可能会增加恢复时间。我经常设置为 64-512MB，跟据服务器大小而异。

innodb_log_buffer_size默认的设置在中等强度写入负载以及较短事务的情况下，服务器性能还可以。如果存在更新操作峰值或者负载较大，就应该考虑加大它的值了。如果它的值设置太高了，可能会浪费内存 -- 它每秒都会刷新一次，因此无需设置超过1秒所需的内存空间。通常 8-16MB 就足够了。越小的系统它的值越小。

innodb_flush_logs_at_trx_commit是否为Innodb比MyISAM慢1000倍而头大？看来也许你忘了修改这个参数了。默认值是 1，这意味着每次提交的更新事务（或者每个事务之外的语句）都会刷新到磁盘中，而这相当耗费资源，尤其是没有电池备用缓存时。很多应用程序，尤其是从 MyISAM转变过来的那些，把它的值设置为 2 就可以了，也就是不把日志刷新到磁盘上，而只刷新到操作系统的缓存上。日志仍然会每秒刷新到磁盘中去，因此通常不会丢失每秒1-2次更新的消耗。如果设置为 0 就快很多了，不过也相对不安全了 -- MySQL服务器崩溃时就会丢失一些事务。设置为 2 指挥丢失刷新到操作系统缓存的那部分事务。

table_cache-- 打开一个表的开销可能很大。例如MyISAM把MYI文件头标志该表正在使用中。你肯定不希望这种操作太频繁，所以通常要加大缓存数量，使得足以最大限度地缓存打开的表。它需要用到操作系统的资源以及内存，对当前的硬件配置来说当然不是什么问题了。如果你有200多个表的话，那么设置为 1024 也许比较合适（每个线程都需要打开表），如果连接数比较大那么就加大它的值。我曾经见过设置为 100,000 的情况。

thread_cache-- 线程的创建和销毁的开销可能很大，因为每个线程的连接/断开都需要。我通常至少设置为 16。如果应用程序中有大量的跳跃并发连接并且

Threads_Created的值也比较大，那么我就会加大它的值。它的目的是在通常的操作中无需创建新线程。

query_cache-- 如果你的应用程序有大量读，而且没有应用程序级别的缓存，那么这很有用。不要把它设置太大了，因为想要维护它也需要不少开销，这会导致MySQL变慢。通常设置为 32-512Mb。设置完之后最好是跟踪一段时间，查看是否运行良好。在一定的负载压力下，如果缓存命中率太低了，就启用它。

sort_buffer_size--如果你只有一些简单的查询，那么就无需增加它的值了，尽管你有 64GB 的内存。搞不好也许会降低性能。

之后又做了一个测试：

mysql支持的两种主要表存储格式myisam，innodb，上个月做个项目时，先使用了innodb，结果速度特别慢，1秒钟只能插入10几条。后来换成myisam格式，一秒钟插入上万条。当时决定这两个表的性能也差别太大了吧。后来自己推测，不应该差别这么慢，估计是写的插入语句有问题，决定做个测试：
测试环境：redhat linux9，4cpu，内存2g，mysql版本为4.1.6-gamma-standard
测试程序：python＋python-mysql模块。
测试方案：
1、myisam格式分别测试，事务和不用事务两种情况：
2、innodb格式分别测试autocommit＝1（不用begin transaction和用begin transaction模式），
     autocommit=0 （不用begin transaction和用begin transaction模式）四种情况。

测试方法为插入10000条记录。为了测试不互相影响，单独建立了专用的测试表，建表语句如下：
1、myisam不用事务表：
create table `myisam_nt` (
  `tableid` int(11) not null default 0,
  `tablestring` varchar(21) not null default
) engine=myisam;

2、myisam用事务表:
create table `myisam_ts` (
  `tableid` int(11) not null default 0,
  `tablestring` varchar(21) not null default
) engine=myisam;

3、innodb关闭autocommit，不用事务:
create table `innodb_na_nb` (
  `tableid` int(11) not null default 0,
  `tablestring` varchar(21) not null default
) engine=innodb;

4、innodb关闭autocommit，用事务:
create table `innodb_na_be` (
  `tableid` int(11) not null default 0,
  `tablestring` varchar(21) not null default
) engine=innodb;

5、innodb开启autocommit，不用事务:
create table `innodb_au_nb` (
  `tableid` int(11) not null default 0,
  `tablestring` varchar(21) not null default
) engine=innodb;

6、innodb开启autocommit，用事务:
create table `innodb_au_be` (
  `tableid` int(11) not null default 0,
  `tablestring` varchar(21) not null default
) engine=innodb;

测试的python脚本如下：

#!/usr/bin/env python

import mysqldb
import sys
import os
import string
import time

c = none

testtables = [("myisam_nt",none,0),
             ("myisam_ts",none,1),
             ("innodb_na_nb",0,0),
             ("innodb_na_be",0,1),
             ("innodb_au_nb",1,0),
             ("innodb_au_be",1,1)
             ]

def begintrans():

    print "execsql:begin;"
    c.execute("begin;")
   
    return

def commit():
   
    print "execsql:commit;"
    c.execute("commit;")
    return

def autocommit(flag):
   
    print "execsql:set autocommit = "+str(flag)
    c.execute("set autocommit = "+str(flag))
    return
 
def getcount(table):
    #print  "execsql:select count(*) from "+table
    c.execute("select count(*) from "+table)
    return c.fetchall()[0][0]
    
 
def addtable (table,tableid,tablestring):

    sql = "insert into "+table+"(tableid, tablestring) values( "+ tableid+ "," + tablestring +")"
    try:
        c.execute(sql)
    except mysqldb.operationalerror,error:
        print "addtable error:",error
        return -1;
    return c.rowcount


def main():

    argv = sys.argv

    if len(argv) < 2:
        print usage:,argv[0], tableid testcount \n
        sys.exit(1)
   
    global c        #mysql访问cursor

   
    db_host = "localhost"
    db_name = "demo"
    db_user = "root"
    db_user_passwd = ""
   
    print "config:[%s %s/%s %s] db\n"%(db_host,db_user,db_user_passwd,db_name)
    
    if len(argv) > 2:
        tableid = argv[1]
        testcount = int(argv[2])   #

    for test in testtables:
        #每次操作前都重写建立数据库连接   
        try:
            mdb = mysqldb.connect(db_host, db_user, db_user_passwd, db_name)
        except mysqldb.operationalerror,error:
            print "connect mysql[%s %s/%s %s] db error:"%(db_host,db_user,db_user_passwd,db_name),error,"\n"
            sys.exit(1)
        else:
            c = mdb.cursor()
        table,autocommit,trans = test
        starttime = time.time()
        print table," ",time.strftime("%y-%m-%d %h:%m:%s",time.localtime())

        if autocommit != none:
            autocommit(autocommit)
       
        if trans == 1:
            begintrans()

        for i in xrange(testcount):
            tablestring = "%020d"%i
            if (addtable(table,tableid,tablestring)<1):
                print "addtable error",tablestring
       
        if trans == 1:
            commit()
       
        print time.strftime("%y-%m-%d %h:%m:%s",time.localtime())
        endtime = time.time()
        usedtime = endtime-starttime

        print table,"count:",getcount(table)," used time:",usedtime
        c.close()
        mdb.close()


if __name__ == __main__:
    main()
测试结果如下：
    
config:[localhost root/ demo] db

1-myisam_nt 
myisam_nt count: 10000  used time: 2.1132440567
2-myisam_ts  
execsql:begin;
execsql:commit;
myisam_ts count: 10000  used time: 2.65475201607
3-innodb_na_nb  
execsql:set autocommit = 0
innodb_na_nb count: 10000  used time: 2.51947999001
innodb_na_be  
execsql:set autocommit = 0
execsql:begin;
execsql:commit;
4-innodb_na_be count: 10000  used time: 3.85625100136
innodb_au_nb  
execsql:set autocommit = 1
5-innodb_au_nb count: 10000  used time: 43.7153041363
innodb_au_be  
execsql:set autocommit = 1
execsql:begin;
execsql:commit;
6-innodb_au_be count: 10000  used time: 3.14328193665

介绍主从设计

我们都清楚经常所说的 主从(master to slave)同步，可以通过读写分离来提高数据库的吞吐量。
如果你使用的方案是一台主，多台从，请看http://www.tbqu.com/post/15.html

但是一台主，在负载比较大的情况下，不免会扛不住，在这里我们谈下多主互备来实现这一功能。

Mysql多机同步技术笔记

下面有二台Mysql服务器，他们的IP地址分别为：
A：192.168.0.97
B：192.168.0.98
数据库都是 test_3306
首先我给两台服务器的my.ini 贴出来
A：my.ini

server-id=2
master-host=192.168.0.98
master-user=mydb
master-password=123
master-port=3306
master-connect-retry=1
replicate-do-db=tbqu
log-bin=
log-slave-updates
binlog-ignore-db=mysql
slave-skip-errors=all

B:my.ini

server-id=1
master-host=192.168.0.97
master-user=mydb
master-password=123
master-port=3306
master-connect-retry=1
replicate-do-db=tbqu
log-bin=
log-slave-updates
binlog-ignore-db=mysql
slave-skip-errors=all

在这里，配置文件和主从配置方法基本上一样
log-slave-updates 这个参数一定要加上，否则不会给更新的记录些到二进制文件里
slave-skip-errors 是跳过错误，继续执行复制操作
其他参数请参照 http://www.tbqu.com/post/15.html

多主互备和主从复制有一些区别，因为多主中 都可以对服务器有写权限，所以设计到自增长重复问题

出现的问题（多主自增长ID重复）
1:首先我们通过A,B的test表结构
2:掉A，在B上对数据表test(存在自增长ID)执行插入操作，返回插入ID为1
3:后停掉B，在A上对数据表test(存在自增长ID)执行插入操作，返回的插入ID也是1
4:然后 我们同时启动A,B，就会出现主键ID重复

解决方法：
我们只要保证两台服务器上插入的自增长数据不同就可以了
如：A查奇数ID，B插偶数ID，当然如果服务器多的话，你可以定义算法，只要不同就可以了

在这里我们在A,B上加入参数，以实现奇偶插入

A：my.ini上加入参数

auto_increment_offset = 1
auto_increment_increment = 2
这样A的auto_increment字段产生的数值是：1, 3, 5, 7, …等奇数ID了

B：my.ini上加入参数

auto_increment_offset = 2
auto_increment_increment = 2
这样B的auto_increment字段产生的数值是：2, 4, 6, 8, …等偶数ID了

可以看出，你的auto_increment字段在不同的服务器之间绝对不会重复，所以Master-Master结构就没有任何问题了。当然，你还可以使用3台，4台，或者N台服务器，只要保证auto_increment_increment = N 再设置一下auto_increment_offset为适当的初始值就可以了，那样，我们的MySQL可以同时有几十台主服务器，而不会出现自增长ID 重复。

在这里我们说的是2台MYSQL服务器，你也可以扩展到多台，实现方法类似
A -> B -> C-> D ->A
这样一个环形的备份结构就形成了，最后可要记住 自增长ID（主键）要设计好哦，否则会出错的。

实际搭建多主多从

操作系统:Linux 2.6.13 (Slackware),其它版的Linux应该也差不多.
数据库:Mysql 4.1.8 源程序安装
假设服务器名:test-db1 (IP为192.168.0.1),主
假设服务器名:test-db2 (IP为192.168.0.2),主
假设服务器名:test-db3 (IP为192.168.0.3),从
二,test-db1主服务器mysql安装准备
用mysql源程序安装,假设在安装时用的configura选择项下如,解压后：
./configure
make
make imstall
chown mysql.mysql /usr/local/mysql/var
cp ../support-files/ my-medium.cnf /etc/my.cnf
cp ../support-files/mysql.server /etc/rc.d/rc.mysqld
直接启动mysql进程/etc/rc.d/rc.mysqld start
这样默认安装好之后数据库生成的目录为/usr/local/mysql/var

三,test-db2主服务器mysql安装准备
./configure
make
make imstall
chown mysql.mysql /usr/local/mysql/var
cp ../support-files/ my-medium.cnf /etc/my.cnf
cp ../support-files/mysql.server /etc/rc.d/rc.mysqld
启动mysql进程/etc/rc.d/rc.mysqld start
这样默认安装好之后数据库生成的目录为/usr/local/mysql/var
修改/etc/my.cnf文档
将port=3306改为port=3307
启动mysql进程/etc/rc.d/rc.mysqld start
至些两台主mysql服务器已经搭建好。
接下来在两台主服务器上设置replicate账号，此账号作为从服务器同步用
mysql  -umysql –p进入mysql
grant all on *.* to replicate@’%’ idenfied by ‘1234567890’;

四.test-db3从服务器mysql安装准备
./configure --prefix=/usr/local/mysql   --datadir=/usr/local/mysql/data1 --sysconfdir=/etc       make     make instll
备注:--prefix将MYSQL安装到/usr/local/mysql,
--datadir将数据库生成/usr/local/mysql/data1
sysconfdir是指定mysql使用到的my.cnf配置文件的搜索路径为/etc
其他mysql安装过程略.

根据Mysql管理手册中提到:每个Mysql的服务都可为独立的，所以它都调用一个my.cnf中各自不同的启动选项--就是下文中将提到的GNR值,使用不同的端口,生成各自的套接文件,服务的数据库都是独立的(更多可查阅mysql官方网站的英文管理手册).

mysqld_multi是管理多个mysqld的服务进程，这些服务进程程序不同的unix socket或是监听于不同的端口。他可以启动、停止和监控当前的服务状态。

----程序在my.cnf(或是在--config-file自定义的配置文件)中搜索[mysqld#]段，"#"可以是任意的正整数。这个正整数就是在下面提及的段序列，即GNR。段的序号做为mysqld_multi的参数，来区别不同的段，这样你就可以控制特定mysqld进程的启动、停止或得到他的报告信息。这些组里的参数就像启动一个mysqld所需要的组的参数一样。但是，如果使用多服务，必须为每个服务指定一个unix socket或端口(摘自[url]http://mifor.4dian.org[/url]中的使用mysqld_multi程序管理多个MySQL服务 )。

从上述文字可看到多Mysql服务中最重要的就是my.cnf配置文件了.
现我贴出我从服务器的my.cnf文件.-----------------------

[mysqld_multi]
mysqld = /usr/local/mysql/bin/mysqld_safe
mysqladmin = /usr/local/mysql/bin/mysqladmin
user = mysql
password = mysql
[mysqld1]
port     = 3306
socket   = /tmp/mysql.sock1
skip-locking
pid-file=/usr/local/mysql/data1/test-db1a.pid
datadir = /usr/local/mysql/data1
log=/usr/local/mysql/data1/test-db1.log
user = mysql
log-slow-queries=/usr/local/mysql/data/slowquery.log
long_query_time = 2
key_buffer = 256M
max_allowed_packet = 1M
table_cache = 512
sort_buffer_size = 2M
read_buffer_size = 2M
myisam_sort_buffer_size = 64M
thread_cache = 32
query_cache_size = 32M
thread_concurrency = 2
max_connections=500
server-id     = 2
master-host   =   192.168.0.1
master-user   =   'replcate'
master-password =   '1234567890'
master-port   = 3306
report-host = test-db3
master-connect-retry = 30
log-bin
log-slave-updates


[mysqld2]
port = 3307
socket = /tmp/mysql.sock2
pid-file = /usr/local/mysql/data2/test-db2b.pid
datadir = /usr/local/mysql/data2
log=/usr/local/mysql/data2/test-db2.log
user = mysql
log-slow-queries=/usr/local/mysql/data2/slowquery.log
long_query_time = 10
key_buffer = 128M
max_allowed_packet = 1M
table_cache = 512
sort_buffer_size = 1M
read_buffer_size = 1M
myisam_sort_buffer_size = 32M
thread_cache = 32
query_cache_size = 16M
thread_concurrency = 2
max_connections=300
server-id     = 2
master-host   =   192.168.0.2
master-user   =   'repl'
master-password =   '1234567890'
master-port   = 3307
report-host = test-db3
master-connect-retry = 30
log-bin
log-slave-updates



之后通过tar命令将主服务器上test-db1的数据库放于从服务器/usr/local/mysql/data1下
再通过tar命令将主服务器上test-db2的数据库放于从服务器/usr/local/mysql/data2下
通过以下命令启动从服务器的mysql进程
/usr/local/mysq/bin/mysqld_multi --config-file=/etc/my.cnf start 1-2                        
查看启动:

test-db3:/ # ps aux

root   10467 0.0 0.2   2712 1300 pts/0   S   18:59   0:00 /bin/sh /usr/local/mysql/bin/mysqld_safe --port=3306 --socket=/tmp/mysql.sock1
root   10475 0.0 0.2   2712 1300 pts/0   S   18:59   0:00 /bin/sh /usr/local/mysql/bin/mysqld_safe --port=3307 --socket=/tmp/mysql.sock2


然后在两台从服务器分另建立数据库以及表做测试，会看到在从服务器中分别会有相应的数据库以及表产生。大家可以通过phpMyadmin以及EMS Mysql Manager对mysql进行管理


至此多主一从服务器搭建完成