这几天看源码弄清了一件事：WEB服务器接收浏览器请求、将请求传给PHP/Python进程（FCGI等）、与数据库进行交互都是用socket（套接字）。 
也就是说，这些行为都是进程间通信。一台WEB服务器在硬件、操作系统不变的情况下，它的性能主要取决于socket通信的速度。如果所有进程都在一台服务器上的话，这个速度就取决于通信的效率了。 

例如与MySQL数据库交互时，程序会调用驱动程序来访问数据库，这个驱动程序主要做这几件事： 



1.创建socket，连接到MySQL。 

2.将程序调用的API翻译成SQL语句，通过socket发送给MySQL；MySQL执行后，将结果发送回来；驱动程序将结果（字符串）传给程序，如有需要，还可以自动翻译成程序能识别的变量类型（如整型）。 

3.断开连接。 


可见连接的速度、翻译的速度和接受响应的及时性是最主要的3个方面。 

弄明白这点后就不难发现，与数据库的执行时间相比，这些只是很少的一部分；而且PHP和Python使用的都是C实现，而JDBC是用Java实现，所以根本不必担心PHP和Python的性能。 
不过在翻译方面还存在算法和实现上的差异，客户端还可以缓存一些语句，所以仍然会出现一些性能上的差异。 
为证明我的想法，我特意去测试了一番。 

首先列出测试平台： 

引用

CPU：Intel Core2 Duo T9400 @ 2.53GHz 
内存：3GB 
操作系统：Windows XP Pro SP2 
MySQL：5.1.36 
Java：1.6.0_17-b04 
JDBC：MySQL Connector/J 5.1.10 
PHP：5.2.11 (cli) 
MySQLi：5.2.11.11 
Python：2.6.4 
MySQL-Python：1.2.3c1 

所用的库都是最新版的，也都采用了最为推荐的库。 
但数据库并没有使用最新的稳定版，因为我懒得重下了。5.4.3-beta测试版也试过，在连续插入时，性能比5.1快1～2个数量级，估计是服务器端缓存和设置的原因。 

测试项目： 



1.创建100万个随机数，并生成插入这些随机数的SQL语句。 

2.连接本地数据库，如不成功，尝试创建数据库。 

3.删除并创建数据库表，引擎类型为InnoDB，主键为自动递增的整数，此外有个浮点型的字段（无索引）。 

4.分成100组，每次插入1万个随机数。（因为每组的执行量都很大，因此启用自动提交事务。） 

5.用SELECT COUNT(*)统计小于0.1的随机数个数。（约10万个） 

6.用SELECT *取出再统计大于0.9的随机数个数。（约10万个） 

7.将所有0.4～0.5之间的随机数加1。（约10万个） 

8.将所有0.5～0.6之间的行删除。（约20万个） 

9.断开数据库连接。 

10.再次连接数据库。 



测试代码： 

Java： 

Java代码  

1. import java.sql.Connection;  

2. import java.sql.DriverManager;  

3. import java.sql.SQLException;  

4. import java.sql.Statement;  

5. import java.sql.ResultSet;  

6. import java.util.Random;  

7.   

8.   

9. public final class Test {  

10.   

11.     public static void main(String[] args) {  

12.         final int SIZE1 = 10000;  

13.         final int SIZE2 = 100;  

14.         final String DB_ENGINE = "InnoDB"; // InnoDB Memory MyISAM  

15.         final double NANO_TIME_PER_SEC = 1000000000.0;  

16.         System.out.printf("测试数据量：%d\n", SIZE1 * SIZE2);  

17.         System.out.printf("测试引擎：%s\n", DB_ENGINE);  

18.           

19.         long t1 = System.nanoTime(), t2, t3 = 0, t4, t5, t6, t7, t8, t9, t10, t11;  

20.         Connection conn = null;  

21.         Statement stmt = null;  

22.         ResultSet rs = null;  

23.           

24.         Random r = new Random();  

25.         String[] sqls = new String[SIZE2];  

26.         for (int i = 0; i < SIZE2; ++i){  

27.             StringBuilder buffer = new StringBuilder("INSERT INTO test (value) VALUES (");  

28.             for (int j = 0; j < SIZE1; ++j){  

29.                 buffer.append(r.nextDouble()).append("),(");  

30.             }  

31.             sqls[i] = buffer.substring(0, buffer.length() -2);  

32.         }  

33.         t2 = System.nanoTime();  

34.           

35.         try {  

36.             conn = DriverManager.getConnection("jdbc:mysql://localhost/testdb?user=root&password=123456");  

37.             t3 = System.nanoTime();  

38.             stmt = conn.createStatement();  

39.         } catch (SQLException e) {  

40.             try {  

41.                 conn = DriverManager.getConnection("jdbc:mysql://localhost/?user=root&password=123456");  

42.                 t3 = System.nanoTime();  

43.                 stmt = conn.createStatement();  

44.                 stmt.execute("CREATE DATABASE testdb");  

45.             } catch (SQLException ex) {  

46.                 System.out.println("SQLException: " + ex.getMessage());  

47.                 System.out.println("SQLState: " + ex.getSQLState());  

48.                 System.out.println("VendorError: " + ex.getErrorCode());  

49.             }  

50.         }  

51.           

52.         try {  

53.             stmt.execute("DROP TABLE test");  

54.         } catch (SQLException e) {  

55.         }  

56.         try {  

57.             stmt.execute("CREATE TABLE test (`id` INT AUTO_INCREMENT PRIMARY KEY, `value` REAL) ENGINE = " + DB_ENGINE);  

58.         } catch (SQLException e) {  

59.         }  

60.         t4 = System.nanoTime();  

61.           

62.         try {  

63.             for (String sql: sqls){  

64.                 stmt.execute(sql);  

65.             }  

66.             t5 = System.nanoTime();  

67.   

68.             rs = stmt.executeQuery("SELECT COUNT(*) FROM test WHERE value < 0.1");  

69.             if (rs.next())  

70.                 System.out.printf("共有%d个小于0.1的随机数\n", rs.getInt(1));  

71.             t6 = System.nanoTime();  

72.   

73.             rs = stmt.executeQuery("SELECT * FROM test WHERE value > 0.9");  

74.             if (rs.last())  

75.                 System.out.printf("共有%d个大于0.9的随机数\n", rs.getRow());  

76.             t7 = System.nanoTime();  

77.   

78.             stmt.executeUpdate("UPDATE test SET value = value + 0.1 WHERE value > 0.4 AND value < 0.5");  

79.             t8 = System.nanoTime();  

80.   

81.             stmt.execute("DELETE FROM test WHERE value > 0.5 AND value < 0.6");  

82.             t9 = System.nanoTime();  

83.   

84.             stmt.close();  

85.             conn.close();  

86.             t10 = System.nanoTime();  

87.               

88.             conn = DriverManager.getConnection("jdbc:mysql://localhost/?user=root&password=123456");  

89.             t11 = System.nanoTime();  

90.             conn.close();  

91.   

92.             System.out.printf("创建随机数：%f\n", (t2 - t1) / NANO_TIME_PER_SEC);  

93.             System.out.printf("初次连接数据库：%f\n", (t3 - t2) / NANO_TIME_PER_SEC);  

94.             System.out.printf("再次连接数据库：%f\n", (t11 - t10) / NANO_TIME_PER_SEC);  

95.             System.out.printf("初始化数据库和表：%f\n", (t4 - t3) / NANO_TIME_PER_SEC);  

96.             System.out.printf("插入：%f\n", (t5 - t4) / NANO_TIME_PER_SEC);  

97.             System.out.printf("选择（COUNT）：%f\n", (t6 - t5) / NANO_TIME_PER_SEC);  

98.             System.out.printf("选择：%f\n", (t7 - t6) / NANO_TIME_PER_SEC);  

99.             System.out.printf("更新：%f\n", (t8 - t7) / NANO_TIME_PER_SEC);  

100.             System.out.printf("删除：%f\n", (t9 - t8) / NANO_TIME_PER_SEC);  

101.             System.out.printf("关闭连接：%f\n", (t10 - t9) / NANO_TIME_PER_SEC);  

102.             System.out.printf("总时间：%f\n", (t10 - t1) / NANO_TIME_PER_SEC);  

103.               

104.         } catch (SQLException ex) {  

105.             System.out.println("SQLException: " + ex.getMessage());  

106.             System.out.println("SQLState: " + ex.getSQLState());  

107.             System.out.println("VendorError: " + ex.getErrorCode());  

108.         }  

109.   

110.     }  

111.   

112. }  

PHP： 

Php代码  

1. <?php  

2. define(‘SIZE1‘, 10000);  

3. define(‘SIZE2‘, 100);  

4. define(‘DB_ENGINE‘, ‘InnoDB‘); // InnoDB Memory MyISAM  

5.   

6. printf("测试数据量：%d\n", SIZE1 * SIZE2);  

7. printf("测试引擎：%s\n", DB_ENGINE);  

8.   

9. $t1 = microtime(true);  

10. for ($i = 0; $i < SIZE2; ++$i){  

11.     for ($j = 0; $j < SIZE1; ++$j){  

12.         $buffer[] = lcg_value();  

13.     }  

14.     $sqls[$i] = ‘INSERT INTO test (value) VALUES (‘.join(‘),(‘, $buffer).‘)‘;  

15.     unset($buffer);  

16. }  

17.   

18. $t2 = microtime(true);  

19.   

20. $db = new mysqli(‘localhost‘, ‘root‘, ‘123456‘, ‘testdb‘);  

21. $t3 = microtime(true);  

22. if (mysqli_connect_errno()) {  

23.     $db = new mysqli(‘localhost‘, ‘root‘, ‘123456‘);  

24.     $t3 = microtime(true);  

25.     $db->query(‘CREATE DATABASE testdb‘);  

26.     $db->select_db(‘testdb‘);  

27. }  

28.   

29. $db->query(‘DROP TABLE test‘);  

30. $db->query(‘CREATE TABLE test (`id` INT AUTO_INCREMENT PRIMARY KEY, `value` REAL) ENGINE = ‘.DB_ENGINE);  

31. $t4 = microtime(true);  

32.   

33. foreach ($sqls as $key=>$sql) {  

34.     $db->query($sql);  

35. }  

36. $t5 = microtime(true);  

37.   

38. $result = $db->query(‘SELECT COUNT(*) FROM test WHERE value < 0.1‘)->fetch_row();  

39. printf("共有%d个小于0.1的随机数\n", $result[0]);  

40. $t6 = microtime(true);  

41.   

42. $result = $db->query(‘SELECT * FROM test WHERE value > 0.9‘);  

43. printf("共有%d个大于0.9的随机数\n", $result->num_rows);  

44. $t7 = microtime(true);  

45.   

46. $db->query(‘UPDATE test SET value = value + 0.1 WHERE value > 0.4 AND value < 0.5‘);  

47. $t8 = microtime(true);  

48.   

49. $db->query(‘DELETE FROM test WHERE value > 0.5 AND value < 0.6‘);  

50. $t9 = microtime(true);  

51.   

52. $db->close();  

53. $t10 = microtime(true);  

54.   

55. $db = new mysqli(‘localhost‘, ‘root‘, ‘123456‘, ‘testdb‘);  

56. $t11 = microtime(true);  

57. $db->close();  

58.   

59. printf("创建随机数：%f\n", $t2 - $t1);  

60. printf("初次连接数据库：%f\n", $t3 - $t2);  

61. printf("再次连接数据库：%f\n", $t11 - $t10);  

62. printf("初始化数据库和表：%f\n", $t4 - $t3);  

63. printf("插入：%f\n", $t5 - $t4);  

64. printf("选择（COUNT）：%f\n", $t6 - $t5);  

65. printf("选择：%f\n", $t7 - $t6);  

66. printf("更新：%f\n", $t8 - $t7);  

67. printf("删除：%f\n", $t9 - $t8);  

68. printf("关闭连接：%f\n", $t10 - $t9);  

69. printf("总时间：%f\n", $t10 - $t1);  

70. ?>  

Python： 

Python代码  

1. # -*- coding: gbk -*-  

2.   

3. import MySQLdb  

4. from random import random  

5. from time import clock  

6.   

7. SIZE1 = 10000  

8. SIZE2 = 100  

9. DB_ENGINE = ‘InnoDB‘ # InnoDB Memory MyISAM  

10. print ‘测试数据量：‘, SIZE1 * SIZE2  

11. print ‘测试引擎：‘, DB_ENGINE  

12.   

13. t1 = clock()  

14.   

15. sqls = [‘INSERT INTO test (value) VALUES (%s)‘ % ‘),(‘.join([`random()` for i in xrange(SIZE1)]) for j in xrange(SIZE2)]  

16. t2 = clock()  

17.   

18. try:  

19.   con = MySQLdb.connect(user=‘root‘, passwd=‘123456‘, db=‘testdb‘)  

20.   t3 = clock()  

21.   cu = con.cursor()  

22. except:  

23.   con = MySQLdb.connect(user=‘root‘, passwd=‘123456‘)  

24.   t3 = clock()  

25.   cu = con.cursor()  

26.   cu.execute(‘CREATE DATABASE testdb‘)  

27.   con.select_db(‘testdb‘)  

28.   

29. con.autocommit(True)  

30.   

31. try:  

32.   cu.execute(‘DROP TABLE test‘)  

33. except:  

34.   pass  

35. cu.execute(‘‘‘‘‘CREATE TABLE test ( 

36. `id` INT AUTO_INCREMENT PRIMARY KEY, 

37. `value` REAL) 

38. ENGINE = %s‘‘‘ % DB_ENGINE)  

39. t4 = clock()  

40.   

41. for sql in sqls:  

42.   cu.execute(sql)  

43. t5 = clock()  

44.   

45. cu.execute(‘SELECT COUNT(*) FROM test WHERE value < 0.1‘)  

46. print ‘共有%d个小于0.1的随机数‘ % cu.fetchone()[0]  

47. t6 = clock()  

48.   

49. cu.execute(‘SELECT * FROM test WHERE value > 0.9‘)  

50. print ‘共有%d个大于0.9的随机数‘ % len(cu.fetchall())  

51. t7 = clock()  

52.   

53. cu.execute(‘UPDATE test SET value = value + 0.1 WHERE value > 0.4 AND value < 0.5‘)  

54. t8 = clock()  

55.   

56. cu.execute(‘DELETE FROM test WHERE value > 0.5 AND value < 0.6‘)  

57. t9 = clock()  

58.   

59. cu.close()  

60. con.close()  

61. t10 = clock()  

62.   

63. con = MySQLdb.connect(user=‘root‘, passwd=‘123456‘, db=‘testdb‘)  

64. t11 = clock()  

65. con.close()  

66.   

67. print ‘创建随机数：‘, t2 - t1  

68. print ‘初次连接数据库：‘, t3 - t2  

69. print ‘再次连接数据库：‘, t11 - t10  

70. print ‘初始化数据库：‘, t4 - t3  

71. print ‘插入：‘, t5 - t4  

72. print ‘选择（COUNT）‘, t6 - t5  

73. print ‘选择：‘, t7 - t6  

74. print ‘更新：‘, t8 - t7  

75. print ‘删除：‘, t9 - t8  

76. print ‘关闭连接：‘, t10 - t9  

77. print ‘总时间：‘, t10 - t1  

MySQL-Python还有个底层的模块，一并测试下： 

Python代码  

1. # -*- coding: gbk -*-  

2.   

3. import _mysql  

4. from MySQLdb.converters import conversions  

5. from random import random  

6. from time import clock  

7.   

8. SIZE1 = 10000  

9. SIZE2 = 100  

10. DB_ENGINE = ‘InnoDB‘ # InnoDB Memory MyISAM  

11. print ‘测试数据量：‘, SIZE1 * SIZE2  

12. print ‘测试引擎：‘, DB_ENGINE  

13.   

14. t1 = clock()  

15.   

16. sqls = [‘INSERT INTO test (value) VALUES (%s)‘ % ‘),(‘.join([`random()` for i in xrange(SIZE1)]) for j in xrange(SIZE2)]  

17. t2 = clock()  

18.   

19. try:  

20.   con = _mysql.connect(user=‘root‘, passwd=‘123456‘, db=‘testdb‘, conv=conversions)  

21.   t3 = clock()  

22. except:  

23.   con = _mysql.connect(user=‘root‘, passwd=‘123456‘, conv=conversions)  

24.   t3 = clock()  

25.   con.query(‘CREATE DATABASE testdb‘)  

26.   con.select_db(‘testdb‘)  

27.   

28. con.autocommit(True)  

29.   

30. try:  

31.   con.query(‘DROP TABLE test‘)  

32. except:  

33.   pass  

34. con.query(‘‘‘‘‘CREATE TABLE test ( 

35. `id` INT AUTO_INCREMENT PRIMARY KEY, 

36. `value` REAL) 

37. ENGINE = %s‘‘‘ % DB_ENGINE)  

38. t4 = clock()  

39.   

40. for sql in sqls:  

41.   con.query(sql)  

42. t5 = clock()  

43.   

44. con.query(‘SELECT COUNT(*) FROM test WHERE value < 0.1‘)  

45. print ‘共有%d个小于0.1的随机数‘ % con.store_result().fetch_row()[0]  

46. t6 = clock()  

47.   

48. con.query(‘SELECT * FROM test WHERE value > 0.9‘)  

49. print ‘共有%d个大于0.9的随机数‘ % con.store_result().num_rows()  

50. t7 = clock()  

51.   

52. con.query(‘UPDATE test SET value = value + 0.1 WHERE value > 0.4 AND value < 0.5‘)  

53. t8 = clock()  

54.   

55. con.query(‘DELETE FROM test WHERE value > 0.5 AND value < 0.6‘)  

56. t9 = clock()  

57.   

58. con.close()  

59. t10 = clock()  

60.   

61. con = _mysql.connect(user=‘root‘, passwd=‘123456‘, db=‘testdb‘, conv=conversions)  

62. t11 = clock()  

63. con.close()  

64.   

65. print ‘创建随机数：‘, t2 - t1  

66. print ‘初次连接数据库：‘, t3 - t2  

67. print ‘再次连接数据库：‘, t11 - t10  

68. print ‘初始化数据库：‘, t4 - t3  

69. print ‘插入：‘, t5 - t4  

70. print ‘选择（COUNT）‘, t6 - t5  

71. print ‘选择：‘, t7 - t6  

72. print ‘更新：‘, t8 - t7  

73. print ‘删除：‘, t9 - t8  

74. print ‘关闭连接：‘, t10 - t9  

75. print ‘总时间：‘, t10 - t1  

每种测试3次（等硬盘灯无闪烁后才进行下一次测试），取最好的一次作为测试结果： 
Java： 

引用

测试数据量：1000000 
测试引擎：InnoDB 
共有99465个小于0.1的随机数 
共有99859个大于0.9的随机数 
创建随机数：2.367840 
初次连接数据库：0.220420 
再次连接数据库：0.013174 
初始化数据库和表：0.075140 
插入：12.139346 
选择（COUNT）：1.130345 
选择：1.017769 
更新：6.173245 
删除：9.380070 
关闭连接：0.002131 
总时间：32.506307

PHP： 

引用

测试数据量：1000000 
测试引擎：InnoDB 
共有99898个小于0.1的随机数 
共有100152个大于0.9的随机数 
创建随机数：1.506294 
初次连接数据库：0.003146 
再次连接数据库：0.001808 
初始化数据库和表：0.131754 
插入：12.046944 
选择（COUNT）：1.236742 
选择：1.238153 
更新：6.115232 
删除：8.145547 
关闭连接：0.000125 
总时间：30.423937

Python（MySQLdb）： 

引用

测试数据量： 1000000 
测试引擎： InnoDB 
共有100040个小于0.1的随机数 
共有100351个大于0.9的随机数 
创建随机数： 1.6822107279 
初次连接数据库： 0.0332120423126 
再次连接数据库： 0.00221704155137 
初始化数据库： 0.131054924578 
插入： 11.7999030603 
选择（COUNT） 1.27067266929 
选择： 1.16714526567 
更新： 6.29200638629 
删除： 8.13660563005 
关闭连接： 0.000131022238861 
总时间： 30.5129417286

Python（_mysql）： 

引用

测试数据量： 1000000 
测试引擎： InnoDB 
共有99745个小于0.1的随机数 
共有99869个大于0.9的随机数 
创建随机数： 1.68099074044 
初次连接数据库： 0.0112056141213 
再次连接数据库： 0.00159293988482 
初始化数据库： 0.130169616529 
插入： 12.1364623157 
选择（COUNT） 1.125517908 
选择： 0.968366649951 
更新： 6.8042843434 
删除： 8.9760508668 
关闭连接： 9.61015995031e-05 
总时间： 31.8331441566

可以看到，在大批量数据测试中，Java是最慢的，而PHP是最快的。 
不考虑IO性能的波动的话，Java主要慢在连接和关闭数据库。JDBC 4.0在第一次连接数据库时会动态加载驱动，非常耗时，因此使用Java要记住使用数据库连接池，避免连接浪费大量时间。当然，这也造成了数据库的负担，势必影响内存占用。而创建随机数的算法实现各不相同，所以不具备可比性；令我惊讶的是SELECT的翻译速度，将字符串转换成浮点数居然慢于Python，要知道后者的浮点数可是对象。 
PHP连接数据库非常快，所以完全无需使用连接池，因为维护连接池会增加复杂性。 
Python的表现和PHP差不多，但是第一次连接数据库比较慢（仍比Java快1个数量级）。如果不用连接池，则使用FCGI等方式来运行比较合适。_mysql模块的通信很快，但更新和删除操作却不太理想，也许是IO性能波动的原因。此外，我在连接数据库时使用了转换参数，实际上我用的语句都不需要翻译，不使用的话会更快一点。 

接着试试小数据，改成最常用的MyISAM引擎，插入100条（1组）。一般的应用不可能一次插入那么多，所以足够满足平时的应用了；而且由于数据量很小，也基本不受IO影响。 

测试结果： 

Java： 

引用

测试数据量：100 
测试引擎：MyISAM 
共有9个小于0.1的随机数 
共有10个大于0.9的随机数 
创建随机数：0.001596 
初次连接数据库：0.224135 
再次连接数据库：0.018656 
初始化数据库和表：0.055601 
插入：0.001476 
选择（COUNT）：0.000529 
选择：0.000433 
更新：0.000304 
删除：0.000313 
关闭连接：0.000927 
总时间：0.285314

PHP： 

引用

测试数据量：测试数据量：100 
测试引擎：MyISAM 
共有12个小于0.1的随机数 
共有9个大于0.9的随机数 
创建随机数：0.000649 
初次连接数据库：0.008077 
再次连接数据库：0.001609 
初始化数据库和表：0.060421 
插入：0.001860 
选择（COUNT）：0.000580 
选择：0.000465 
更新：0.000326 
删除：0.000373 
关闭连接：0.000127 
总时间：0.072878

Python（MySQLdb）： 

引用

测试数据量： 100 
测试引擎： MyISAM 
共有14个小于0.1的随机数 
共有9个大于0.9的随机数 
创建随机数： 0.000198907961766 
初次连接数据库： 0.0334640296462 
再次连接数据库： 0.00150577796899 
初始化数据库： 0.0123194428342 
插入： 0.00125211444471 
选择（COUNT） 0.000581079438867 
选择： 0.000484139744018 
更新： 0.000250311142897 
删除： 0.000262323842835 
关闭连接： 7.98984228442e-05 
总时间： 0.0488922474784

Python（_mysql）： 

引用

测试数据量： 100 
测试引擎： MyISAM 
共有12个小于0.1的随机数 
共有10个大于0.9的随机数 
创建随机数： 0.000214273043082 
初次连接数据库： 0.0118774872225 
再次连接数据库： 0.00123702872851 
初始化数据库： 0.0315031659052 
插入： 0.00120322554962 
选择（COUNT） 0.000596165155069 
选择： 0.000507327048549 
更新： 0.0002447238406 
删除： 0.00026148574749 
关闭连接： 5.78285787719e-05 
总时间： 0.0464656820909

从结果可以看出，虽然差距都很小，但Python仍然稍微占优。不过Java的SELECT操作稍微胜出，而这也是实际应用中最常使用的操作。 
再从语言方面来看，Python无疑是写得最欢畅的，生成随机数只用了1行代码；PHP的变量要写个$让我老是出错，不过数据库操作不需要处理异常，这点节省了很多代码；Java的代码量很大，而且不得不使用很多try...catch，我甚至懒得以安全的方式将close()放在finally块里面，因为它也会抛出我根本懒得去管的异常，且会提示我计时变量可能没有初始化。 

总体上来看，Google放弃Python，只采用C++和Java是有点不明智。因为页面响应时间主要在于数据库通信和磁盘文件IO上，语言的影响基本忽略不计。

Java、PHP、Python与MySQL交互的性能测试