中文字幕av专区_日韩电影在线播放_精品国产精品久久一区免费式_av在线免费观看网站

溫馨提示×

溫馨提示×

您好,登錄后才能下訂單哦!

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

Java、PHP、Python與MySQL交互的性能測試

發布時間:2020-07-06 21:25:18 來源:網絡 閱讀:1448 作者:觸龍 欄目:數據庫

這幾天看源碼弄清了一件事: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代碼  Java、PHP、Python與MySQL交互的性能測試

  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代碼  Java、PHP、Python與MySQL交互的性能測試

  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代碼  Java、PHP、Python與MySQL交互的性能測試

  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代碼  Java、PHP、Python與MySQL交互的性能測試

  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上,語言的影響基本忽略不計。


向AI問一下細節

免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。

AI

额敏县| 双牌县| 大英县| 东丽区| 桂林市| 平武县| 曲松县| 大渡口区| 博白县| 玉林市| 咸宁市| 西峡县| 佛冈县| 梧州市| 新巴尔虎左旗| 新建县| 布尔津县| 宣恩县| 奉化市| 榕江县| 孝义市| 徐汇区| 和平县| 会宁县| 汕头市| 大新县| 和林格尔县| 邹城市| 来宾市| 南昌市| 建昌县| 扶沟县| 北京市| 文水县| 巴林左旗| 伊春市| 东光县| 扎兰屯市| 玉屏| 赫章县| 林州市|