高吞吐量系统设计优化建议

共计 12593 个字符，预计需要花费 32 分钟才能阅读完成。

高吞吐量系统

举一个例子，我们做项目需要安排计划，每一个模块可以由多人同时并行做多项任务，也可以一个人或者多个人串行工作，但始终会有一条关键路径，这条路径就是项目的工期。系统一次调用的响应时间跟项目计划一样，也有一条关键路径，这个关键路径是就是系统影响时间。关键路径由 CPU 运算、IO、外部系统响应等等组成。

对于一个系统的用户来说，从用户点击一个按钮、链接或发出一条指令开始，到系统把结果以用户希望的形式展现出来为终止，整个过程所消耗的时间是用户对这个软件性能的直观印象，也就是我们所说的响应时间。当响应时间较短时，用户体验是很好的，当然用户体验的响应时间包括个人主观因素和客观响应时间。在设计软件时，我们就需要考虑到如何更好地结合这两部分达到用户最佳的体验。如：用户在大数据量查询时，我们可以将先提取出来的数据展示给用户，在用户看的过程中继续进行数据检索，这时用户并不知道我们后台在做什么，用户关注的是用户操作的响应时间。

我们经常说的一个系统吞吐量，通常由 QPS（TPS）、并发数两个因素决定，每套系统这两个值都有一个相对极限值，在应用场景访问压力下，只要某一项达到系统最高值，系统的吞吐量就上不去了，如果压力继续增大，系统的吞吐量反而会下降，原因是系统超负荷工作，上下文切换、内存等等其它消耗导致系统性能下降，决定系统响应时间要素。

缓冲 (Buffer)

缓冲区是一块特定的内存区域，开辟缓冲区的目的是通过缓解应用程序上下层之间的性能差异，提高系统的性能。在日常生活中，缓冲的一个典型应用是漏斗。缓冲可以协调上层组件和下层组件的性能差，当上层组件性能优于下层组件时，可以有效减少上层组件对下层组件的等待时间。基于这样的结构，上层应用组件不需要等待下层组件真实地接受全部数据，即可返回操作，加快了上层组件的处理速度，从而提升系统整体性能。

使用 BufferedWriter 进行缓冲

BufferedWriter 就是一个缓冲区用法，一般来说，缓冲区不宜过小，过小的缓冲区无法起到真正的缓冲作用，缓冲区也不宜过大，过大的缓冲区会浪费系统内存，增加 GC 负担。尽量在 I/O 组件内加入缓冲区，可以提高性能。一个缓冲区例子代码如清单 1 所示。

清单 1. 加上缓冲区之前示例代码

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
 
import javax.swing.JApplet;
 
public class NoBufferMovingCircle extends JApplet implements Runnable{
 Image screenImage = null;
 Thread thread;
 int x = 5;
 int move = 1;
 
 public void init(){screenImage = createImage(230,160);
 }
 
 public void start(){if(thread == null){thread = new Thread(this);
 thread.start();}
 }
 
@Override
public void run() {
// TODO Auto-generated method stub
try{System.out.println(x);
while(true){
x+=move;
System.out.println(x);
if((x>105)||(x<5)){move*=-1;}
repaint();
Thread.sleep(10);
}
}catch(Exception e){}}
 
public void drawCircle(Graphics gc){Graphics2D g = (Graphics2D) gc;
g.setColor(Color.GREEN);
g.fillRect(0, 0, 200, 100);
g.setColor(Color.red);
g.fillOval(x, 5, 90, 90);
}
 
public void paint(Graphics g){g.setColor(Color.white);
g.fillRect(0, 0, 200, 100);
drawCircle(g);
}
 
}

程序可以完成红球的左右平移，但是效果较差，因为每次的界面刷新都涉及图片的重新绘制，这较为费时，因此，画面的抖动和白光效果明显。为了得到更优质的显示效果，可以为它加上缓冲区。代码如清单 2 所示。

清单 2. 加上缓冲区之后示例代码

import java.awt.Color;
import java.awt.Graphics;
 
public class BufferMovingCircle extends NoBufferMovingCircle{
 Graphics doubleBuffer = null;// 缓冲区
 
 public void init(){super.init();
 doubleBuffer = screenImage.getGraphics();}
 
 public void paint(Graphics g){// 使用缓冲区，优化原有的 paint 方法
 doubleBuffer.setColor(Color.white);// 先在内存中画图
 doubleBuffer.fillRect(0, 0, 200, 100);
 drawCircle(doubleBuffer);
 g.drawImage(screenImage, 0, 0, this);
 }
}

使用 Buffer 进行 I/O 操作

除 NIO 外，使用 Java 进行 I/O 操作有两种基本方式：

• 使用基于 InputStream 和 OutputStream 的方式；
• 使用 Writer 和 Reader。

无论使用哪种方式进行文件 I/O，如果能合理地使用缓冲，就能有效地提高 I/O 的性能。

下面显示了可与 InputStream、OutputStream、Writer 和 Reader 配套使用的缓冲组件。

OutputStream-FileOutputStream-BufferedOutputStream

InputStream-FileInputStream-BufferedInputStream

Writer-FileWriter-BufferedWriter

Reader-FileReader-BufferedReader

使用缓冲组件对文件 I/O 进行包装，可以有效提高文件 I/O 的性能。

清单 3. 示例代码

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class StreamVSBuffer {public static void streamMethod() throws IOException{
 try {long start = System.currentTimeMillis();
// 请替换成自己的文件
 DataOutputStream dos = new DataOutputStream(new FileOutputStream("C://StreamVSBuffertest.txt"));
for(int i=0;i<10000;i++){dos.writeBytes(String.valueOf(i)+"/r/n");// 循环 1 万次写入数据
}
dos.close();
DataInputStream dis = new DataInputStream(new FileInputStream("C://StreamVSBuffertest.txt"));
while(dis.readLine() != null){
}
dis.close();
 System.out.println(System.currentTimeMillis() - start);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();}
 
 }
 
 public static void bufferMethod() throws IOException{
 try {long start = System.currentTimeMillis();
 // 请替换成自己的文件
 DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("C://StreamVSBuffertest.txt")));
 for(int i=0;i<10000;i++){dos.writeBytes(String.valueOf(i)+"/r/n");// 循环 1 万次写入数据
 }
 dos.close();
 DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream("C://StreamVSBuffertest.txt")));
 while(dis.readLine() != null){ }
 dis.close();
 System.out.println(System.currentTimeMillis() - start);
 } catch (FileNotFoundException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();}
 }
 
 public static void main(String[] args){
 try {StreamVSBuffer.streamMethod();
StreamVSBuffer.bufferMethod();} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();}
 }
}

运行结果如清单 4 所示。

清单 4. 运行输出

889
31

很明显使用缓冲的代码性能比没有使用缓冲的快了很多倍。清单 5 所示代码对 FileWriter 和 FileReader 进行了相似的测试。

清单 5.FileWriter 和 FileReader 代码

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
public class WriterVSBuffer {public static void streamMethod() throws IOException{
 try {long start = System.currentTimeMillis();
 FileWriter fw = new FileWriter("C://StreamVSBuffertest.txt");// 请替换成自己的文件
for(int i=0;i<10000;i++){fw.write(String.valueOf(i)+"/r/n");// 循环 1 万次写入数据
}
fw.close();
FileReader fr = new FileReader("C://StreamVSBuffertest.txt");
while(fr.ready() != false){
}
fr.close();
 System.out.println(System.currentTimeMillis() - start);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();}
 
 }
 
 public static void bufferMethod() throws IOException{
 try {long start = System.currentTimeMillis();
 BufferedWriter fw = new BufferedWriter(new FileWriter("C://StreamVSBuffertest.txt"));// 请替换成自己的文件
 for(int i=0;i<10000;i++){fw.write(String.valueOf(i)+"/r/n");// 循环 1 万次写入数据
 }
 fw.close();
 BufferedReader fr = new BufferedReader(new FileReader("C://StreamVSBuffertest.txt"));
 while(fr.ready() != false){ }
 fr.close();
 System.out.println(System.currentTimeMillis() - start);
 } catch (FileNotFoundException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();}
 }
 
 public static void main(String[] args){
 try {StreamVSBuffer.streamMethod();
StreamVSBuffer.bufferMethod();} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();}
 }
}

运行输出如清单 6 所示。

清单 6. 运行输出

1295
31

从上面例子可以看出，无论对于读取还是写入文件，适当地使用缓冲，可以有效地提升系统的文件读写性能，为用户减少响应时间。

缓存

缓存也是一块为提升系统性能而开辟的内存空间。缓存的主要作用是暂存数据处理结果，并提供下次访问使用。在很多场合，数据的处理或者数据获取可能会非常费时，当对这个数据的请求量很大时，频繁的数据处理会耗尽 CPU 资源。缓存的作用就是将这些来之不易的数据处理结果暂存起来，当有其他线程或者客户端需要查询相同的数据资源时，可以省略对这些数据的处理流程，而直接从缓存中获取处理结果，并立即返回给请求组件，以此提高系统的响应时间。

目前有很多基于 Java 的缓存框架，比如 Ehcache、OSCache 和 JBossCache 等。EHCache 缓存出自 Hibernate，是其默认的数据缓存解决方案；OSCache 缓存是有 OpenSymphony 设计的，它可以用于缓存任何对象，甚至是缓存部分 JSP 页面或者 HTTP 请求；JBossCache 是由 JBoss 开发、可用于 JBoss 集群间数据共享的缓存框架。

以 EHCache 为例，EhCache 的主要特性有：

1. 快速；
2. 简单；
3. 多种缓存策略；
4. 缓存数据有两级：内存和磁盘，因此无需担心容量问题；
5. 缓存数据会在虚拟机重启的过程中写入磁盘；
6. 可以通过 RMI、可插入 API 等方式进行分布式缓存；
7. 具有缓存和缓存管理器的侦听接口；
8. 支持多缓存管理器实例，以及一个实例的多个缓存区域；
9. 提供 Hibernate 的缓存实现。

由于 EhCache 是进程中的缓存系统，一旦将应用部署在集群环境中，每一个节点维护各自的缓存数据，当某个节点���缓存数据进行更新，这些更新的数据无法在其它节点中共享，这不仅会降低节点运行的效率，而且会导致数据不同步的情况发生。例如某个网站采用 A、B 两个节点作为集群部署，当 A 节点的缓存更新后，而 B 节点缓存尚未更新就可能出现用户在浏览页面的时候，一会是更新后的数据，一会是尚未更新的数据，尽管我们也可以通过 Session Sticky 技术来将用户锁定在某个节点上，但对于一些交互性比较强或者是非 Web 方式的系统来说，Session Sticky 显然不太适合。所以就需要用到 EhCache 的集群解决方案。清单 7 所示是 EHCache 示例代码。

清单 7.EHCache 示例代码

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
/**
 * 第一步：生成 CacheManager 对象
 * 第二步：生成 Cache 对象
 * 第三步：向 Cache 对象里添加由 key,value 组成的键值对的 Element 元素
 * @author mahaibo
 *
 */
public class EHCacheDemo{public static void main(String[] args) {
 // 指定 ehcache.xml 的位置
 String fileName="E://1008//workspace//ehcachetest//ehcache.xml";
 CacheManager manager = new CacheManager(fileName);
 // 取出所有的 cacheName
 String names[] = manager.getCacheNames();
 for(int i=0;i<names.length;i++){System.out.println(names[i]);
 }
 // 根据 cacheName 生成一个 Cache 对象
 // 第一种方式：Cache cache=manager.getCache(names[0]);
 
 // 第二种方式，ehcache 里必须有 defaultCache 存在,"test" 可以换成任何值
// Cache cache = new Cache("test", 1, true, false, 5, 2); 
// manager.addCache(cache); 
 
 // 向 Cache 对象里添加 Element 元素，Element 元素有 key，value 键值对组成
 cache.put(new Element("key1","values1"));
 Element element = cache.get("key1");
 
 System.out.println(element.getValue());
 Object obj = element.getObjectValue();
 System.out.println((String)obj);
 manager.shutdown();}
 
}

<Resource name="jdbc/dbsource" 
 type="com.mchange.v2.c3p0.ComboPooledDataSource" 
 maxPoolSize="50" minPoolSize="5" acquireIncrement="2" initialPoolSize="10" maxIdleTime="60"
 factory="org.apache.naming.factory.BeanFactory" 
 user="xxxx" password="xxxx" 
 driverClass="Oracle.jdbc.driver.OracleDriver" 
 jdbcUrl="jdbc:oracle:thin:@192.168.x.x:1521:orcl" 
 idleConnectionTestPeriod="10" />

<bean id="dataSource" destroy-method="close">
<property name="driverClass"><value>oracle.jdbc.driver.OracleDriver</value></property>
<property name="jdbcUrl"><value>jdbc:oracle:thin:@localhost:1521:Test</value></property>
<property name="user"><value>Kay</value></property>
<property name="password"><value>root</value></property>
<!-- 连接池中保留的最小连接数。-->
<property name="minPoolSize" value="10" />
<!-- 连接池中保留的最大连接数。Default: 15 -->
<property name="maxPoolSize" value="100" />
<!-- 最大空闲时间,1800 秒内未使用则连接被丢弃。若为 0 则永不丢弃。Default: 0 -->
<property name="maxIdleTime" value="1800" />
<!-- 当连接池中的连接耗尽的时候 c3p0 一次同时获取的连接数。Default: 3 -->
<property name="acquireIncrement" value="3" />
<property name="maxStatements" value="1000" />
<property name="initialPoolSize" value="10" />
<!-- 每 60 秒检查所有连接池中的空闲连接。Default: 0 -->
<property name="idleConnectionTestPeriod" value="60" />
<!-- 定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
<property name="acquireRetryAttempts" value="30" />
<property name="breakAfterAcquireFailure" value="true" />
<property name="testConnectionOnCheckout" value="false" />
</bean>

a=a+b;
b=a-b;
a=a-b;

public class UnsignedByte {public short getValue(byte i){// 将 byte 转为无符号的数字
 short li = (short)(i & 0xff);
 return li;
 }
 
 public byte toUnsignedByte(short i){return (byte)(i & 0xff);// 将 short 转为无符号 byte
 }
 
 public static void main(String[] args){UnsignedByte ins = new UnsignedByte();
 short[] shorts = new short[256];// 声明一个 short 数组
 for(int i=0;i<shorts.length;i++){// 数组不能超过无符号 byte 的上限
 shorts[i]=(short)i;
 }
 byte[] bytes = new byte[256];// 使用 byte 数组替代 short 数组
 for(int i=0;i<bytes.length;i++){bytes[i]=ins.toUnsignedByte(shorts[i]);//short 数组的数据存到 byte 数组中
 }
 for(int i=0;i<bytes.length;i++){System.out.println(ins.getValue(bytes[i])+" ");// 从 byte 数组中取出无符号的 byte
 }
 }
}

0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
 
public class SpaceSort {
 public static int arrayLen = 1000000;
 
 public static void main(String[] args){int[] a = new int[arrayLen];
 int[] old = new int[arrayLen];
 Map<Integer,Object> map = new HashMap<Integer,Object>();
 int count = 0;
 while(count < a.length){
 // 初始化数组
 int value = (int)(Math.random()*arrayLen*10)+1;
 if(map.get(value)==null){map.put(value, value);
 a[count] = value;
 count++;
 }
 }
 System.arraycopy(a, 0, old, 0, a.length);// 从 a 数组拷贝所有数据到 old 数组
 long start = System.currentTimeMillis();
 Arrays.sort(a);
 System.out.println("Arrays.sort spend:"+(System.currentTimeMillis() - start)+"ms");
 System.arraycopy(old, 0, a, 0, old.length);// 恢复 原有数据
 start = System.currentTimeMillis();
 spaceTotime(a);
 System.out.println("spaceTotime spend:"+(System.currentTimeMillis() - start)+"ms");
 }
 
 public static void spaceTotime(int[] array){
 int i = 0;
 int max = array[0];
 int l = array.length;
 for(i=1;i<l;i++){if(array[i]>max){max = array[i];
 }
 }
 int[] temp = new int[max+1];
 for(i=0;i<l;i++){temp[array[i]] = array[i];
 }
 int j = 0;
 int max1 = max + 1;
 for(i=0;i<max1;i++){if(temp[i] > 0){array[j++] = temp[i];
 }
 }
 }
}

本文永久更新链接地址 ：http://www.linuxidc.com/Linux/2015-08/122377.htm