性能测试时，tomcat配置优化

，Tomcat连接数设置（建议的设置，可根据服务器的实际性能进行更改）

在tomcat配置文件server.xml中的配置中，和连接数相关的参数有：

1 maxThreads：Tomcat使用线程来处理接收的每个请求。这个值表示Tomcat可创建的最大的线程数。portal预置值300。

2 acceptCount：指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理。portal预置值50。

3 minSpareThreads：Tomcat初始化时创建的线程数。portal预置值25。

4 maxSpareThreads：一旦创建的线程超过这个值，Tomcat就会关闭不再需要的socket线程。portal预置值75。

5 connnectionTimeout：网络连接超时，默认值60000，单位：毫秒。设置为0表示永不超时，这样设置有隐患的。portal预置值为30000毫秒。

6 maxKeepAliveRequests：保持请求数量，portal预置值100。

7  bufferSize：输入流缓冲大小，portal预置值2048 bytes。

把端口的配置替换为如下的内容，可以提高tomcat的性能，并且同时关闭tomcat的打印信息。
可以复制下面的代码进行粘贴后修改：

  <Connector port="80" maxHttpHeaderSize="8192" useBodyEncodingForURI="true"  
               maxThreads="300" minSpareThreads="25" maxSpareThreads="75"  
               enableLookups="false" redirectPort="8443" acceptCount="100"  
               compression="off" compressionMinSize="2048"   
compressableMimeType="text/html,text/xml,text/css,text/plain"  
               connectionTimeout="20000" disableUploadTimeout="true" URIEncoding="UTF-8"/>

二，如果在性能测试中发现有tomcat内存溢出的错误，就需要加大虚拟内存了。

Tomcat默认可以使用的内存为128MB,Windows下,在文件/bin/catalina.bat，Unix下，在文件/bin/catalina.sh的前面，增加如下设置：JAVA_OPTS='-Xms【初始化内存大小】-Xmx【可以使用的最大内存】'需要把这个两个参数值调大。例如：JAVA_OPTS='-Xms256m -Xmx512m'表示初始化内存为256MB，可以使用的最大内存为512MB（普通PC机作为服务器下建议用此配置）。

从实际应用的角度来说。-Xmx大了不是很好，垃圾回收需要更多的时间，但是thread问题就很大，配给JVM的内存数越大，tomcat所能开的thread数就越小，最后出现ava.lang.OutOfMemoryError: unable to create new native thread。

如果给jvm分配过多，剩余供OS使用，其中windows的dll占了一部分，但是你在JVM创建线程的时候，创建的是OS的线程，他要从剩余的空间中分配内存。如果没有可用内存，出现上述错误。

如果是刀片4核，8G内存的服务器，如果布置两个tomcat，tomcat预置值建议可以设置为JAVA_OPTS='-Xms512m –Xmx1024m'。

服务器为windows方法：找到版本库中hooks目录下，将pre-revprop-change.tmpl复制为pre-revprop-change.bat
然后修改pre-revprop-change.bat文件中最后内容为：代码:

# Here is an example hook script, for a Unix /bin/sh interpreter.# For more examples and pre-written hooks, see those in
# the Subversion repository at
# [url]http://svn.collab.net/repos/svn/trunk/tools/hook-scripts/[/url] and
# [url]http://svn.collab.net/repos/svn/trunk/contrib/hook-scripts/[/url]
rem Only allow log messages to be changed.
if "%4" == "svn:log" exit 0
echo Property '%4' cannot be changed >&2
exit 1

这样就可以修改日志了，上面最后三行的意思如下：
如果修改的是svn:log(也就是日志)则返回0,通过，如果不是，输出要修改的不能被修改返回1

Unix/Linux解决方案：
只要将文件pre-revprop-change.tmpl改名为pre-revprop-change，并加上执行权限即可。具体步骤为右键点击属性，勾选执行权限。

 1. 阅读下列代码回答问题（第一个Java程序，理解PATH和CLASSPATH，学会使用javac和java命令）

view plaincopy to clipboardprint?
package cn.edu.uibe;  
public class HelloWorld {  
    public static void main(String[] args) {  
        System.out.println("Hello World!");  
    }  
} 
package cn.edu.uibe;
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}
 

问：

（1)上面代码所在的源文件的文件名是_______________？
（2）在DOS提示符下，当前目录为该源文件所在的目录，PATH环境变量已包含编译程序所在的路径，编译目标路径为“D:\classes”，编译命令行是_____________？
（3）为了让Java解释器能够找到编译后的类文件，需要如何设置环境变量___________？
（4）在正确设置了相关的环境变量之后，运行HelloWorld类的命令行是____________?

答案：

（1）HelloWorld.java，公共类必须定义在和类名同名的文件中，文件名区分大小写。

（2）javac -d D:\classes HelloWorld.java ，-d给出输出目录，javac会在D:\classes创建包的目录层次结构cn\edu\uibe\HelloWorld.class

（3）set CLASSPATH=.;D:\classses，CLASSSPATH给出Java寻找.class文件的多个路径，路径之间用分号分隔，“.”表示当前路径。

（4）java cn.edu.uibe.HelloWorld，注意需要给出包名，类名后面不要加“.class”。

2. 阅读下列代码回答问题（关于private的理解）

view plaincopy to clipboardprint?
public class Light {  
    private int brightness = 5;  
    public void brighten(Light another){  
        another.brightness++;  
    }  
    public static void main(String[] args) {  
        Light light1 = new Light();  
        Light light2 = new Light();  
        light1.brighten(light2);  
    }  
} 
public class Light {
 private int brightness = 5;
 public void brighten(Light another){
  another.brightness++;
 }
 public static void main(String[] args) {
  Light light1 = new Light();
  Light light2 = new Light();
  light1.brighten(light2);
 }
}
 

问：上面代码Java编译器是否会给出错误提示？为什么？

答案：不会出现错误提示，private限制了私有变量只能被同一个类访问，但是没有限制同一个类的不同对象之间互相访问私有变量。实际上，private是在编译时进行检查，如果想限制同类对象之间互相访问，需要在动态运行时实现，开销较大，而且没有必要。

3. 阅读下列代码回答问题（关于多态性的理解）

view plaincopy to clipboardprint?
class Base {  
    int i=1;  
    void f(){  
        System.out.println("Base.f()");  
    }  
    void g(){  
    f(); //会调用上面的f()方法吗？  
    }  
}  
public class Derived extends Base { //继承了Base类  
    int i=2; //Derived类的对象有1个i还是2个i呢？ 答：2个  
    void f(){ //覆盖override了f()方法  
        System.out.println("Derived.f()");  
    }  
    public static void main(String[] args) {  
        Derived d = new Derived(); //创建子类对象  
        Base b = d; //没有创建对象，仅仅是父类引用指向了子类对象  
        d.f(); //将会输出Derived.f()  
        b.f(); //也会输出Derived.f()，方法具有多态性  
        System.out.println(d.i); //输出的是2，d.i访问子类中定义的变量i  
        System.out.println(b.i); //输出的是1，b.i访问的是父类中定义的变量i，成员变量是不会动态绑定而表现出多态性的。        
        d.g(); //输出Derived.f()  
        b.g(); //也输出Derived.f()，从父类中调用被覆盖的方法f()，也将调用到子类中更具体的方法。  
    }  
} 
class Base {
    int i=1;
    void f(){
        System.out.println("Base.f()");
    }
    void g(){
 f(); //会调用上面的f()方法吗？
    }
}
public class Derived extends Base { //继承了Base类
    int i=2; //Derived类的对象有1个i还是2个i呢？ 答：2个
    void f(){ //覆盖override了f()方法
        System.out.println("Derived.f()");
    }
    public static void main(String[] args) {
        Derived d = new Derived(); //创建子类对象
        Base b = d; //没有创建对象，仅仅是父类引用指向了子类对象
        d.f(); //将会输出Derived.f()
        b.f(); //也会输出Derived.f()，方法具有多态性
        System.out.println(d.i); //输出的是2，d.i访问子类中定义的变量i
        System.out.println(b.i); //输出的是1，b.i访问的是父类中定义的变量i，成员变量是不会动态绑定而表现出多态性的。  
        d.g(); //输出Derived.f()
        b.g(); //也输出Derived.f()，从父类中调用被覆盖的方法f()，也将调用到子类中更具体的方法。
    }
}
 

问： 写出上面代码的输出？

答案：参见代码注释，子类和父类中定义同名的变量时，仅仅是隐藏了，变量没有多态性；而对于覆盖的方法，Java表现出多态性，

会调用更具体的子类里面的方法，无论从哪里调用，无论使用什么引用类型调用。

4.阅读下列代码回答问题（关于匿名内部类的理解）

view plaincopy to clipboardprint?
interface A {  
    void f();  
}  
public class B {  
    public void f(A a) {  
    }  
    public static void main(String[] args) {  
        B b= new B();  
        b.f(new A() {  
            public void f() {  
            }  
        });  
    }  
} 
interface A {
    void f();
}
public class B {
    public void f(A a) {
    }
    public static void main(String[] args) {
        B b= new B();
        b.f(new A() {
            public void f() {
            }
        });
    }
}
 

问：请解释语句
b.f(new A() {
    public void f() {
    }
});
的含义与作用。

答案：

   这个语句在参数表中定义了一个匿名内部类，这个匿名内部类实现了接口A，实例化了一个匿名内部类的对象，并将这个对象传递给了接收接口A作为参数的方法f(A a)。需要注意的是接口A中的方法f()和类B中的方法f(A a)没有任何关系，是不同的方法。

5. 阅读下列代码回答问题（关于static的理解）

view plaincopy to clipboardprint?
public class Static {  
    static int i = 0;  
    int j=0;  
    public static void main(String[] args) {  
        Static s1 = new Static();  
        Static s2 = new Static();  
        s1.i++;  
        s2.i++;  
        s1.j++;  
        s2.j++;  
        System.out.println(s1.i);  
        System.out.println(s1.j);  
        System.out.println(s2.i);  
        System.out.println(s2.j);  
}  
} 
public class Static {
 static int i = 0;
 int j=0;
 public static void main(String[] args) {
  Static s1 = new Static();
  Static s2 = new Static();
  s1.i++;
  s2.i++;
  s1.j++;
  s2.j++;
  System.out.println(s1.i);
  System.out.println(s1.j);
  System.out.println(s2.i);
  System.out.println(s2.j);
}
}
 

问：写出上面代码的输出。

答案： 2 1 2 1，i是静态变量，类的所有实例共享同一个i，通常我们不通过引用变量访问静态变量，而是通过类名访问Static.i，注意Static是我们自己定义的类名，而小写的static是关键字，表示静态的，为类的所有实例共享的变量或方法。j是实例变量，每个对象具有不同的，属于其自身的一个变量j。

6. 阅读下列代码回答问题（关于引用变量的理解）

view plaincopy to clipboardprint?
class Counter{  
    int i=0;  
}  
public class Reference {  
    public void plus(int i){  
        i++; //不会改变传递进来的参数的值,Java传递基本类型时进行了值的拷贝  
    }  
    public void plus(Counter c){  
        c.i++; //会改变，因为c是一个引用变量，相当于指针  
    }  
    public void create(Counter c){  
        c = new Counter();   
                  c.i++; //不会改变，因为c执行了另外一个新建的对象  
    }     
    public static void main(String[] args) {  
        int i = 0;  
        Reference r = new Reference();  
        Counter c1 = new Counter();  
        Counter c2 = new Counter();       
        r.plus(i);  
        r.plus(c1);  
        r.create(c2);         
        System.out.println(i);  
        System.out.println(c1.i);  
        System.out.println(c2.i);  
    }  
} 
class Counter{
 int i=0;
}
public class Reference {
 public void plus(int i){
  i++; //不会改变传递进来的参数的值,Java传递基本类型时进行了值的拷贝
 }
 public void plus(Counter c){
  c.i++; //会改变，因为c是一个引用变量，相当于指针
 }
 public void create(Counter c){
  c = new Counter();
                  c.i++; //不会改变，因为c执行了另外一个新建的对象
 } 
 public static void main(String[] args) {
  int i = 0;
  Reference r = new Reference();
  Counter c1 = new Counter();
  Counter c2 = new Counter();  
  r.plus(i);
  r.plus(c1);
  r.create(c2);  
  System.out.println(i);
  System.out.println(c1.i);
  System.out.println(c2.i);
 }
}
 

问：上面代码输出是？

答案：参考代码注释，输出应该是：0 1 0

7. 阅读下列代码回答问题（关于异常的理解）

view plaincopy to clipboardprint?
class MyException extends Exception{  
    public MyException(String message){  
        super(message);  
    }  
}  
public class ExceptionDemo{  
    public void f(int num) throws MyException {  
        if(num<0){  
            throw new MyException("参数不能为负数！");  
        }  
        System.out.println(num);  
        }  
    public void g(){  
        try{  
            f(1);  
            f(3);  
            f(0);  
            f(-1);  
            f(2);  
            f(-5);  
        }catch(MyException e){  
            System.err.println(e.getMessage());  
            return;//会立即返回吗？答：不会！  
        }finally{  
           System.out.println("无论什么时候！");     
        }  
    }  
    public static void main(String[] args) {  
        ExceptionDemo demo = new ExceptionDemo();  
        demo.g();  
    }  
} 
class MyException extends Exception{
 public MyException(String message){
  super(message);
 }
}
public class ExceptionDemo{
 public void f(int num) throws MyException {
  if(num<0){
   throw new MyException("参数不能为负数！");
  }
  System.out.println(num);
  }
 public void g(){
  try{
   f(1);
   f(3);
   f(0);
   f(-1);
   f(2);
   f(-5);
  }catch(MyException e){
   System.err.println(e.getMessage());
   return;//会立即返回吗？答：不会！
  }finally{
     System.out.println("无论什么时候！"); 
  }
 }
 public static void main(String[] args) {
  ExceptionDemo demo = new ExceptionDemo();
  demo.g();
 }
}
 

问：上面代码输出是？

答案：输出是：1 3 0 参数不能为负数! 无论什么时候!

try语句块里面的一行代码抛出了异常，后续代码就不再执行了，而是转到catch开始匹配异常类型。finally语句块里面的代码始终会被执行，即使在catch语句块里面有行return语句也不会立即返回，Java确保finally语句块执行完函数才会返回。