这几天看源码弄清了一件事：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;

9. public final class Test {

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);

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;

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();

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.         }

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();

62.         try {

63.             for (String sql: sqls){

64.                 stmt.execute(sql);

65.             }

66.             t5 = System.nanoTime();

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();

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();

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

79.             t8 = System.nanoTime();

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

82.             t9 = System.nanoTime();

84.             stmt.close();

85.             conn.close();

86.             t10 = System.nanoTime();

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

89.             t11 = System.nanoTime();

90.             conn.close();

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);

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.         }

110.     }

112. }

PHP：

Php代码  

2. define('SIZE1', 10000);

3. define('SIZE2', 100);

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

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

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

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. }

18. $t2 = microtime(true);

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. }

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);

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

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

35. }

36. $t5 = microtime(true);

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);

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

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

44. $t7 = microtime(true);

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

47. $t8 = microtime(true);

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

50. $t9 = microtime(true);

52. $db->close();

53. $t10 = microtime(true);

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

56. $t11 = microtime(true);

57. $db->close();

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 -*-

3. import MySQLdb

4. from random import random

5. from time import clock

7. SIZE1 = 10000

8. SIZE2 = 100

9. DB_ENGINE = 'InnoDB' # InnoDB Memory MyISAM

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

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

13. t1 = clock()

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

16. t2 = clock()

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')

29. con.autocommit(True)

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()

41. for sql in sqls:

42.   cu.execute(sql)

43. t5 = clock()

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

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

47. t6 = clock()

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

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

51. t7 = clock()

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

54. t8 = clock()

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

57. t9 = clock()

59. cu.close()

60. con.close()

61. t10 = clock()

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

64. t11 = clock()

65. con.close()

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 -*-

3. import _mysql

4. from MySQLdb.converters import conversions

5. from random import random

6. from time import clock

8. SIZE1 = 10000

9. SIZE2 = 100

10. DB_ENGINE = 'InnoDB' # InnoDB Memory MyISAM

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

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

14. t1 = clock()

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

17. t2 = clock()

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')

28. con.autocommit(True)

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()

40. for sql in sqls:

41.   con.query(sql)

42. t5 = clock()

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()

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

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

50. t7 = clock()

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

53. t8 = clock()

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

56. t9 = clock()

58. con.close()

59. t10 = clock()

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

62. t11 = clock()

63. con.close()

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上，语言的影响基本忽略不计。

另外有需要云服务器可以了解下创新互联cdcxhl.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。

网站名称：Java、PHP、Python与MySQL交互的性能测试-创新互联
文章源于：http://hbruida.cn/article/dcpehe.html