甜橘子，专注成都网站制作网站设计与营销型网站建设与优化
QQ :532337155
电话：028-86922220
提高JAVA的性能，一般考虑如下的四个主要方面：
创新互联公司成立与2013年，先为漳州等服务建站，漳州等地企业，进行企业商务咨询服务。为漳州企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。
（1） 程序设计的方法和模式
一个良好的设计能提高程序的性能，这一点不仅适用于JAVA，也适用也任何的编程语言。因为它充分利用了各种资源，如内存，CPU,高速缓存，对象缓冲池及多线程，从而设计出高性能和可伸缩性强的系统。
当然，为了提高程序的性能而改变原来的设计是比较困难的，但是，程序性能的重要性常常要高于设计上带来的变化。因此，在编程开始之前就应该有一个好的设计模型和方法。
（2） JAVA布署的环境。
JAVA布署的环境就是指用来解释和执行JAVA字节码的技术，一般有如下五种。即解释指令技术(Interpreter Technology)，及时编译的技术(Just In Time Compilier Technology), 适应性优化技术（Adaptive Optimization Technology）, 动态优化，提前编译为机器码的技术（Dynamic Optimization,Ahead Of Time Technology）和编译为机器码的技术（Translator Technology）.
这些技术一般都通过优化线程模型，调整堆和栈的大小来优化JAVA的性能。在考虑提高JAVA的性能时，首先要找到影响JAVA性能的瓶颈（BottleNecks），在确认了设计的合理性后，应该调整JAVA布署的环境，通过改变一些参数来提高JAVA应用程序的性能。具体内容见第二节。
（3） JAVA应用程序的实现
当讨论应用程序的性能问题时，大多数的程序员都会考虑程序的代码，这当然是对的，当更重要的是要找到影响程序性能的瓶颈代码。为了找到这些瓶颈代码，我们一般会使用一些辅助的工具，如Jprobe,Optimizit,Vtune以及一些分析的工具如TowerJ Performance等。这些辅助的工具能跟踪应用程序中执行每个函数或方法所消耗掉的时间，从而改善程序的性能。
（4） 硬件和操作系统
为了提高JAVA应用程序的性能，而采用跟快的CPU和更多的内存，并认为这是提高程序性能的唯一方法，但事实并非如此。实践经验和事实证明，只有遭到了应用程序性能的瓶颈，从而采取适当得方法，如设计模式，布署的环境，操作系统的调整，才是最有效的。
3．程序中通常的性能瓶颈。
所有的应用程序都存在性能瓶颈，为了提高应用程序的性能，就要尽可能的减少程序的瓶颈。以下是在JAVA程序中经常存在的性能瓶颈。
了解了这些瓶颈后，就可以有针对性的减少这些瓶颈，从而提高JAVA应用程序的性能
4. 提高JAVA程序性能的步骤
为了提高JAVA程序的性能，需要遵循如下的六个步骤。
a) 明确对性能的具体要求
在实施一个项目之前，必须要明确该项目对于程序性能的具体要求，如：这个应用程序要支持5000个并发的用户，并且响应时间要在5秒钟之内。但同时也要明白对于性能的要求不应该同对程序的其他要求冲突。
1、组织与风格
(1).关键词和操作符之间加适当的空格。
(2).相对独立的程序块与块之间加空行
(3).较长的语句、表达式等要分成多行书写。
(4).划分出的新行要进行适应的缩进，使排版整齐，语句可读。
(5).长表达式要在低优先级操作符处划分新行，操作符放在新行之首。
(6).循环、判断等语句中若有较长的表达式或语句，则要进行适应的划分。
(7).若函数或过程中的参数较长，则要进行适当的划分。
(8).不允许把多个短语句写在一行中，即一行只写一条语句。
(9).函数或过程的开始、结构的定义及循环、判断等语句中的代码都要采用缩进风格。
注：如果大家有兴趣可以到安安DIY创作室博客，有相关说明性的文章和解释。
2、注解
Java 的语法与 C++ 及为相似，那么，你知道 Java 的注释有几种吗？是两种？
// 注释一行
/* ...... */ 注释若干行
不完全对，除了以上两种之外，还有第三种，文档注释：
/** ...... */ 注释若干行，并写入 javadoc 文档
注释要简单明了。
String userName = null; //用户名
边写代码边注释，修改代码同时修改相应的注释，以保证注释与代码的一致性。
在必要的地方注释，注释量要适中。注释的内容要清楚、明了，含义准确，防止注释二义性。
保持注释与其描述的代码相邻，即注释的就近原则。
对代码的注释应放在其上方相邻位置，不可放在下面。对数据结构的注释应放在其上方相邻位置，不可放在下面；对结构中的每个域的注释应放在此域的右方；
同一结构中不同域的注释要对齐。
变量、常量的注释应放在其上方相邻位置或右方。
全局变量要有较详细的注释，包括对其功能、取值范围、哪些函数或过程存取它以及存取时注意事项等的说明。
在每个源文件的头部要有必要的注释信息，包括：文件名；版本号；作者；生成日期；模块功能描述（如功能、主要算法、内部各部分之间的关系、该文件与其它文件关系等）；主要函数或过程清单及本文件历史修改记录等。
/**
* Copy Right Information : Neusoft IIT
* Project : eTrain
* JDK version used : jdk1.3.1
* Comments : config path
* Version : 1.01
* Modification history :2003.5.1
* Sr Date Modified By Why What is modified
* 1. 2003.5.2 Kevin Gao new
**/
在每个函数或过程的前面要有必要的注释信息，包括：函数或过程名称；功能描述；输入、输出及返回值说明；调用关系及被调用关系说明等
/**
* Description :checkout 提款
* @param Hashtable cart info
* @param OrderBean order info
* @return String
*/
public String checkout(Hashtable htCart,
OrderBean orderBean)
throws Exception{
}
javadoc注释标签语法
@author 对类的说明 标明开发该类模块的作者
@version 对类的说明 标明该类模块的版本
@see 对类、属性、方法的说明 参考转向，也就是相关主题
@param 对方法的说明 对方法中某参数的说明
@return 对方法的说明 对方法返回值的说明
@exception 对方法的说明 对方法可能抛出的异常进行说明
3、命名规范
定义这个规范的目的是让项目中所有的文档都看起来像一个人写的，增加可读性，减少项目组中因为换人而带来的损失。（这些规范并不是一定要绝对遵守，但是一定要让程序有良好的可读性）较短的单词可通过去掉元音形成缩写；要不然最后自己写的代码自己都看不懂了，那可不行。
较长的单词可取单词的头几发符的优先级，并用括号明确表达式的操作顺序，避免使用默认优先级。
使用匈牙利表示法
Package 的命名
Package 的名字应该都是由一个小写单词组成。
package com.neu.util
Class 的命名
Class 的名字必须由大写字母开头而其他字母都小写的单词组成,对于所有标识符，其中包含的所有单词都应紧靠在一起，而且大写中间单词的首字母。
public class ThisAClassName{}
Class 变量的命名
变量的名字必须用一个小写字母开头。后面的单词用大写字母开头
userName , thisAClassMethod
Static Final 变量的命名
static Final 变量的名字应该都大写，并且指出完整含义。
/**
*DBConfig PATH
**/
public static final String
DB_CONFIG_FILE_PATH =com.neu.etrain.dbconfig;
参数的命名
参数的名字必须和变量的命名规范一致。
数组的命名
数组应该总是用下面的方式来命名：
byte[] buffer;
而不是：
byte buffer[];
方法的参数
使用有意义的参数命名，如果可能的话，使用和要赋值的字段一样的名字：
SetCounter(int size){
this.size = size;
}
4、文件样式
所有的 Java(*.java) 文件都必须遵守如下的样式规则：
版权信息
版权信息必须在 java 文件的开头，比如：
/*
* Copyright ? 2000 Shanghai XXX Co. Ltd.
* All right reserved.
*/
其他不需要出现在 javadoc 的信息也可以包含在这里。
Package/Imports
package 行要在 import 行之前，import 中标准的包名要在本地的包名之前，而且按照字母
顺序排列。如果 import 行中包含了同一个包中的不同子目录，则应该用 * 来处理。
package hotlava.net.stats;
import java io.*;
import java.util.Observable;
import hotlava.util.Application;
这里 java。io.* 使用来代替InputStream and OutputStream 的。
Class
接下来的是类的注释，一般是用来解释类的。
/**
* A class representing a set of packet and byte counters
* It is observable to allow it to be watched, but only
* reports changes when the current set is complete
*/
接下来是类定义，包含了在不同的行的 extends 和 implements
public class CounterSet
extends Observable
implements Cloneable
Class Fields
接下来是类的成员变量：
/**
* Packet counters
*/
protected int[] packets;
public 的成员变量必须生成文档（JavaDoc）。proceted、private和 package 定义的成
员变量如果名字含义明确的话，可以没有注释。
存取方法
接下来是类变量的存取的方法。它只是简单的用来将类的变量赋值获取值的话，可以简单的
写在一行上。
/**
* Get the counters
* @return an array containing the statistical data. This array has been
* freshly allocated and can be modified by the caller.
*/
public int[] getPackets() { return copyArray(packets, offset); }
public int[] getBytes() { return copyArray(bytes, offset); }
public int[] getPackets() { return packets; }
public void setPackets(int[] packets) { this.packets = packets; }
其它的方法不要写在一行上
构造函数
接下来是构造函数，它应该用递增的方式写（比如：参数多的写在后面）。
访问类型 (public, private 等.) 和 任何 static, final 或 synchronized 应该在一行
中，并且方法和参数另写一行，这样可以使方法和参数更易读。
public
CounterSet(int size){
this.size = size;
}
克隆方法
如果这个类是可以被克隆的，那么下一步就是 clone 方法：
public
Object clone() {
try {
CounterSet obj = (CounterSet)super.clone();
obj.packets = (int[])packets.clone();
obj.size = size;
return obj;
}catch(CloneNotSupportedException e) {
throw new InternalError(Unexpected CloneNotSUpportedException: +
e.getMessage());
}
}
类方法
下面开始写类的方法：
/**
* Set the packet counters
* (such as when restoring from a database)
*/
protected final
void setArray(int[] r1, int[] r2, int[] r3, int[] r4)
throws IllegalArgumentException
{
//
// Ensure the arrays are of equal size
//
if (r1.length != r2.length || r1.length != r3.length || r1.length != r4.length)
throw new IllegalArgumentException(Arrays must be of the same size);
System.arraycopy(r1, 0, r3, 0, r1.length);
System.arraycopy(r2, 0, r4, 0, r1.length);
}
toString 方法
无论如何，每一个类都应该定义 toString 方法：
public
String toString() {
String retval = CounterSet: ;
for (int i = 0; i data.length(); i++) {
retval += data.bytes.toString();
retval += data.packets.toString();
}
return retval;
}
}
main 方法
如果main(String[]) 方法已经定义了, 那么它应该写在类的底部.
5、代码可读性
避免使用不易理解的数字，用有意义的标识来替代。
不要使用难懂的技巧性很高的语句。
源程序中关系较为紧密的代码应尽可能相邻。
6、代码性能
在写代码的时候，从头至尾都应该考虑性能问题。这不是说时间都应该浪费在优化代码上，而是我们时刻应该提醒自己要注意代码的效率。比如：如果没有时间来实现一个高效的算法，那么我们应该在文档中记录下来，以便在以后有空的时候再来实现她。
不是所有的人都同意在写代码的时候应该优化性能这个观点的，他们认为性能优化的问题应该在项目的后期再去考虑，也就是在程序的轮廓已经实现了以后。
不必要的对象构造
不要在循环中构造和释放对象
使用 StringBuffer 对象
在处理 String 的时候要尽量使用 StringBuffer 类，StringBuffer 类是构成 String 类的基础。
String 类将 StringBuffer 类封装了起来，（以花费更多时间为代价）为开发人员提供了一个安全的接口。当我们在构造字符串的时候，我们应该用 StringBuffer 来实现大部分的工作，当工作完成后将 StringBuffer 对象再转换为需要的 String 对象。比如：如果有一个字符串必须不断地在其后添加许多字符来完成构造，那么我们应该使用StringBuffer 对象和她的 append() 方法。如果我们用 String 对象代替StringBuffer 对象的话，会花费许多不必要的创建和释放对象的 CPU 时间。大家可以来安安DIY创作室一起讨论。
避免太多的使用 synchronized 关键字避免不必要的使用关键字 synchronized，应该在必要的时候再使用她，这是一个避免死锁的好方法。
7、编程技巧
byte 数组转换到 characters
为了将 byte 数组转换到 characters，你可以这么做：
Hello world!.getBytes();
Utility 类
Utility 类（仅仅提供方法的类）应该被申明为抽象的来防止被继承或被初始化。
初始化
下面的代码是一种很好的初始化数组的方法：
objectArguments = new Object[] { arguments };
枚举类型
JAVA 对枚举的支持不好，但是下面的代码是一种很有用的模板：
class Colour {
public static final Colour BLACK = new Colour(0, 0, 0);
public static final Colour RED = new Colour(0xFF, 0, 0);
public static final Colour GREEN = new Colour(0, 0xFF, 0);
public static final Colour BLUE = new Colour(0, 0, 0xFF);
public static final Colour WHITE = new Colour(0xFF, 0xFF, 0xFF);
}
这种技术实现了RED, GREEN, BLUE 等可以象其他语言的枚举类型一样使用的常量。
他们可以用 '==' 操作符来比较。
但是这样使用有一个缺陷：如果一个用户用这样的方法来创建颜色 BLACK new Colour(0,0,0)
那么这就是另外一个对象，'=='操作符就会产生错误。她的 equal() 方法仍然有效。由于这个原因，这个技术的缺陷最好注明在文档中，或者只在自己的包中使用。
8、编写格式
代码样式
代码应该用 unix 的格式，而不是 windows 的（比如：回车变成回车+换行）
文档化
必须用 javadoc 来为类生成文档。不仅因为它是标准，这也是被各种 java 编译器都认可的方法。使用 @author 标记是不被推荐的，因为代码不应该是被个人拥有的。
缩进
缩进应该是每行2个空格. 不要在源文件中保存Tab字符. 在使用不同的源代码管理工具时Tab字符将因为用户设置的不同而扩展为不同的宽度.如果你使用 UltrEdit 作为你的 Java 源代码编辑器的话，你可以通过如下操作来禁止保存Tab字符, 方法是通过 UltrEdit中先设定 Tab 使用的长度室2个空格，然后用 Format|Tabs to Spaces 菜单将 Tab 转换为空格。
页宽
页宽应该设置为80字符. 源代码一般不会超过这个宽度, 并导致无法完整显示, 但这一设置也可以灵活调整. 在任何情况下, 超长的语句应该在一个逗号或者一个操作符后折行. 一条语句折行后, 应该比原来的语句再缩进2个字符.
{} 对
{} 中的语句应该单独作为一行. 例如, 下面的第1行是错误的, 第2行是正确的:
if (i0) { i ++ }; // 错误, { 和 } 在同一行
if (i0) {
i ++
}; // 正确, { 单独作为一行
} 语句永远单独作为一行.如果 } 语句应该缩进到与其相对应的 { 那一行相对齐的位置。
括号
左括号和后一个字符之间不应该出现空格, 同样, 右括号和前一个字符之间也不应该出现空格. 下面的例子说明括号和空格的错误及正确使用:
CallProc( AParameter ); // 错误
CallProc(AParameter); // 正确
不要在语句中使用无意义的括号. 括号只应该为达到某种目的而出现在源代码中。下面的例子说明错误和正确的用法:
if ((I) = 42) { // 错误 - 括号毫无意义
if (I == 42) or (J == 42) then // 正确 - 的确需要括号
9、代码编译
1.编写代码时要注意随时保存，并定期备份，防止由于断电、硬盘损坏等原因造成代码丢失。
2.同一项目组内，最好使用相同的编辑器，并使用相同的设置选项。
3.合理地设计软件系统目录，方便开发人员使用。
4.打开编译器的所有告警开关对程序进行编译。
5.在同一项目组或产品组中，要统一编译开关选项。
6.使用工具软件（如Visual SourceSafe）对代码版本进行维护。如果大家有不明白的可以到安安DIY创作室留言。
10、可移植性
Borland Jbulider 不喜欢 synchronized 这个关键字，如果你的断点设在这些关键字的作用域内的话，调试的时候你会发现的断点会到处乱跳，让你不知所措。除非必须，尽量不要使用。
换行
如果需要换行的话，尽量用 println 来代替在字符串中使用\n。
你不要这样：
System.out.print(Hello,world!\n);
要这样：
System.out.println(Hello,world!);
或者你构造一个带换行符的字符串，至少要象这样：
String newline = System.getProperty(line.separator);
System.out.println(Hello world + newline);
PrintStream
PrintStream 已经被不赞成（deprecated）使用，用 PrintWrite 来代替它。
另外一个回复是简单的建议，限于代码层面跟计算资源紧张的情况。
说说我的理论：
1、想要这么大的并发量，申请买几台比较好的机器，带宽加到足够大应该不是问题。
2、网络层的负载均衡考虑一下，这应该也不是啥问题，这么大并发量，别告诉我客户网络设计很垃圾。高端点的网络设备都没有。
3、软件层的结构，看用户给什么样的机器，如果经济型的机器，考虑分布式运算，分布式再从软件层面做集群或主从。根据计算密集型还是IO密集型选择适合的设备。计算密集型的业务，需要强悍的CPU（可以用多C，未必是频率高的）+内存。IO密集型的业务需要，速度快的存储，越快越好。有极致要求的考虑固态存储设备。
4、并发设计，java中主要是线程的应用。能拆分成多任务的运算一定拆成多任务。尽量压榨cpu资源，现在的工作站不会写并发程序，真浪费cpu资源。
5、数据库并发的考量，以前说mysql不如oracle现在还有人有这论调。使用的时候把参数调整到最优状态。如缓存到内存中数据大小，内存要够，就把全部表数据加载到内存中。mysql的innodb调整两三个参数就行。数据库IO访问，mysql有测算IO能力的参数，存储够好，可以调整到很大。
6、这么大的并发量，选择适合的缓存器，可以用来缓存热点数据，或加快分布式运算的IO访问能力。（磁盘肯定没内存块，包括固态）
7、代码编写完后，对系统整体进行测试，评估，分析性能瓶颈，优化代码。
能做到以上标准，tomcat+mysql跑一堆集群也不会慢。
通过使用一些辅助性工具来找到程式中的瓶颈，然后就能对瓶颈部分的代码进行优化。一般有两种方案：即优化代码或更改设计方法。我们一般会选择后者，因为不去调用以下代码要比调用一些优化的代码更能提高程式的性能。而一个设计良好的程式能够精简代码，从而提高性能。
????下面将提供一些在JAVA程式的设计和编码中，为了能够提高JAVA程式的性能，而经常采用的一些方法和技巧。
????1．对象的生成和大小的调整。
????JAVA程式设计中一个普遍的问题就是没有好好的利用JAVA语言本身提供的函数，从而常常会生成大量的对象（或实例）。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程式的性能带来非常大的影响。
????例1：关于String ,StringBuffer，+和append
????JAVA语言提供了对于String类型变量的操作。但如果使用不当，会给程式的性能带来影响。如下面的语句：
????String name=new String("HuangWeiFeng");
????System.out.println(name+"is my name");
????看似已非常精简了，其实并非如此。为了生成二进制的代码，要进行如下的步骤和操作：
????(1) 生成新的字符串 new String（STR_1);
????(2) 复制该字符串;
????(3) 加载字符串常量"HuangWeiFeng"（STR_2);
????(4) 调用字符串的构架器（Constructor）;
????(5) 保存该字符串到数组中（从位置0开始）;
????(6) 从java.io.PrintStream类中得到静态的out变量;
????(7) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
????(8) 复制该字符串缓冲变量;
????(9) 调用字符串缓冲的构架器（Constructor）;
????(10) 保存该字符串缓冲到数组中（从位置1开始）;
????(11) 以STR_1为参数，调用字符串缓冲(StringBuffer)类中的append方法;
????(12) 加载字符串常量"is my name"(STR_3);
????(13) 以STR_3为参数，调用字符串缓冲(StringBuffer)类中的append方法;
????(14) 对于STR_BUF_1执行toString命令;
????(15) 调用out变量中的println方法，输出结果。
????由此能看出，这两行简单的代码，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五个对象变量。这些生成的类的实例一般都存放在堆中。堆要对所有类的超类，类的实例进行初始化，同时还要调用类极其每个超类的构架器。而这些操作都是非常消耗系统资源的。因此，对对象的生成进行限制，是完全有必要的。
????经修改，上面的代码能用如下的代码来替换。
????StringBuffer name=new StringBuffer("HuangWeiFeng");
????System.out.println(name.append("is my name.").toString());
????系统将进行如下的操作：
????(1) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
????(2) 复制该字符串缓冲变量;
????(3) 加载字符串常量"HuangWeiFeng"(STR_1);
????(4) 调用字符串缓冲的构架器（Constructor）;
????(5) 保存该字符串缓冲到数组中（从位置1开始）;
????(6) 从java.io.PrintStream类中得到静态的out变量;
????(7) 加载STR_BUF_1;
????(8) 加载字符串常量"is my name"(STR_2);
????(9) 以STR_2为参数，调用字符串缓冲(StringBuffer)实例中的append方法;
????(10) 对于STR_BUF_1执行toString命令(STR_3);
????(11)调用out变量中的println方法，输出结果。
????由此能看出，经过改进后的代码只生成了四个对象变量：STR_1,STR_2,STR_3和STR_BUF_1.你可能觉得少生成一个对象不会对程式的性能有非常大的提高。但下面的代码段2的执行速度将是代码段1的2倍。因为代码段1生成了八个对象，而代码段2只生成了四个对象。
????代码段1：
????String name= new StringBuffer("HuangWeiFeng");
????name+="is my";
????name+="name";
????代码段2：
????StringBuffer name=new StringBuffer("HuangWeiFeng");
????name.append("is my");
????name.append("name.").toString();
????因此，充分的利用JAVA提供的库函数来优化程式，对提高JAVA程式的性能时非常重要的.其注意点主要有如下几方面；
????(1) 尽可能的使用静态变量（Static Class Variables）
????如果类中的变量不会随他的实例而变化，就能定义为静态变量，从而使他所有的实例都共享这个变量。
????例：
????public class foo
????{
??????SomeObject so=new SomeObject();
????}
????就能定义为：
????public class foo
????{
??????static SomeObject so=new SomeObject();
????}
????(2) 不要对已生成的对象作过多的改动。
????对于一些类(如：String类)来讲，宁愿在重新生成一个新的对象实例，而不应该修改已生成的对象实例。
????例：
????String name="Huang";
????name="Wei";
????name="Feng";
????上述代码生成了三个String类型的对象实例。而前两个马上就需要系统进行垃圾回收处理。如果要对字符串进行连接的操作，性能将得更差，因为系统将不得为此生成更多得临时变量，如上例1所示。
????(3) 生成对象时，要分配给他合理的空间和大小JAVA中的非常多类都有他的默认的空间分配大小。对于StringBuffer类来讲，默认的分配空间大小是16个字符。如果在程式中使用StringBuffer的空间大小不是16个字符，那么就必须进行正确的初始化。
????(4) 避免生成不太使用或生命周期短的对象或变量。对于这种情况，因该定义一个对象缓冲池。以为管理一个对象缓冲池的开销要比频繁的生成和回收对象的开销小的多。
????(5) 只在对象作用范围内进行初始化。JAVA允许在代码的所有地方定义和初始化对象。这样，就能只在对象作用的范围内进行初始化。从而节约系统的开销。
????例：
????SomeObject so=new SomeObject();
????If(x==1) then
????{
??????Foo=so.getXX();
????}
????能修改为：
????if(x==1) then
????{
??????SomeObject so=new SomeObject();
??????Foo=so.getXX();
????}
????2．异常(Exceptions)
????JAVA语言中提供了try/catch来发方便用户捕捉异常，进行异常的处理。不过如果使用不当，也会给JAVA程式的性能带来影响。因此，要注意以下两点：
????(1) 避免对应用程式的逻辑使用try/catch
????如果能用if,while等逻辑语句来处理，那么就尽可能的不用try/catch语句。
????(2) 重用异常
????在必须要进行异常的处理时，要尽可能的重用已存在的异常对象。以为在异常的处理中，生成一个异常对象要消耗掉大部分的时间。
????3. 线程(Threading)
????一个高性能的应用程式中一般都会用到线程。因为线程能充分利用系统的资源。在其他线程因为等待硬盘或网络读写而 时，程式能继续处理和运行。不过对线程运用不当，也会影响程式的性能。
????例2：正确使用Vector类
????Vector主要用来保存各种类型的对象（包括相同类型和不同类型的对象）。不过在一些情况下使用会给程式带来性能上的影响。这主要是由Vector类的两个特点所决定的。第一，Vector提供了线程的安全保护功能。即使Vector类中的许多方法同步。不过如果你已确认你的应用程式是单线程，这些方法的同步就完全不必要了。第二，在Vector查找存储的各种对象时，常常要花非常多的时间进行类型的匹配。而当这些对象都是同一类型时，这些匹配就完全不必要了。因此，有必要设计一个单线程的，保存特定类型对象的类或集合来替代Vector类.用来替换的程式如下（StringVector.java）：
????public class StringVector
????{
??????private String [] data;
??????private int count;
??????public StringVector()
??????{
????????this(10); // default size is 10
??????}
??????public StringVector(int initialSize)
??????{
????????data = new String[initialSize];
??????}
??????public void add(String str)
??????{
??????// ignore null strings
??????if(str == null) { return; }
??????ensureCapacity(count + 1);
??????data[count++] = str;
??????}
??????private void ensureCapacity(int minCapacity)
??????{
????????int oldCapacity = data.length;
????????if (minCapacity oldCapacity)
????????{
??????????String oldData[] = data;
??????????int newCapacity = oldCapacity * 2;
??????????data = new String[newCapacity];
??????????System.arraycopy(oldData, 0, data, 0, count);
????????}
??????}
??????public void remove(String str)
??????{
??????if(str == null) { return; // ignore null str }
??????for(int i = 0; i count; i++)
??????{
????????// check for a match
????????if(data[i].equals(str))
????????{
??????????System.arraycopy(data,i+1,data,i,count-1); // copy data
??????????// allow previously valid array element be gc�0�7d
??????????data[--count] = null;
??????????return;
????????}
??????}
??????}
??????public final String getStringAt(int index)
??????{
??????if(index 0) { return null; }
??????else if(index count) { return null; // index is # strings }
??????else { return data[index]; // index is good }
??????}
????}
????因此，代码：
????Vector Strings=new Vector();
????Strings.add("One");
????Strings.add("Two");
????String Second=(String)Strings.elementAt(1);
????能用如下的代码替换：
????StringVector Strings=new StringVector();
????Strings.add("One");
????Strings.add("Two");
????String Second=Strings.getStringAt(1);
????这样就能通过优化线程来提高JAVA程式的性能。用于测试的程式如下（TestCollection.java）:
????import java.util.Vector;
????public class TestCollection
????{
??????public static void main(String args [])
??????{
????????TestCollection collect = new TestCollection();
????????if(args.length == 0)
????????{
??????????System.out.println("Usage: java TestCollection [ vector | stringvector ]");
??????????System.exit(1);
????????}
????????if(args[0].equals("vector"))
????????{
??????????Vector store = new Vector();
??????????long start = System.currentTimeMillis();
??????????for(int i = 0; i 1000000; i++)
??????????{
????????????store.addElement("string");
??????????}
??????????long finish = System.currentTimeMillis();
??????????System.out.println((finish-start));
??????????start = System.currentTimeMillis();
??????????for(int i = 0; i 1000000; i++)
??????????{
????????????String result = (String)store.elementAt(i);
??????????}
??????????finish = System.currentTimeMillis();
??????????System.out.println((finish-start));
????????}
????????else if(args[0].equals("stringvector"))
????????{
??????????StringVector store = new StringVector();
??????????long start = System.currentTimeMillis();
??????????for(int i = 0; i 1000000; i++) { store.add("string"); }
??????????long finish = System.currentTimeMillis();
??????????System.out.println((finish-start));
??????????start = System.currentTimeMillis();
??????????for(int i = 0; i 1000000; i++) {
????????????String result = store.getStringAt(i);
??????????}
??????????finish = System.currentTimeMillis();
??????????System.out.println((finish-start));
????????}
??????}
????}
????关于线程的操作，要注意如下几个方面：
????(1) 防止过多的同步
????如上所示，不必要的同步常常会造成程式性能的下降。因此，如果程式是单线程，则一定不要使用同步。
????(2) 同步方法而不要同步整个代码段
????对某个方法或函数进行同步比对整个代码段进行同步的性能要好。
????(3) 对每个对象使用多”锁”的机制来增大并发。
????一般每个对象都只有一个”锁”，这就表明如果两个线程执行一个对象的两个不同的同步方法时，会发生”死锁”。即使这两个方法并不共享所有资源。为了避免这个问题，能对一个对象实行”多锁”的机制。如下所示：
????class foo
????{
??????private static int var1;
??????private static Object lock1=new Object();
??????private static int var2;
??????private static Object lock2=new Object();
??????public static void increment1()
??????{
????????synchronized(lock1)
????????{
??????????var1++;
????????}
??????}
??????public static void increment2()
??????{
????????synchronized(lock2)
????????{
??????????var2++;
????????}
??????}
????}
????4．输入和输出(I/O)
????输入和输出包括非常多方面，但涉及最多的是对硬盘，网络或数据库的读写操作。对于读写操作，又分为有缓存和没有缓存的；对于数据库的操作，又能有多种类型的JDBC驱动器能选择。但无论怎样，都会给程式的性能带来影响。因此，需要注意如下几点：
????(1) 使用输入输出缓冲
????尽可能的多使用缓存。但如果要经常对缓存进行刷新（flush）,则建议不要使用缓存。
????(2) 输出流(Output Stream)和Unicode字符串
当时用Output Stream和Unicode字符串时，Write类的开销比较大。因为他要实现Unicode到字节(byte)的转换.因此，如果可能的话,在使用Write类之前就实现转换或用OutputStream类代替Writer类来使用。
????(3) 当需序列化时使用transient
当序列化一个类或对象时，对于那些原子类型（atomic）或能重建的原素要表识为transient类型。这样就不用每一次都进行序列化。如果这些序列化的对象要在网络上传输，这一小小的改动对性能会有非常大的提高。
????(4) 使用高速缓存（Cache）
对于那些经常要使用而又不大变化的对象或数据，能把他存储在高速缓存中。这样就能提高访问的速度。这一点对于从数据库中返回的结果集尤其重要。
????(5) 使用速度快的JDBC驱动器（Driver）
JAVA对访问数据库提供了四种方法。这其中有两种是JDBC驱动器。一种是用JAVA外包的本地驱动器；另一种是完全的JAVA驱动器。具体要使用哪一种得根据JAVA布署的环境和应用程式本身来定。
????5.一些其他的经验和技巧
????(1) 使用局部变量。
????(2) 避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量。
????(3) 避免在循环中生成同一个变量或调用同一个函数（参数变量也相同）。
????(4) 尽可能的使用static,final,private等关键字。
java是解释性语言，它不像C++那样直接被译为可执行的机器代码运行。而是通过虚拟机运行字节码。也就是语言运行的时候有间接性。
为什么要有虚拟机呢？因为java最重要的优势和特点之一就是可移植性。同样的字节码，配上不同的虚拟机，就能在单片机啊，PC啊，服务器等各种操作系统和硬件环境下运行。所以牺牲一点点性能是值得的。
并且，随着现在硬件水平的提高，java的性能瓶颈也被越来越缩小，所以不能说java运行速度很慢，只是适用的情况不同罢了。在大型网站，平台等的背后，java可以发挥它的用武之地，并且保持让人满意的性能。
大多数JAVA开发人员理所当然地以为性能优化很复杂，需要大量的经验和知识。
好吧，不能说这是完全错误的。
优化应用程序以获得最佳性能不是一件容易的事情。
但是，这并不意味着如果你不具备这些知识，就不能做任何事情。
这里有一些易于遵循的调优方式，青岛java培训建议可以做个参考！ 大部分建议是针对Java的。
但也有若干建议是与语言无关的，可以应用于所有应用程序和编程语言。
在讨论专门针对Java的性能调优技巧之前，让我们先来看看通用技巧。
1.在你知道必要之前不要优化 这可能是最重要的性能调整技巧之一。
你应该遵循常见的最佳实践做法并尝试高效地实现用例。
但是，这并不意味着在你证明必要之前，你应该更换任何标准库或构建复杂的优化。
在大多数情况下，过早优化不但会占用大量时间，而且会使代码变得难以阅读和维护。
更糟糕的是，这些优化通常不会带来任何好处，因为你花费大量时间来优化的是应用程序的非关键部分。
那么，你如何证明你需要优化一些东西呢? 首先，你需要定义应用程序代码的速度得多快，例如，为所有API调用指定最大响应时间，或者指定在特定时间范围内要导入的记录数量。
在完成这些之后，你就可以测量应用程序的哪些部分太慢需要改进。
然后，接着看第二个技巧。
2.使用分析器查找真正的瓶颈 在你遵循第一个建议并确定了应用程序的某些部分需要改进后，那么从哪里开始呢? 你可以用两种方法来解决问题： ·查看你的代码，并从看起来可疑或者你觉得可能会产生问题的部分开始。
·或者使用分析器并获取有关代码每个部分的行为和性能的详细信息。
希望不需要我解释为什么应该始终遵循第二种方法的原因。
很明显，基于分析器的方法可以让你更好地理解代码的性能影响，并使你能够专注于最关键的部分。
如果你曾使用过分析器，那么你一定记得曾经你是多么惊讶于一下就找到了代码的哪些部分产生了性能问题。
老实说，我第一次的猜测不止一次地导致我走错了方向。
3.为整个应用程序创建性能测试套件 这是另一个通用技巧，可以帮助你避免在将性能改进部署到生产后经常会发生的许多意外问题。
你应该总是定义一个测试整个应用程序的性能测试套件，并在性能改进之前和之后运行它。
这些额外的测试运行将帮助你识别更改的功能和性能副作用，并确保不会导致弊大于利的更新。
如果你工作于被应用程序若干不同部分使用的组件，如数据库或缓存，那么这一点就尤其重要。