Newsgroup: it.comp.java
Titolo: [LUNGO] ecco il sorgente

Ho cambiato leggermente il sorgente, provate voi stessi. Io utilizzo
- Win2000
- P4 1.6 Ghz
- 512 MB ram
Ho provato diversi parametri della VM:
-client / -server
in combinazione con parametri per la memoria:
-Xms8m -Xmx8m
-Xms8m -Xmx256m
-Xms256m -Xmx256m
Anche se in questo caso sono inutili, in quanto non vengono creati molti 
oggetti complessi.
Insomma, i risultati sono quasi identici, con un leggerissimo vantaggio 
per la classe con gli accessor !! Inoltre le misurazioni fatte su cicli 
inferiori a 100 molto probabilmente č viziata dall'imprecisione di
System.currentTimeMillis() ...
=============================================
class NoAccessors {
   public String a;
   public String b;
   public String c;
   public String d;
   public String e;
   public String f;
   public String g;
}
class WithAccessors {
   private String a;
   private String b;
   private String c;
   private String d;
   private String e;
   private String f;
   private String g;
   public String getA() {
     return a;
   }
   public void setA(String a) {
     this.a = a;
   }
   public String getB() {
     return b;
   }
   public void setB(String b) {
     this.b = b;
   }
   public String getC() {
     return c;
   }
   public void setC(String c) {
     this.c = c;
   }
   public String getD() {
     return d;
   }
   public void setD(String d) {
     this.d = d;
   }
   public String getE() {
     return e;
   }
   public void setE(String e) {
     this.e = e;
   }
   public String getF() {
     return f;
   }
   public void setF(String f) {
     this.f = f;
   }
   public String getG() {
     return g;
   }
   public void setG(String g) {
     this.g = g;
   }
}
public class GetSetBenchmark {
   public static void main(String[] args) {
     System.out.println("Riscaldamento Hotspot...");
     testWithoutAccessors(1000);
     testWithAccessors(1000);
     testWithoutAccessors(1000);
     testWithAccessors(1000);
     System.out.println("...OK");
     System.out.println("Via con i test...");
     test(10);
     test(100);
     test(1000);
     test(10000);
     test(100000);
     test(1000000);
     test(10000000);
     System.out.println("==================================");
     System.out.println("   FINE");
   }
   private static void test(int numObj) {
     System.out.println("==================================");
     System.out.println("N. CICLI: " + numObj);
     System.out.println("testWithoutAccessors:\t" + 
testWithoutAccessors(numObj) + "\tms");
     System.out.println("testWithAccessors:\t" + 
testWithAccessors(numObj) + "\tms");
   }
   private static long testWithoutAccessors(int numObj) {
     NoAccessors obj = new NoAccessors();
     String s;
     long elapsed = System.currentTimeMillis();
     for (int i = 0; i < numObj; i++) {
       obj.a = "" + i;
       obj.b = "" + i;
       obj.c = "" + i;
       obj.d = "" + i;
       obj.e = "" + i;
       obj.f = "" + i;
       obj.g = "" + i;
       s = obj.a;
       s = obj.b;
       s = obj.c;
       s = obj.d;
       s = obj.e;
       s = obj.f;
       s = obj.g;
     }
     return System.currentTimeMillis() - elapsed;
   }
   private static long testWithAccessors(int numObj) {
     WithAccessors obj = new WithAccessors();
     String s;
     long elapsed = System.currentTimeMillis();
     for (int i = 0; i < numObj; i++) {
       obj.setA("" + i);
       obj.setB("" + i);
       obj.setC("" + i);
       obj.setD("" + i);
       obj.setE("" + i);
       obj.setF("" + i);
       obj.setG("" + i);
       s = obj.getA();
       s = obj.getB();
       s = obj.getC();
       s = obj.getD();
       s = obj.getE();
       s = obj.getF();
       s = obj.getG();
     }
     return System.currentTimeMillis() - elapsed;
   }
}
-- 
                 ''~``
                ( o o )
+---------.oooO--(_)--Oooo.----+
 
http://www.jroller.com/page/megadix/
 
http://www.mict.it/

ho fatto il tuo test, perņ ho anche provato a scambiare
le chiamate
(riporto solo quelli + lunghi)
chiamando prima quello senza get/set (come nel tuo codice)
==================================
N. CICLI: 100000
testWithoutAccessors: 266 ms
testWithAccessors: 281 ms
==================================
N. CICLI: 1000000
testWithoutAccessors: 2750 ms
testWithAccessors: 2640 ms
==================================
N. CICLI: 10000000
testWithoutAccessors: 26625 ms
testWithAccessors: 26500 ms
==================================
////////////////////////////////////////////////////////////////
chiamando prima quelli con i getters
==================================
N. CICLI: 100000
testWithAccessors: 282 ms
testWithoutAccessors: 265 ms
==================================
N. CICLI: 1000000
testWithAccessors: 2641 ms
testWithoutAccessors: 2609 ms
==================================
N. CICLI: 10000000
testWithAccessors: 26657 ms
testWithoutAccessors: 26453 ms
==================================
in questo caso fa meglio quello senza!!!
PS: secondo me sono esattamente uguali,
le piccole differenze possono essere dovute al garbage collector?

 
Questo dimostra che in generale č meglio rispettare le "buone regole" e 
mettere i get/set sulle proprietą, senza aver paura di penalitą di 
performance.
Niente di nuovo, comunque, io mi ricordo del caro vecchio compilatore 
C++ che mi batteva sempre sempre sempre anche se scrivevo due routine, 
una in C e l'altra in assembler (beh, č anche vero che in assembler ero 
una vera sega, aargh...)
