架构师训练营 - 性能优化

发布于: 6 小时前

性能测试

性能测试是性能优化的前提和基础,也是性能优化结果的检查和度量标准。不同视角下的网站有不同的标准,也有不同的优化手段。

主观视角:用户感受到的性能。

客观视角:性能指标衡量的性能(主要有响应时间,并发数,吞吐量,性能计数器)。

响应时间

指应用系统从发出请求开始到收到最后响应数据所需的时间(从发出第一个字节开始标记开始,从收到最后一个字节后标记结束)。响应时间直观反映了系统的“快慢”。

并发数

系统能够同时处理请求的数目,这个数字也反映了系统的负载特性。对于网站而言,并发数即系统并发用户数,指同时提交请求的用户数目,于此相对应,还有在线用户数(当前登录系统的用户数)和系统用户数(可能访问系统的中用户数)。

吞吐量

指单位时间内系统处理的请求数,体现系统的处理能力。对于网站,可以用“请求数/秒”或“页面数/秒”来衡量,也可以用“访问人数/天”或是“处理的业务数/小时”等来衡量。(通常以秒为单位)

TPS(每秒事务数)也是吞吐量的一个指标,此外还有HPS(每秒HTTP请求数),QPS(每秒查询数)等。

吞吐量=(1000/响应时间ms)* 并发数

性能计数器

是描述服务器或操作系统性能的一些数据指标。包括System Load,对象和线程数,内存使用,CPU使用,磁盘与网络IO等指标。这些指标也是系统监控的重要参数,对这些指标设置报警阈值,当监控系统发现性能计数器超过阈值的时候,就向运维和开发人员报警,及时发现处理系统异常。

性能测试方法

可以细分为性能测试,负载测试,压力测试,稳定性测试。

性能测试:以系统设计初期规划的性能指标为预期目标,对系统不断施加压力,验证系统在资源可接受范围内,是否能达到性能预期。

负载测试:对系统不断地增加并发请求以增加系统压力,直到系统的某项或多项性能指标达到安全临界值,如某种资源已经呈饱和状态,这时候继续对系统施加压力,系统的处理能力不但不能提高,反而会下降。

压力测试:超出安全负载的情况下,对系统继续施加压力,直到系统崩溃或不能再处理任何请求,以此获得系统最大压力承受能力。

稳定性测试:被测试系统在特定硬件,软件,网络环境条件下,给系统加载一定业务压力,使系统运行一段较长时间,以此检测系统是否稳定。在生产环境,请求压力是不均匀的,呈波浪特性,因此为了更好地模拟生产环境,稳定性测试也应不均匀地对系统施加压力。

性能优化

基本原则

你不能优化一个没有测试的软件

你不能优化一个你不了解的软件

一般方法

性能测试,获得性能指标(吞吐量,响应时间,并发数,性能计数器等)

指标分析,发现性能与资源瓶颈点

架构与代码分析,寻找性能与资源瓶颈关键所在

架构与代码优化,优化关键技术点,平衡资源利用

性能测试,进入性能优化闭环

分层思想

机房与骨干网络性能优化

服务器与硬件性能优化(垂直伸缩)

操作系统性能优化

虚拟机性能优化(java虚拟节相关,比如即时编译,垃圾回收,锁等)

基础组件性能优化(tomcat,spring,fastjson等)

软件架构性能优化(分布式系统,分布式缓存,消息队列等)

软件代码性能优化

机房与骨干网络性能优化

异地多活的多机房架构

专线网络与自建CDN

服务器与硬件性能优化

使用更优的CPU,磁盘,内存,网卡,对软件的性能优化可能是数量级的,有时候远超代码和架构的性能优化。

软件架构性能优化三板斧

缓存

从内存获取数据,减少响应时间。减少数据库访问,降低存储设备负载压力。缓存结果对象,而不是原始数据,减少CPU计算。缓存主要优化读操作。

异步

即时响应,更好的用户体验。控制消费速度,合适的负载压力。异步主要优化写操作。

集群

古老谚语:如果一匹马拉不动车,无需换一匹更强的马,而是用两匹马拉车。

集群的技术目标只有一个:如何使很多台服务器对使用者而言看起来就像一台服务器。

程序运行时架构

程序是静态的。程序运行起来以后,被称为进程,进程是有生命的。

进程运行时状态

运行:进程正在CPU上运行

就绪:进程获得了除CPU以外的一切所需资源,只要得到CPU,就能运行

阻塞:也称为等待或睡眠状态,当进程正在等待某一事件发生(如IO完成,锁等),此时即使把CPU分配给进程也无法执行

进程VS线程

不同进程轮流在CPU上执行,每次都要进行进程间CPU切换,代价很大,因此服务器应用通常是单进程多线程。一个进程里面的所有线程共享进程的内存地址空间,而每个线程也会拥有自己私有的内存地址范围(栈空间),其他线程不能访问。

线程安全

当某些代码修改内存堆(进程共享内存)里的数据的时候,如果有多个线程在同时执行,就可能会出现同时修改数据的情况。

临界区

多个线程访问共享资源的这段代码被称为临界区,解决线程安全问题的主要方法是使用锁,间临界区的代码加锁,只有获得锁的线程才能操作临界区代码。

阻塞导致高并发系统崩溃

锁或者IO会引起线程阻塞,阻塞导致线程既不能继续执行,也不能释放资源。进而导致资源耗尽,最终导致系统崩溃(如何避免:限流,熔断降级,反应式编程)。

锁原语CAS

CAS(V,E,N)

V表示要更新的变量

E表示预期值

N表示新值

如果V变量对应的值等于E值,则将V的值更新为N,若V值与E不同,什么都不做。CAS是一种系统原语,原语的执行必须是连续的,在执行过程中不允许被中断。

偏向锁:指一段同步代码一直被一个线程访问,那么该线程会自动获得锁,降低获得锁的代价。

轻量级锁:指当锁是偏向锁时,被另一个线程所访问,偏向锁就会升级成轻量级锁,其他线程通过自旋的形式尝试获取锁,不会阻塞,提高性能。

重量级锁:指当锁是轻量级锁时,另一个线程虽然自旋,但自旋不会一直持续下去,当自旋到一定次数时,还没获取到锁,就会进入阻塞,该锁膨胀为重量级锁,重量级锁会让其他申请的线程进入阻塞,性能降低。

多CPU情况下的锁

多个CPU,每个CPU进行CAS都是自己Cache里面的对象头,那岂不是多个CPU可以同时获得锁了?此时,就要引入总线锁和缓存锁的概念了。

总线锁:使用处理器的LOCK#信号,当一个处理器在内存总线上输出此信号的时候,其他处理器的请求被阻塞,该处理器独占内存。

缓存锁:是指内存区域如果被缓存在处理器的缓存行中,并且在Lock操作期间被锁定,那么当它执行锁操作回写到内存时,处理器不在总线上声言LOCK#信号,而且修改内部内存地址,并允许它的缓存一致性来保证操作的原子性,因为缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据,当其他处理器回写已被锁定的缓存行数据时,会使得缓存行无效。

文件控制块

文件系统将磁盘空间以块为单位(常见的是4KB)进行划分,每个文件占据若干个块,然后再通过一个文件控制块FCB记录每个文件占据的硬盘数据块(操作系统一次至少读取一个块)。(注意:一个块是由多个扇区构成,扇区的单位是512字节)

Linux inode文件控制块

inode中记录着文件权限,所有者,修改时间和文件大小等文件属性信息,以及文件数据块硬盘地址索引。inode是固定结构的,能够记录的硬盘地址索引数也是固定的,只有15个索引。每个inode最多可以存储12+256+256*256+256*256*256个数据块,如果每个数据块的大小为4K,也就是单个文件最大不超过70GB。

RAID独立硬盘冗余阵列

RAID0:数据分散写入多块磁盘,提升写入性能,但是降低了可用性,磁盘故障率升高。

RAID1:两个硬盘同时写同样的数据,提升了可用性,成本提升。

RAID10:RAID0和RAID1的组合,兼顾了可用性和性能,但是浪费比较严重(浪费一半)。

RAID5:使用一块硬盘记录其他两块盘的异或结果,这样坏掉一块盘的话,也可以恢复,最多浪费一块盘。

RAID6:对RAID5的改进,使用两块盘记录两种校验算法的结果,这样即使坏掉两块盘,也可以恢复。

分布式文件系统HDFS

作业

作业1:性能压测的时候,随着并发压力的增加,系统响应时间和吞吐量如何变化,为什么?

如上

作业2:用你熟悉的编程语言写一个 web 性能压测工具,输入参数:URL,请求总次数,并发数。输出参数:平均响应时间,95% 响应时间。用这个测试工具以 10 并发、100 次请求压测 www.baidu.com。

public class JavaPerformanceTest {
//超时请求时间
private final long TIMEOUT = 3000;
//超时请求时间单位
private final TimeUnit UNIT = TimeUnit.MILLISECONDS;
//默认总共请求数
private int totalNums = 100;
//默认并发数
private int concurrentNums = 10;
public static void main(String[] args) {
JavaPerformanceTest javaTest = new JavaPerformanceTest();
javaTest.test(args);
}
private void test(String[] args) {
try {
//测试地址
String url = "https://www.baidu.com/";
//封装为URL类
final URL rea = new URL(url);
//总共请求数
totalNums = 100;
//并发数
concurrentNums = 10;
//模拟请求
List<Future<RequestResult>> futureList = simulateRequest(rea);
//结果展示
display(futureList);
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 模拟请求
*
* @param rea
* @throws InterruptedException
*/
private List<Future<RequestResult>> simulateRequest(URL rea)
throws InterruptedException {
int seconds = totalNums % concurrentNums == 0
? totalNums / concurrentNums
: totalNums / concurrentNums + 1;
ExecutorService service = Executors.newFixedThreadPool(seconds);
List<Callable<RequestResult>> requestList = new ArrayList<>();
List<Future<RequestResult>> futureList = new ArrayList<>();
for (int i = 0; i < seconds; i++) {
requestList.clear();
//当前需要请求数
int curConcurrentNums = (i == seconds - 1)
? totalNums - concurrentNums * i
: concurrentNums;
for (int j = 0; j < curConcurrentNums; j++) {
requestList.add(() -> req(rea));
}
List<Future<RequestResult>> futures = service.invokeAll(requestList, TIMEOUT, UNIT);
futureList.addAll(futures);
//间隔一秒
Thread.sleep(1000);
}
service.shutdown();
return futureList;
}
/**
* 输出结果
*
* @param futureList
*/
private void display(List<Future<RequestResult>> futureList) {
List<Long> times = new ArrayList<>();
int errorNums = 0;
for (Future<RequestResult> resultSetFutureTask : futureList) {
try {
RequestResult requestResult=resultSetFutureTask.get();
if(requestResult.code==200) {
times.add(requestResult.elapsedTime);
}else{
//作为错误数据统计
errorNums++;
}
} catch (InterruptedException ex) {
//作为错误数据统计
errorNums++;
} catch (ExecutionException ex) {
//作为错误数据统计
errorNums++;
}
}
//输出结果
times.sort(Long::compareTo);
System.out.println("平均响应时间:" + times.stream().mapToLong(p -> p.longValue()).sum() / totalNums);
System.out.println("90% 响应时间:" + times.get(totalNums * 90 / 100));
System.out.println("95% 响应时间:" + times.get(totalNums * 95 / 100));
System.out.println("99% 响应时间:" + times.get(totalNums * 99 / 100));
System.out.println("最小响应时间:" + times.get(0));
System.out.println("最大响应时间:" + times.get(totalNums - 1));
System.out.println("错误率:" + String.format("%.2f", errorNums * 100.00 / totalNums));
}
/**
* 实际完成一次请求
*
* @param rea
* @return
* @throws IOException
*/
private RequestResult req(URL rea) throws IOException {
long start = System.currentTimeMillis();
//打开和URL之间的连接
HttpURLConnection connection = (HttpURLConnection) rea.openConnection();
//设置请求属性
connection.setRequestMethod("GET");
// 设置是否使用缓存
connection.setUseCaches(false);
connection.connect();//建立实际的连接
int code = connection.getResponseCode();
long end = System.currentTimeMillis();
return new RequestResult(code, end - start);
}
/**
* 请求结果
*/
public class RequestResult {
int code;
long elapsedTime;
RequestResult(int code, long elapsedTime) {
this.code = code;
this.
elapsedTime = elapsedTime;
}
}
}

参考1

参考2

用户头像

Pontus

关注

还未添加个人签名 2018.04.21 加入

还未添加个人简介

评论

发布
暂无评论
架构师训练营 - 性能优化