java项目优化的一些方法

1.  针对日志记录的优化

关闭日志记录，或者更改日志输出级别。因为从两台服务器的外部系统D上获取到的信息是相同的，所以数据库插入操作会抛出异常，异常信息类似于“Attempt to insert duplicate record”，这样的异常信息跟有效信息的条数相等，有上千条。这种情况是能预料到的，所以可以考虑关闭日志记录，或者不关闭日志记录而是更改日志输出级别，只记录严重级别（severe level）的错误信息，并将此类操作的日志级别调整为警告级别（warning level），这样就不会记录以上异常信息了。本项目使用的是 Java 自带的日志记录类，以下配置文件将日志输出级别设置为严重级别。

清单 1. log.properties 设置日志输出级别的片段 

1 2 3 4 5

default file output is in user ’ s home directory.  levels can be: SEVERE, WARNING, INFO, FINE, FINER, FINEST    java.util.logging.ConsoleHandler.level=SEVERE    java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter    java.util.logging.FileHandler.append= true

通过上述的优化之后，性能有了大幅度的提升，从原来的 100 秒左右降到了 50 秒左右。为什么仅仅不记录日志就能有如此大幅度的性能提升呢？查阅资料，发现已经有人做了相关的研究与实验。经常听到 Java 程序比 C/C++ 程序慢的言论，但是运行速度慢的真正原因是什么，估计很多人并不清楚。对于 CPU 密集型的程序（即程序中包含大量计算），Java 程序可以达到 C/C++ 程序同等级别的速度，但是对于 I/O 密集型的程序（即程序中包含大量 I/O 操作），Java 程序的速度就远远慢于 C/C++ 程序了，很大程度上是因为 C/C++ 程序能直接访问底层的存储设备。因此，不记录日志而得到大幅度性能提升的原因是，Java 程序的 I/O 操作较慢，是一个很耗时的操作。

2.  针对数据库连接的优化

共享数据库连接。共有 5 次数据库连接操作，每次都需重新建立数据库连接，数据库插入操作完成之后又立即释放了，数据库连接没有被复用。为了做到共享数据库连接，可以通过单例模式 （Singleton Pattern）获得一个相同的数据库连接，每次数据库连接操作都共享这个数据库连接。这里没有使用数据库连接池（Database Connection Pool）是因为在程序只有少量的数据库连接操作，只有在大量并发数据库连接的时候才需要连接池。

清单 2. 共享数据库连接的代码片段 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

public class JdbcUtil {    private static Connection con;    // 从配置文件读取连接数据库的信息    private static String driverClassName;    private static String url;    private static String username;    private static String password;    private static String currentSchema;    private static Properties properties = new Properties();    static {    // driverClassName, url, username, password, currentSchema 等从配置文件读取，代码略去    try {    Class.forName(driverClassName);    } catch (ClassNotFoundException e) {    e.printStackTrace();    }    properties.setProperty( "user" , username);    properties.setProperty( "password" , password);    properties.setProperty( "currentSchema" , currentSchema);    try {    con = DriverManager.getConnection(url, properties);    } catch (SQLException e) {    e.printStackTrace();    }    }    private JdbcUtil() {}    // 获得一个单例的、共享的数据库连接    public static Connection getConnection() {    return con;    }    public static void close() throws SQLException {    if (con != null )    con.close();    }    }

通过上述的优化之后，性能有了小幅度的提升，从 50 秒左右降到了 40 秒左右。共享数据库连接而得到的性能提升的原因是，数据库连接是一个耗时耗资源的操作，需要同远程计算机进行网络通信，建立 TCP 连接，还需要维护连接状态表，建立数据缓冲区。如果共享数据库连接，则只需要进行一次数据库连接操作，省去了多次重新建立数据库连接的时间。

3.  针对插入数据库记录的优化 - 1

使用预编译 SQL。具体做法是使用 java.sql.PreparedStatement 代替 java.sql.Statement 生成 SQL 语句。PreparedStatement 使得数据库预先编译好 SQL 语句，可以传入参数。而 Statement 生成的 SQL 语句在每次提交时，数据库都需进行编译。在执行大量类似的 SQL 语句时，可以使用 PreparedStatement 提高执行效率。使用 PreparedStatement 的另一个好处是不需要拼接 SQL 语句，代码的可读性更强。通过上述的优化之后，性能有了小幅度的提升，从 40 秒左右降到了 30~35 秒左右。

清单 3. 使用 Statement 的代码片段 

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// 需要拼接 SQL 语句，执行效率不高，代码可读性不强  StringBuilder sql = new StringBuilder();  sql.append( "insert into table1(column1,column2) values('" );  sql.append(column1Value);  sql.append( "','" );  sql.append(column2Value);  sql.append( "');" );  Statement st;  try {    st = con.createStatement();    st.executeUpdate(sql.toString());  } catch (SQLException e) {    e.printStackTrace();  }

清单 4. 使用 PreparedStatement 的代码片段 

1 2 3 4 5 6

// 预编译 SQL 语句，执行效率高，可读性强  String sql = “insert into table1(column1,column2) values(?,?)”;  PreparedStatement pst = con.prepareStatement(sql);  pst.setString(1,column1Value);  pst.setString(2,column2Value);  pst.execute();

4.  针对插入数据库记录的优化 - 2

使用 SQL 批处理。通过 java.sql.PreparedStatement 的 addBatch 方法将 SQL 语句加入到批处理，这样在调用 execute 方法时，就会一次性地执行 SQL 批处理，而不是逐条执行。通过上述的优化之后，性能有了小幅度的提升，从 30~35 秒左右降到了 30 秒左右。

5.  针对多线程的优化

使用多线程实现并发 / 并行。清空数据库表的操作、把从 2 个外部系统 D 取得的数据插入数据库记录的操作，是相互独立的任务，可以给每个任务分配一个线程执行。清空数据库表的操作应该先于数据库插入操作完成，可以通过 java.lang.Thread 类的 join 方法控制线程执行的先后次序。在单核 CPU 时代，操作系统中某一时刻只有一个线程在运行，通过进程 / 线程调度，给每个线程分配一小段执行的时间片，可以实现多个进程 / 线程的并发（concurrent）执行。而在目前的多核多处理器背景下，操作系统中同一时刻可以有多个线程并行（parallel）执行，大大地提高了 计算速度。

清单 5. 使用多线程的代码片段 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Thread t0 = new Thread( new ClearTableTask());  Thread t1 = new Thread( new StoreServersTask(ADDRESS1));  Thread t2 = new Thread( new StoreServersTask(ADDRESS2));  try {    t0.start();    // 执行完清空操作后，再进行后续操作    t0.join();    t1.start();    t2.start();    t1.join();    t2.join();  } catch (InterruptedException e) {    e.printStackTrace();  }  // 断开数据库连接  try {    JdbcUtil.close();  } catch (SQLException e) {    e.printStackTrace();  }

通过上述的优化之后，性能有了大幅度的提升，从 30 秒左右降到了 15 秒以下，10~15 秒之间。使用多线程而得到的性能提升的原因是，系统部署所在的服务器是多核多处理器的，使用多线程，给每个任务分配一个线程执行，可以充分地利用 CPU 计算资源。

笔者试着给每个任务分配两个线程执行，希望能使程序运行得更快，但是事与愿违，此时程序运行的时间反而比每个任务分配一个线程执行的慢，大约 20 秒。笔者推测，这是因为线程较多（相对于 CPU 的内核数），使得 CPU 忙于线程的上下文切换，过多的线程上下文切换使得程序的性能反而不如之前。因此，要根据实际的硬件环境，给任务分配适量的线程执行。

6.  针对设计模式的优化

使用 DAO 模式抽象出数据访问层。原来的代码中混杂着 JDBC 操作数据库的代码，代码结构显得十分凌乱。使用 DAO 模式（Data Access Object Pattern）可以抽象出数据访问层，这样使得程序可以独立于不同的数据库，即便访问数据库的代码发生了改变，上层调用数据访问的代码无需改变。并且程 序员可以摆脱单调繁琐的数据库代码的编写，专注于业务逻辑层面的代码的开发。通过上述的优化之后，性能并未有提升，但是代码的可读性、可扩展性大大地提高 了。

清单 6. 使用 DAO 模式的代码片段 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// DeviceDAO.java，定义了 DAO 抽象，上层的业务逻辑代码引用该接口，面向接口编程 public interface DeviceDAO {      public void add(Device device);  }    // DeviceDAOImpl.java，DAO 实现，具体的 SQL 语句和数据库操作由该类实现 public class DeviceDAOImpl implements DeviceDAO {      private Connection con;      public DeviceDAOImpl() {          // 获得数据库连接，代码略去     }  @Override  public void add(Device device) {          // 使用 PreparedStatement 进行数据库插入记录操作，代码略去     }  }

回顾以上代码优化过程：关闭日志记录、共享数据库连接、使用预编译 SQL、使用 SQL 批处理、使用多线程实现并发 / 并行、使用 DAO 模式抽象出数据访问层，程序运行时间从最初的 100 秒左右降低到 15 秒以下，在性能上得到了很大的提升，同时也具有了更好的可读性和可扩展性。