set global query_cache_size=6410241024;
show variables like ‘query_cache_size’;
query_cache_size 67108864
将查询结果缓存
select sql_cache * from user;
重置缓存
reset query cache;
缓存失效问题(大问题)
当数据表改动时,基于该数据表的任何缓存都会被删除。(表层面的管理,不是记录层面的管理,因此失效率较高)
注意事项
- 应用程序,不应该关心
query cache
的使用情况。可以尝试使用,但不能由query cache
决定业务逻辑,因为query cache
由DBA来管理。 - 缓存是以SQL语句为key存储的,因此即使SQL语句功能相同,但如果多了一个空格或者大小写有差异都会导致匹配不到缓存。
分区
一般情况下我们创建的表对应一组存储文件,使用MyISAM
存储引擎时是一个.MYI
和.MYD
文件,使用Innodb
存储引擎时是一个.ibd
和.frm
(表结构)文件。
当数据量较大时(一般千万条记录级别以上),MySQL的性能就会开始下降,这时我们就需要将数据分散到多组存储文件,
保证其单个文件的执行效率
。
最常见的分区方案是按id
分区,如下将id
的哈希值对10取模将数据均匀分散到10个.ibd
存储文件中:
create table article(
id int auto_increment PRIMARY KEY,
title varchar(64),
content text
)PARTITION by HASH(id) PARTITIONS 10
查看data
目录:
服务端的表分区对于客户端是透明的
,客户端还是照常插入数据,但服务端会按照分区算法分散存储数据。
MySQL提供的分区算法
分区依据的字段必须是主键的一部分
,分区是为了快速定位数据,因此该字段的搜索频次较高应作为强检索字段,否则依照该字段分区毫无意义
hash(field)
相同的输入得到相同的输出。输出的结果跟输入是否具有规律无关。
仅适用于整型字段
key(field)
和hash(field)
的性质一样,只不过key
是
处理字符串
的,比hash()
多了一步从字符串中计算出一个整型在做取模操作。
create table article_key(
id int auto_increment,
title varchar(64),
content text,
PRIMARY KEY (id,title) – 要求分区依据字段必须是主键的一部分
)PARTITION by KEY(title) PARTITIONS 10
range算法
是一种
条件分区
算法,按照数据大小范围分区(将数据使用某种条件,分散到不同的分区中)。
如下,按文章的发布时间将数据按照2018年8月、9月、10月分区存放:
create table article_range(
id int auto_increment,
title varchar(64),
content text,
created_time int, – 发布时间到1970-1-1的毫秒数
PRIMARY KEY (id,created_time) – 要求分区依据字段必须是主键的一部分
)charset=utf8
PARTITION BY RANGE(created_time)(
PARTITION p201808 VALUES less than (1535731199), – select UNIX_TIMESTAMP(‘2018-8-31 23:59:59’)
PARTITION p201809 VALUES less than (1538323199), – 2018-9-30 23:59:59
PARTITION p201810 VALUES less than (1541001599) – 2018-10-31 23:59:59
);
注意:条件运算符只能使用
less than
,这以为着较小的范围要放在前面,比如上述p201808,p201819,p201810
分区的定义顺序依照created_time
数值范围从小到大,不能颠倒。
insert into article_range values(null,‘MySQL优化’,‘内容示例’,1535731180);
flush tables; – 使操作立即刷新到磁盘文件
由于插入的文章的发布时间1535731180
小于1535731199
(2018-8-31 23:59:59
),因此被存储到p201808
分区中,这种算法的存储到哪个分区取决于数据状况。
list算法
也是一种条件分区,按照列表值分区(in (值列表)
)。
create table article_list(
id int auto_increment,
title varchar(64),
content text,
status TINYINT(1), – 文章状态:0-草稿,1-完成但未发布,2-已发布
PRIMARY KEY (id,status) – 要求分区依据字段必须是主键的一部分
)charset=utf8
PARTITION BY list(status)(
PARTITION writing values in(0,1), – 未发布的放在一个分区
PARTITION published values in (2) – 已发布的放在一个分区
);
insert into article_list values(null,‘mysql优化’,‘内容示例’,0);
flush tables;
分区管理语法
range/list
增加分区
前文中我们尝试使用range
对文章按照月份归档,随着时间的增加,我们需要增加一个月份:
alter table article_range add partition(
partition p201811 values less than (1543593599) – select UNIX_TIMESTAMP(‘2018-11-30 23:59:59’)
– more
);
删除分区
alter table article_range drop PARTITION p201808
注意:
删除分区后,分区中原有的数据也会随之删除!
key/hash
新增分区
alter table article_key add partition partitions 4
销毁分区
alter table article_key coalesce partition 6
key/hash
分区的管理不会删除数据,但是每一次调整(新增或销毁分区)都会将所有的数据重写分配到新的分区上。
效率极低
,最好在设计阶段就考虑好分区策略。
分区的使用
当数据表中的数据量很大时,分区带来的效率提升才会显现出来。
只有检索字段为分区字段时,分区带来的效率提升才会比较明显。因此,
分区字段的选择很重要
,并且
业务逻辑要尽可能地根据分区字段做相应调整
(尽量使用分区字段作为查询条件)。
水平分割和垂直分割
水平分割:通过建立结构相同的几张表分别存储数据
垂直分割:将经常一起使用的字段放在一个单独的表中,分割后的表记录之间是一一对应关系。
分表原因
- 为数据库减压
- 分区算法局限
- 数据库支持不完善(
5.1
之后mysql
才支持分区操作)
id重复的解决方案
- 借用第三方应用如
memcache、redis
的id
自增器 - 单独建一张只包含
id
一个字段的表,每次自增该字段作为数据记录的id
集群
横向扩展:从根本上(单机的硬件处理能力有限)提升数据库性能 。由此而生的相关技术:
读写分离、负载均衡
安装和配置主从复制
环境
Red Hat Enterprise Linux Server release 7.0 (Maipo)
(虚拟机)mysql5.7
安装和配置
解压到对外提供的服务的目录(我自己专门创建了一个/export/server
来存放)
tar xzvf mysql-5.7.23-linux-glibc2.12-x86_64.tar.gz -C /export/server
cd /export/server
mv mysql-5.7.23-linux-glibc2.12-x86_64 mysql
添加mysql
目录的所属组和所属者:
groupadd mysql
useradd -r -g mysql mysql
cd /export/server
chown -R mysql:mysql mysql/
chmod -R 755 mysql/
创建mysql
数据存放目录(其中/export/data
是我创建专门用来为各种服务存放数据的目录)
mkdir /export/data/mysql
初始化mysql
服务
cd /export/server/mysql
./bin/mysqld --basedir=/export/server/mysql --datadir=/export/data/mysql --user=mysql --pid-file=/export/data/mysql/mysql.pid --initialize
如果成功会显示
mysql
的root
账户的初始密码,记下来以备后续登录。如果报错缺少依赖,则使用yum instally
依次安装即可
配置my.cnf
vim /etc/my.cnf
[mysqld]
basedir=/export/server/mysql
datadir=/export/data/mysql
socket=/tmp/mysql.sock
user=mysql
server-id=10 # 服务id,在集群时必须唯一,建议设置为IP的第四段
port=3306
Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links=0
Settings user and group are ignored when systemd is used.
If you need to run mysqld under a different user or group,
customize your systemd unit file for mariadb according to the
instructions in http://fedoraproject.org/wiki/Systemd
[mysqld_safe]
log-error=/export/data/mysql/error.log
pid-file=/export/data/mysql/mysql.pid
include all files from the config directory
!includedir /etc/my.cnf.d
将服务添加到开机自动启动
cp /export/server/mysql/support-files/mysql.server /etc/init.d/mysqld
启动服务
service mysqld start
配置环境变量,在/etc/profile
中添加如下内容
mysql env
MYSQL_HOME=/export/server/mysql
MYSQL_PATH=
M
Y
S
Q
L
H
O
M
E
/
b
i
n
P
A
T
H
=
MYSQL_HOME/bin PATH=
MYSQLHOME/binPATH=PATH:$MYSQL_PATH
export PATH
使配置即可生效
source /etc/profile
使用root
登录
mysql -uroot -p
这里填写之前初始化服务时提供的密码
登录上去之后,更改root
账户密码(我为了方便将密码改为root),否则操作数据库会报错
set password=password(‘root’);
flush privileges;
设置服务可被所有远程客户端访问
use mysql;
update user set host=‘%’ where user=‘root’;
flush privileges;
这样就可以在宿主机使用
navicat
远程连接虚拟机linux上的mysql了
配置主从节点
配置master
以linux
(192.168.10.10
)上的mysql
为master
,宿主机(192.168.10.1
)上的mysql
为slave
配置主从复制。
修改master
的my.cnf
如下
[mysqld]
basedir=/export/server/mysql
datadir=/export/data/mysql
socket=/tmp/mysql.sock
user=mysql
server-id=10
port=3306
Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links=0
Settings user and group are ignored when systemd is used.
If you need to run mysqld under a different user or group,
customize your systemd unit file for mariadb according to the
instructions in http://fedoraproject.org/wiki/Systemd
log-bin=mysql-bin # 开启二进制日志
expire-logs-days=7 # 设置日志过期时间,避免占满磁盘
binlog-ignore-db=mysql # 不使用主从复制的数据库
binlog-ignore-db=information_schema
binlog-ignore-db=performation_schema
binlog-ignore-db=sys
binlog-do-db=test #使用主从复制的数据库
[mysqld_safe]
log-error=/export/data/mysql/error.log
pid-file=/export/data/mysql/mysql.pid
include all files from the config directory
!includedir /etc/my.cnf.d
重启master
service mysqld restart
登录master
查看配置是否生效(ON
即为开启,默认为OFF
):
mysql> show variables like ‘log_bin’;
±--------------±------+
| Variable_name | Value |
±--------------±------+
| log_bin | ON |
±--------------±------+
在master
的数据库中建立备份账号:backup
为用户名,%
表示任何远程地址,用户back
可以使用密码1234
通过任何远程客户端连接master
grant replication slave on . to ‘backup’@‘%’ identified by ‘1234’
查看user
表可以看到我们刚创建的用户:
mysql> use mysql
mysql> select user,authentication_string,host from user;
±--------------±------------------------------------------±----------+
| user | authentication_string | host |
±--------------±------------------------------------------±----------+
| root | *81F5E21E35407D884A6CD4A731AEBFB6AF209E1B | % |
| mysql.session | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | localhost |
| mysql.sys | *THISISNOTAVALIDPASSWORDTHATCANBEUSEDHERE | localhost |
| backup | *A4B6157319038724E3560894F7F932C8886EBFCF | % |
±--------------±------------------------------------------±----------+
新建test
数据库,创建一个article
表以备后续测试
CREATE TABLE article
(
id
int(11) NOT NULL AUTO_INCREMENT,
title
varchar(64) DEFAULT NULL,
content
text,
PRIMARY KEY (id
)
) CHARSET=utf8;
重启服务并刷新数据库状态到存储文件中(with read lock
表示在此过程中,客户端只能读数据,以便获得一个一致性的快照)
[root@zhenganwen ~]# service mysqld restart
Shutting down MySQL… SUCCESS!
Starting MySQL. SUCCESS!
[root@zhenganwen mysql]# mysql -uroot -proot
mysql> flush tables with read lock;
Query OK, 0 rows affected (0.00 sec)
查看master
上当前的二进制日志和偏移量(记一下其中的File
和Position
)
mysql> show master status \G
*************************** 1. row ***************************
File: mysql-bin.000002
Position: 154
Binlog_Do_DB: test
Binlog_Ignore_DB: mysql,information_schema,performation_schema,sys
Executed_Gtid_Set:
1 row in set (0.00 sec)
File
表示实现复制功能的日志,即上图中的Binary log
;Position
则表示Binary log
日志文件的偏移量之后的都会同步到slave
中,那么在偏移量之前的则需要我们手动导入。
主服务器上面的任何修改都会保存在二进制日志Binary log里面,从服务器上面启动一个I/O thread(实际上就是一个主服务器的客户端进程),连接到主服务器上面请求读取二进制日志,然后把读取到的二进制日志写到本地的一个Realy log里面。从服务器上面开启一个SQL thread定时检查Realy log,如果发现有更改立即把更改的内容在本机上面执行一遍。
如果一主多从的话,这时主库既要负责写又要负责为几个从库提供二进制日志。此时可以稍做调整,将二进制日志只给某一从,这一从再开启二进制日志并将自己的二进制日志再发给其它从。或者是干脆这个从不记录只负责将二进制日志转发给其它从,这样架构起来性能可能要好得多,而且数据之间的延时应该也稍微要好一些
手动导入,从master
中导出数据
mysqldump -uroot -proot -hlocalhost test > /export/data/test.sql
将test.sql
中的内容在slave
上执行一遍。
配置slave
修改slave
的my.ini
文件中的[mysqld]
部分
log-bin=mysql
server-id=1 #192.168.10.1
保存修改后重启slave
,WIN+R
->services.msc
->MySQL5.7
->重新启动
登录slave
检查log_bin
是否以被开启:
show VARIABLES like ‘log_bin’;
配置与master
的同步复制:
stop slave;
change master to
master_host=‘192.168.10.10’, – master的IP
master_user=‘backup’, – 之前在master上创建的用户
master_password=‘1234’,
master_log_file=‘mysql-bin.000002’, – master上 show master status \G 提供的信息
master_log_pos=154;
启用slave
节点并查看状态
mysql> start slave;
mysql> show slave status \G
*************************** 1. row ***************************
Slave_IO_State: Waiting for master to send event
Master_Host: 192.168.10.10
Master_User: backup
Master_Port: 3306
Connect_Retry: 60
Master_Log_File: mysql-bin.000002
Read_Master_Log_Pos: 154
Relay_Log_File: DESKTOP-KUBSPE0-relay-bin.000002
Relay_Log_Pos: 320
Relay_Master_Log_File: mysql-bin.000002
Slave_IO_Running: Yes
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: 154
Relay_Log_Space: 537
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: 10
Master_UUID: f68774b7-0b28-11e9-a925-000c290abe05
Master_Info_File: C:\ProgramData\MySQL\MySQL Server 5.7\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)
注意查看第4、14、15三行,若与我一致,表示
slave
配置成功
测试
关闭master
的读取锁定
mysql> unlock tables;
Query OK, 0 rows affected (0.00 sec)
向master
中插入一条数据
mysql> use test
mysql> insert into article (title,content) values (‘mysql master and slave’,‘record the cluster building succeed!😃’);
Query OK, 1 row affected (0.00 sec)
查看slave
是否自动同步了数据
mysql> insert into article (title,content) values (‘mysql master and slave’,‘record the cluster building succeed!😃’);
Query OK, 1 row affected (0.00 sec)
至此,主从复制的配置成功!:)
使用mysqlreplicate命令快速搭建 Mysql 主从复制
读写分离
读写分离是依赖于主从复制,而主从复制又是为读写分离服务的。因为主从复制要求slave
不能写只能读(如果对slave
执行写操作,那么show slave status
将会呈现Slave_SQL_Running=NO
,此时你需要按照前面提到的手动同步一下slave
)。
方案一、定义两种连接
就像我们在学JDBC时定义的DataBase
一样,我们可以抽取出ReadDataBase,WriteDataBase implements DataBase
,但是这种方式无法利用优秀的线程池技术如DruidDataSource
帮我们管理连接,也无法利用Spring AOP
让连接对DAO
层透明。
方案二、使用Spring AOP
如果能够使用Spring AOP
解决数据源切换的问题,那么就可以和Mybatis
、Druid
整合到一起了。
我们在整合Spring1
和Mybatis
时,我们只需写DAO接口和对应的SQL
语句,那么DAO实例是由谁创建的呢?实际上就是Spring
帮我们创建的,它通过我们注入的数据源,帮我们完成从中获取数据库连接、使用连接执行 SQL
语句的过程以及最后归还连接给数据源的过程。
如果我们能在调用DAO接口时根据接口方法命名规范(增addXXX/createXXX
、删deleteXX/removeXXX
、改updateXXXX
、查selectXX/findXXX/getXX/queryXXX
)动态地选择数据源(读数据源对应连接master
而写数据源对应连接slave
),那么就可以做到读写分离了。
项目结构
引入依赖
其中,为了方便访问数据库引入了mybatis
和druid
,实现数据源动态切换主要依赖spring-aop
和spring-aspects
数据类
package top.zhenganwen.mysqloptimize.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Article {
private int id;
private String title;
private String content;
}
spring配置文件
其中RoutingDataSourceImpl
是实现动态切换功能的核心类,稍后介绍。
<context:property-placeholder location=“db.properties”></context:property-placeholder>
<context:component-scan base-package=“top.zhenganwen.mysqloptimize”/>
dp.properties
master.db.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
master.db.username=root
master.db.password=root
slave.db.url=jdbc:mysql://192.168.10.10:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
slave.db.username=root
slave.db.password=root
db.driverClass=com.mysql.jdbc.Driver
mybatis-config.xml
mapper接口和配置文件
ArticleMapper.java
package top.zhenganwen.mysqloptimize.mapper;
import org.springframework.stereotype.Repository;
import top.zhenganwen.mysqloptimize.entity.Article;
import java.util.List;
@Repository
public interface ArticleMapper {
List
void add(Article article);
void delete(int id);
}
ArticleMapper.xml
核心类
RoutingDataSourceImpl
package top.zhenganwen.mysqloptimize.dataSource;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import java.util.*;
/**
- RoutingDataSourceImpl class
- 数据源路由
- @author zhenganwen, blog:zhenganwen.top
- @date 2018/12/29
*/
public class RoutingDataSourceImpl extends AbstractRoutingDataSource {
/**
- key为read或write
- value为DAO方法的前缀
- 什么前缀开头的方法使用读数据员,什么开头的方法使用写数据源
*/
public static final Map<String, List> METHOD_TYPE_MAP = new HashMap<String, List>();
/**
- 由我们指定数据源的id,由Spring切换数据源
- @return
*/
@Override
protected Object determineCurrentLookupKey() {
System.out.println(“数据源为:”+DataSourceHandler.getDataSource());
return DataSourceHandler.getDataSource();
}
public void setMethodType(Map<String, String> map) {
for (String type : map.keySet()) {
String methodPrefixList = map.get(type);
if (methodPrefixList != null) {
METHOD_TYPE_MAP.put(type, Arrays.asList(methodPrefixList.split(“,”)));
}
}
}
}
它的主要功能是,本来我们只配置一个数据源,因此Spring
动态代理DAO接口时直接使用该数据源,现在我们有了读、写两个数据源,我们需要加入一些自己的逻辑来告诉调用哪个接口使用哪个数据源(读数据的接口使用slave
,写数据的接口使用master
。这个告诉Spring
该使用哪个数据源的类就是AbstractRoutingDataSource
,必须重写的方法determineCurrentLookupKey
返回数据源的标识,结合spring
配置文件(下段代码的5,6两行)
如果determineCurrentLookupKey
返回read
那么使用slaveDataSource
,如果返回write
就使用masterDataSource
。
DataSourceHandler
package top.zhenganwen.mysqloptimize.dataSource;
/**
- DataSourceHandler class
-
- 将数据源与线程绑定,需要时根据线程获取
- @author zhenganwen, blog:zhenganwen.top
- @date 2018/12/29
*/
public class DataSourceHandler {
/**
- 绑定的是read或write,表示使用读或写数据源
*/
private static final ThreadLocal holder = new ThreadLocal();
public static void setDataSource(String dataSource) {
System.out.println(Thread.currentThread().getName()+“设置了数据源类型”);
holder.set(dataSource);
}
public static String getDataSource() {
System.out.println(Thread.currentThread().getName()+“获取了数据源类型”);
return holder.get();
}
}
DataSourceAspect
package top.zhenganwen.mysqloptimize.dataSource;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Set;
import static top.zhenganwen.mysqloptimize.dataSource.RoutingDataSourceImpl.METHOD_TYPE_MAP;
/**
- DataSourceAspect class
- 配置切面,根据方法前缀设置读、写数据源
- 项目启动时会加载该bean,并按照配置的切面(哪些切入点、如何增强)确定动态代理逻辑
- @author zhenganwen,blog:zhenganwen.top
- @date 2018/12/29
*/
@Component
//声明这是一个切面,这样Spring才会做相应的配置,否则只会当做简单的bean注入
@Aspect
@EnableAspectJAutoProxy
public class DataSourceAspect {
/**
- 配置切入点:DAO包下的所有类的所有方法
/
@Pointcut("execution( top.zhenganwen.mysqloptimize.mapper..(…))")
public void aspect() {
}
/**
- 配置前置增强,对象是aspect()方法上配置的切入点
*/
@Before(“aspect()”)
public void before(JoinPoint point) {
String className = point.getTarget().getClass().getName();
String invokedMethod = point.getSignature().getName();
System.out.println(“对 “+className+”$”+invokedMethod+" 做了前置增强,确定了要使用的数据源类型");
Set dataSourceType = METHOD_TYPE_MAP.keySet();
for (String type : dataSourceType) {
List prefixList = METHOD_TYPE_MAP.get(type);
for (String prefix : prefixList) {
if (invokedMethod.startsWith(prefix)) {
DataSourceHandler.setDataSource(type);
System.out.println(“数据源为:”+type);
return;
}
}
}
}
}
测试读写分离
如何测试读是从
slave
中读的呢?可以将写后复制到slave
中的数据更改,再读该数据就知道是从slave
中读了。注意
,一但对
slave
做了写操作就要重新手动将slave
与master
同步一下,否则主从复制就会失效。
package top.zhenganwen.mysqloptimize.dataSource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import top.zhenganwen.mysqloptimize.entity.Article;
import top.zhenganwen.mysqloptimize.mapper.ArticleMapper;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = “classpath:spring-mybatis.xml”)
public class RoutingDataSourceTest {
@Autowired
ArticleMapper articleMapper;
@Test
public void testRead() {
System.out.println(articleMapper.findAll());
}
@Test
public void testAdd() {
Article article = new Article(0, “我是新插入的文章”, “测试是否能够写到master并且复制到slave中”);
articleMapper.add(article);
}
@Test
public void testDelete() {
articleMapper.delete(2);
}
}
负载均衡
负载均衡算法
- 轮询
- 加权轮询:按照处理能力来加权
- 负载分配:依据当前的空闲状态(但是测试每个节点的内存使用率、CPU利用率等,再做比较选出最闲的那个,效率太低)
高可用
在服务器架构时,为了保证服务器7x24不宕机在线状态,需要为每台单点服务器(由一台服务器提供服务的服务器,如写服务器、数据库中间件)提供冗余机。
对于写服务器来说,需要提供一台同样的写-冗余服务器,当写服务器健康时(写-冗余通过心跳检测),写-冗余作为一个从机的角色复制写服务器的内容与其做一个同步;当写服务器宕机时,写-冗余服务器便顶上来作为写服务器继续提供服务。对外界来说这个处理过程是透明的,即外界仅通过一个IP访问服务。
典型SQL
线上DDL
DDL(Database Definition Language)是指数据库表结构的定义(create table
)和维护(alter table
)的语言。在线上执行DDL,在低于MySQL5.6
版本时会导致全表被独占锁定,此时表处于维护、不可操作状态,这会导致该期间对该表的所有访问无法响应。但是在MySQL5.6
之后,支持Online DDL
,大大缩短了锁定时间。
优化技巧是采用的维护表结构的DDL(比如增加一列,或者增加一个索引),是
copy
策略。思路:创建一个满足新结构的新表,将旧表数据
逐条
导入(复制)到新表中,以保证
一次性锁定的内容少
(锁定的是正在导入的数据),同时旧表上可以执行其他任务。导入的过程中,将对旧表的所有操作以日志的形式记录下来,导入完毕后,将更新日志在新表上再执行一遍(确保一致性)。最后,新表替换旧表(在应用程序中完成,或者是数据库的rename,视图完成)。
但随着MySQL的升级,这个问题几乎淡化了。
数据库导入语句
在恢复数据时,可能会导入大量的数据。此时为了快速导入,需要掌握一些技巧:
- 导入时
先禁用索引和约束
:
alter table table-name disable keys
待数据导入完成之后,再开启索引和约束,一次性创建索引
alter table table-name enable keys
- 数据库如果使用的引擎是
Innodb
,那么它
默认会给每条写指令加上事务
(这也会消耗一定的时间),因此建议先手动开启事务,再执行一定量的批量导入,最后手动提交事务。
2. 如果批量导入的SQL指令格式相同只是数据不同,那么你应该先prepare
预编译
一下,这样也能节省很多重复编译的时间。
学习分享,共勉
这里是小编拿到的学习资源,其中包括“中高级Java开发面试高频考点题笔记300道.pdf”和“Java核心知识体系笔记.pdf”文件分享,内容丰富,囊括了JVM、锁、并发、Java反射、Spring原理、微服务、Zookeeper、数据库、数据结构等大量知识点。同时还有Java进阶学习的知识笔记脑图(内含大量学习笔记)!
资料整理不易,读者朋友可以转发分享下!
Java核心知识体系笔记.pdf
中高级Java开发面试高频考点题笔记300道.pdf
架构进阶面试专题及架构学习笔记脑图
Java架构进阶学习视频分享
able)的语言。在线上执行DDL,在低于
MySQL5.6版本时会导致全表被独占锁定,此时表处于维护、不可操作状态,这会导致该期间对该表的所有访问无法响应。但是在
MySQL5.6之后,支持
Online DDL`,大大缩短了锁定时间。
优化技巧是采用的维护表结构的DDL(比如增加一列,或者增加一个索引),是
copy
策略。思路:创建一个满足新结构的新表,将旧表数据
逐条
导入(复制)到新表中,以保证
一次性锁定的内容少
(锁定的是正在导入的数据),同时旧表上可以执行其他任务。导入的过程中,将对旧表的所有操作以日志的形式记录下来,导入完毕后,将更新日志在新表上再执行一遍(确保一致性)。最后,新表替换旧表(在应用程序中完成,或者是数据库的rename,视图完成)。
但随着MySQL的升级,这个问题几乎淡化了。
数据库导入语句
在恢复数据时,可能会导入大量的数据。此时为了快速导入,需要掌握一些技巧:
- 导入时
先禁用索引和约束
:
alter table table-name disable keys
待数据导入完成之后,再开启索引和约束,一次性创建索引
alter table table-name enable keys
- 数据库如果使用的引擎是
Innodb
,那么它
默认会给每条写指令加上事务
(这也会消耗一定的时间),因此建议先手动开启事务,再执行一定量的批量导入,最后手动提交事务。
2. 如果批量导入的SQL指令格式相同只是数据不同,那么你应该先prepare
预编译
一下,这样也能节省很多重复编译的时间。
学习分享,共勉
这里是小编拿到的学习资源,其中包括“中高级Java开发面试高频考点题笔记300道.pdf”和“Java核心知识体系笔记.pdf”文件分享,内容丰富,囊括了JVM、锁、并发、Java反射、Spring原理、微服务、Zookeeper、数据库、数据结构等大量知识点。同时还有Java进阶学习的知识笔记脑图(内含大量学习笔记)!
资料整理不易,读者朋友可以转发分享下!
Java核心知识体系笔记.pdf
[外链图片转存中…(img-wQ8sjHNR-1720107796060)]
中高级Java开发面试高频考点题笔记300道.pdf
[外链图片转存中…(img-G5lYBzDu-1720107796060)]
架构进阶面试专题及架构学习笔记脑图
[外链图片转存中…(img-4cv0xKbm-1720107796060)]
Java架构进阶学习视频分享