这几天看源码弄清了一件事: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上,语言的影响基本忽略不计。