DB Tuning

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • DB Tuning

    Hi

    Ich hab hier ne Anwendung, die ne Liste mit Objekten generiert.
    Diese Liste möchte ich nun in eine Datenbank abspeichern.

    Eigentlich auch kein großes Problem

    Quellcode

    1. for(int i = 0; i < list.size(); i++){
    2. Connection c = cp.getConnection();
    4. String sql = "INSERT INTO bla bla bla";
    5. c.createStatement().execute(sql);
    7. cp.closeConnection(c);
    8. }


    getConnection() und closeConnection() sind Methoden eines ConnectionPools, den ich selber geschrieben habe. Nix besonderes. Gibt bei Anfrage ne Connection zurück und verwendet diese dann wieder (speichern in nem Vektor)

    Das ganze funktioniert ohne Probleme, nur ist es meiner Meinung nach sehr lahm. Die DB zeigt an, dass ca. 10 kb/s geschrieben werden.

    Irgendwelche vorschläge, ob und wie man das ganze noch etwas tunen kann?

    Greeting
    cr4ch

  • ConnectionPool :

    Quellcode

    1. public class ConnectionPool {
    2. Vector<PoolConnection> vPool = new Vector<PoolConnection>();
    3. String strDriver, strURLDatabase;
    5. public ConnectionPool(String strDriver, String strURLDatabase){
    6. this.strDriver = strDriver;
    7. this.strURLDatabase = strURLDatabase;
    8. }
    10. public ConnectionPool(){
    11. this.strDriver = "com.mysql.jdbc.Driver";
    12. this.strURLDatabase = "jdbc:mysql://127.0.0.1:3306/test";
    13. }
    15. public Connection getConnection(){
    16. PoolConnection poolCon;
    18. for (int i = 0; i < vPool.size(); i++) {
    19. if(!vPool.elementAt(i).finUse){
    20. poolCon = vPool.elementAt(i);
    21. poolCon.finUse = true;
    22. return poolCon.con;
    23. }
    24. }
    26. Connection con;
    27. try{
    28. Class.forName(strDriver);
    29. con = DriverManager.getConnection(strURLDatabase);
    30. }
    31. catch(Exception ex){
    32. ex.printStackTrace();
    33. return null;
    34. }
    36. poolCon = new PoolConnection(con, true);
    37. vPool.addElement(poolCon);
    38. return con;
    39. }
    41. public void closeConnection(Connection con){
    42. try{
    43. int c = 0;
    44. while(!vPool.elementAt(c).con.equals(con)){
    45. c++;
    46. }
    48. vPool.elementAt(c).finUse = false;
    49. }
    50. catch(Exception ex){
    51. ex.printStackTrace();
    52. }
    53. }
    55. }
    57. class PoolConnection{
    58. Connection con;
    59. boolean finUse;
    61. public PoolConnection(Connection con, boolean finUse){
    62. this.con = con;
    63. this.finUse = finUse;
    64. }
    65. }
    Alles anzeigen

  • Das Konstrukt

    Quellcode

    1. Vector<PoolConnection> vPool = new Vector<PoolConnection>();

    ist mir von der Syntax her nicht bekannt, aber der Code macht Sinn und scheint auch zu funktionieren.

    Wenn ich raten müßte wo soviel Zeit verbraucht wird, dann würde ich aber auf die Schleifen in getConnection() & closeConnection() tippen.

    Hast du schonmal versucht die Zeit zu messen, die das Erzeugen und Zurückgeben der Connections benötigt?

    ICH IDIOT!

    Warum holst du für jedes Statement eine eigene Connection?

    Quellcode

    1. Connection c = cp.getConnection();
    2. for(int i = 0; i < list.size(); i++){
    3. String sql = "INSERT INTO bla bla bla";
    4. c.createStatement().execute(sql);
    5. }
    6. cp.closeConnection(c);


    Wie lange dauert das denn?

  • "Marcus Gnaß" schrieb:

    Das Konstrukt

    Quellcode

    1. Vector<PoolConnection> vPool = new Vector<PoolConnection>();

    ist mir von der Syntax her nicht bekannt, aber der Code macht Sinn und scheint auch zu funktionieren.

    Das sind Java Generics - das ist schon okay so :)

    Hast du eigentlich eine Web-Anwendung oder eine Standalone-Applikation.
    Wenn es eine Web-Anwendung ist und du Tomcat verwendest, kannst du das automatische Connection-Pooling von Tomcat verwenden - das ist vielleicht noch eine Spur schneller, da er nicht in jedem Request die Verbindung öffnen muss.

  • Moin Moin

    Also ich hab gestern mal den Vorschlag von Marcus ausprobiert, aber das ist auch nicht wirklich schneller (Zumindestens hab ich nicht das gefühl)

    phax
    Es ging allgemein um Datenbanken in Anwendungen. Hab sowohl verwendung für Standalone als auch für eine Web-Anwendung. Bei der benutze ich zur Zeit noch kein Connection-Pooling, werde das aber auf jeden fall noch in Angriff nehmen. Aktuell ist das Objekt selber dafür verantwortlich, sich in die DB zu schreiben.

    ich will wieder in mein Bett !!!

  • Altes Thema neues Problem:
    Kann mir mal wer sagen an welchen Stelle ich bei meinem ConnectionPool ein Speicherleck habe?

    muss ne gewisse menge datensätze in ne db schreiben.
    Bekomme irgendwann ein heap Exception
    Etwas rumgesucht und scheinbar hat ich irgendein Problem mit meinem ConnectionPool. Auch wenn ich noch getConnection und closeConnection mache hab ich nach ca. 30.000 Datensätzen 50 - 80 mb im speicher

    hab das Teil mitlerweile als Singleton realisiert.
    Daher kann auch nur eine Instance vorhanden sein

    Quellcode

    1. public class ConnectionPool {
    2. private final static int MAXCONNECTIONS = 20; // Verbindungen
    3. private final static long ZEITRAUM = 1000l; // 1 Sekunde
    4. private final static int WAIT = 250; // 1/4 Sekunde
    6. private static PropertiesSingleton config = PropertiesSingleton.getInstance();;
    8. private static ConnectionPool connectionPool;
    9. private Vector<PoolConnection> vPool = new Vector<PoolConnection>();
    11. private int anz = 0;
    12. private long start = System.currentTimeMillis();
    13. private long time;
    15. private ConnectionPool(){
    17. }
    19. private ConnectionPool(String configFile){
    20. try {
    21. config = PropertiesSingleton.getInstance(configFile);
    22. } catch (IOException e) {
    23. e.printStackTrace();
    24. config = PropertiesSingleton.getInstance();
    25. }
    26. }
    28. public static ConnectionPool getInstance(){
    29. if(connectionPool == null){
    30. connectionPool = new ConnectionPool();
    31. }
    33. return connectionPool;
    34. }
    36. public static ConnectionPool getInstance(String configFile){
    37. if(connectionPool == null){
    38. connectionPool = new ConnectionPool(configFile);
    39. }
    40. return connectionPool;
    41. }
    44. public Connection getConnection() throws SQLException{
    45. anz++;
    46. time = System.currentTimeMillis() - start;
    47. PoolConnection poolCon;
    49. /*
    50. * Prüft wie viele Connections in einem gewissen Zeitraum hergestellt wurden
    51. * und legt bei bedarf eine Pause ein.
    52. */
    53. if(time > ZEITRAUM && anz < MAXCONNECTIONS){
    54. start = System.currentTimeMillis();
    55. anz = 0;
    56. }
    57. else if(anz > MAXCONNECTIONS && time < ZEITRAUM){
    58. anz = 0;
    59. try {
    60. Thread.sleep(WAIT);
    61. } catch (InterruptedException e) {
    62. e.printStackTrace();
    63. }
    64. start = System.currentTimeMillis();
    65. }
    66. /*
    67. * ENDE
    68. */
    70. for (int i = 0; i < vPool.size(); i++) {
    71. if(!vPool.elementAt(i).finUse){
    72. poolCon = vPool.elementAt(i);
    73. poolCon.finUse = true;
    74. return poolCon.con;
    75. }
    76. }
    78. Connection con;
    79. try{
    80. Class.forName(config.getProperty("db.db"));
    81. }
    82. catch(ClassNotFoundException ex){
    83. throw new SQLException("Could not load DB Driver!");
    84. }
    85. con = DriverManager.getConnection(config.getProperty("db.driver"),
    86. config.getProperty("db.user"), config.getProperty("db.password"));
    88. poolCon = new PoolConnection(con, true);
    89. vPool.addElement(poolCon);
    90. return con;
    91. }
    93. public void closeConnection(Connection con){
    94. try{
    95. int c = 0;
    96. while(!vPool.elementAt(c).con.equals(con)){
    97. c++;
    98. }
    100. vPool.elementAt(c).finUse = false;
    101. }
    102. catch(Exception ex){
    103. ex.printStackTrace();
    104. }
    105. }
    106. }
    108. class PoolConnection{
    109. Connection con;
    110. boolean finUse;
    112. public PoolConnection(Connection con, boolean finUse){
    113. this.con = con;
    114. this.finUse = finUse;
    115. }
    116. }
    Alles anzeigen

    mfg
    Ubuntu Edgy * Kernel 2.6.17 * Gnome 2.16 * Beryl
    2 x Athlon MP 1900 * MSI K7D Master-L * 1024 MB ECC DDR333
    Hercules 9800XT 256 MB Ram * 1x 250 GB IDE
    Wasserkühlung