Skip to content

Il modo più veloce per iterare su tutti i caratteri di una stringa

Abbiamo bisogno del tuo aiuto per condividere le nostre storie sull'informatica.

Soluzione:

PRIMO AGGIORNAMENTO: Prima di provare questo metodo in un ambiente di produzione (sconsigliato), leggete prima questo: http://www.javaspecialists.eu/archive/Issue237.html
A partire da Java 9, la soluzione descritta non funzionerà più, perché ora Java memorizza le stringhe come byte[] per impostazione predefinita.

SECONDO AGGIORNAMENTO: A partire dal 2016-10-25, sul mio AMDx64 8core e sulla sorgente 1.8, non vi è alcuna differenza tra l'utilizzo di 'charAt' e l'accesso al campo. Sembra che il jvm sia sufficientemente ottimizzato per inlineare e semplificare qualsiasi chiamata a 'string.charAt(n)'.

TERZO AGGIORNAMENTO: al 2020-09-07, sul mio Ryzen 1950-X 16 core e sorgente 1.14, 'charAt1' è 9 volte più lento dell'accesso al campo e 'charAt2' è 4 volte più lento dell'accesso al campo. L'accesso al campo è tornato ad essere il chiaro vincitore. Si noti che il programma dovrà utilizzare il byte[] per i jvms versione Java 9+.

Tutto dipende dalla lunghezza del campo String che viene ispezionato. Se, come dice la domanda, è per lungo il modo più veloce per ispezionare la stringa è quello di usare la riflessione per accedere al backing char[] della stringa.

Un benchmark completamente randomizzato con JDK 8 (win32 e win64) su un AMD Phenom II 4 core 955 @ 3,2 GHZ (sia in modalità client che in modalità server) con 9 tecniche diverse (vedere sotto!) mostra che l'uso di String.charAt(n) è il più veloce per le stringhe piccole e che l'uso di reflection per accedere all'array di supporto delle stringhe è quasi due volte più veloce per le stringhe grandi.

L'ESPERIMENTO

  • Sono state provate 9 diverse tecniche di ottimizzazione.

  • Tutti i contenuti delle stringhe sono randomizzati

  • I test vengono eseguiti per stringhe di dimensioni multiple di due, a partire da 0,1,2,4,8,16 ecc.

  • I test vengono eseguiti 1.000 volte per ogni dimensione di stringa

  • I test vengono mescolati ogni volta in ordine casuale. In altre parole, i test vengono eseguiti in ordine casuale ogni volta che vengono eseguiti, per oltre 1000 volte.

  • L'intera suite di test viene eseguita in avanti e all'indietro, per mostrare l'effetto del riscaldamento della JVM sull'ottimizzazione e sui tempi.

  • L'intera suite viene eseguita due volte, una volta in -client e l'altra in modalità -server in modalità -server .

CONCLUSIONI

-modalità client (32 bit)

Per le stringhe lunghezza da 1 a 256 caratteri, chiamando string.charAt(i) vince con un'elaborazione media da 13,4 milioni a 588 milioni di caratteri al secondo.

Inoltre, è complessivamente più veloce del 5,5% (client) e del 13,9% (server) in questo modo:

    for (int i = 0; i < data.length(); i++) {
        if (data.charAt(i) <= ' ') {
            doThrow();
        }
    }

che in questo modo con una variabile locale di lunghezza finale:

    final int len = data.length();
    for (int i = 0; i < len; i++) {
        if (data.charAt(i) <= ' ') {
            doThrow();
        }
    }

Per le stringhe lunghe, lunghezza da 512 a 256K caratteri l'uso della riflessione per accedere all'array di supporto della stringa è più veloce. Questa tecnica è quasi due volte più veloce di String.charAt(i) (178% più veloce). La velocità media su questo intervallo è stata di 1,111 miliardi di caratteri al secondo.

Il campo deve essere ottenuto in anticipo e poi può essere riutilizzato nella libreria su stringhe diverse. È interessante notare che, a differenza del codice precedente, con l'accesso al campo è più veloce del 9% avere una variabile locale di lunghezza finale che usare 'chars.length' nel controllo del ciclo. Ecco come l'accesso al campo può essere configurato come più veloce:

   final Field field = String.class.getDeclaredField("value");
   field.setAccessible(true);

   try {
       final char[] chars = (char[]) field.get(data);
       final int len = chars.length;
       for (int i = 0; i < len; i++) {
           if (chars[i] <= ' ') {
               doThrow();
           }
       }
       return len;
   } catch (Exception ex) {
       throw new RuntimeException(ex);
   }

Commenti speciali sulla modalità -server

L'accesso al campo inizia a vincere dopo stringhe di lunghezza pari a 32 caratteri in modalità server su una macchina Java a 64 bit sul mio computer AMD 64. Questo non è stato visto fino alla lunghezza di 512 caratteri in modalità client.

Vale anche la pena notare che, quando stavo eseguendo JDK 8 (build a 32 bit) in modalità server, le prestazioni complessive erano più lente del 7% per stringhe grandi e piccole. Questo è avvenuto con la build 121 dicembre 2013 di JDK 8 early release. Quindi, per ora, sembra che la modalità server a 32 bit sia più lenta della modalità client a 32 bit.

Detto questo... sembra che l'unica modalità server che valga la pena invocare sia su una macchina a 64 bit. In caso contrario, le prestazioni vengono effettivamente ostacolate.

Per la build a 32 bit in esecuzione in -server mode su un AMD64, posso dire questo:

  1. String.charAt(i) è il chiaro vincitore assoluto. Anche se tra le dimensioni da 8 a 512 caratteri ci sono stati vincitori tra 'nuovo' 'riutilizzo' e 'campo'.
  2. String.charAt(i) è più veloce del 45% in modalità client.
  3. L'accesso ai campi è due volte più veloce per le stringhe di grandi dimensioni in modalità client.

Vale anche la pena di dire che String.chars() (Stream e la versione parallela) sono un fallimento. Molto più lento di qualsiasi altro modo. Il Streams è un modo piuttosto lento per eseguire operazioni generali sulle stringhe.

Elenco dei desideri

Java String potrebbe avere metodi ottimizzati per l'accettazione di predicati, come contains(predicate), forEach(consumer), forEachWithIndex(consumer). In questo modo, senza che l'utente debba conoscere la lunghezza o ripetere le chiamate ai metodi String, questi potrebbero aiutare le librerie di parsing. beep-beep beep velocizzare.

Continuate a sognare 🙂

Corde felici!

~SH

Il test ha utilizzato i seguenti 9 metodi per verificare la presenza di spazi bianchi nella stringa:

"charAt1" -- Verifica il contenuto della stringa nel modo consueto:

int charAtMethod1(final String data) {
    final int len = data.length();
    for (int i = 0; i < len; i++) {
        if (data.charAt(i) <= ' ') {
            doThrow();
        }
    }
    return len;
}

"charAt2" -- STESSA COSA MA UTILIZZANDO String.length() SENZA FARE UN INT LOCALE FINALE PER LA LUNGHEZZA

int charAtMethod2(final String data) {
    for (int i = 0; i < data.length(); i++) {
        if (data.charAt(i) <= ' ') {
            doThrow();
        }
    }
    return data.length();
}

"stream" -- usa il nuovo IntStream di JAVA-8 String e gli passa un PREDICATO per fare il controllo

int streamMethod(final String data, final IntPredicate predicate) {
    if (data.chars().anyMatch(predicate)) {
        doThrow();
    }
    return data.length();
}

"streamPara" -- STESSA COSA, MA OH-LA-LA - VAI IN PARALLELO!!!

// avoid this at all costs
int streamParallelMethod(final String data, IntPredicate predicate) {
    if (data.chars().parallel().anyMatch(predicate)) {
        doThrow();
    }
    return data.length();
}

"reuse" -- Riempire un carattere riutilizzabile[] CON IL CONTENUTO DELLA STRINGA

int reuseBuffMethod(final char[] reusable, final String data) {
    final int len = data.length();
    data.getChars(0, len, reusable, 0);
    for (int i = 0; i < len; i++) {
        if (reusable[i] <= ' ') {
            doThrow();
        }
    }
    return len;
}

"new1" -- OTTENERE UNA NUOVA COPIA DEL CARATTERE[] DALLA STRINGA

int newMethod1(final String data) {
    final int len = data.length();
    final char[] copy = data.toCharArray();
    for (int i = 0; i < len; i++) {
        if (copy[i] <= ' ') {
            doThrow();
        }
    }
    return len;
}

"nuovo2" -- STESSO COME SOPRA, MA USANDO "PER OGNI"

int newMethod2(final String data) {
    for (final char c : data.toCharArray()) {
        if (c <= ' ') {
            doThrow();
        }
    }
    return data.length();
}

"campo1" -- FANTASTICO!!! OTTENERE IL CAMPO PER ACCEDERE AL CARATTERE INTERNO DELLA STRINGA[]

int fieldMethod1(final Field field, final String data) {
    try {
        final char[] chars = (char[]) field.get(data);
        final int len = chars.length;
        for (int i = 0; i < len; i++) {
            if (chars[i] <= ' ') {
                doThrow();
            }
        }
        return len;
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
}

"campo2" -- COME I PRECEDENTI, MA UTILIZZARE "PER OGNI"

int fieldMethod2(final Field field, final String data) {
    final char[] chars;
    try {
        chars = (char[]) field.get(data);
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
    for (final char c : chars) {
        if (c <= ' ') {
            doThrow();
        }
    }
    return chars.length;
}

RISULTATI COMPOSITI PER IL CLIENTE -client MODALITÀ (test in avanti e indietro combinati)

Nota: la modalità -client con Java 32 bit e la modalità -server con Java 64 bit sono uguali a quelle sotto riportate sulla mia macchina AMD64.

Size     WINNER  charAt1 charAt2  stream streamPar   reuse    new1    new2  field1  field2
1        charAt    77.0     72.0   462.0     584.0   127.5    89.5    86.0   159.5   165.0
2        charAt    38.0     36.5   284.0   32712.5    57.5    48.3    50.3    89.0    91.5
4        charAt    19.5     18.5   458.6    3169.0    33.0    26.8    27.5    54.1    52.6
8        charAt     9.8      9.9   100.5    1370.9    17.3    14.4    15.0    26.9    26.4
16       charAt     6.1      6.5    73.4     857.0     8.4     8.2     8.3    13.6    13.5
32       charAt     3.9      3.7    54.8     428.9     5.0     4.9     4.7     7.0     7.2
64       charAt     2.7      2.6    48.2     232.9     3.0     3.2     3.3     3.9     4.0
128      charAt     2.1      1.9    43.7     138.8     2.1     2.6     2.6     2.4     2.6
256      charAt     1.9      1.6    42.4      90.6     1.7     2.1     2.1     1.7     1.8
512      field1     1.7      1.4    40.6      60.5     1.4     1.9     1.9     1.3     1.4
1,024    field1     1.6      1.4    40.0      45.6     1.2     1.9     2.1     1.0     1.2
2,048    field1     1.6      1.3    40.0      36.2     1.2     1.8     1.7     0.9     1.1
4,096    field1     1.6      1.3    39.7      32.6     1.2     1.8     1.7     0.9     1.0
8,192    field1     1.6      1.3    39.6      30.5     1.2     1.8     1.7     0.9     1.0
16,384   field1     1.6      1.3    39.8      28.4     1.2     1.8     1.7     0.8     1.0
32,768   field1     1.6      1.3    40.0      26.7     1.3     1.8     1.7     0.8     1.0
65,536   field1     1.6      1.3    39.8      26.3     1.3     1.8     1.7     0.8     1.0
131,072  field1     1.6      1.3    40.1      25.4     1.4     1.9     1.8     0.8     1.0
262,144  field1     1.6      1.3    39.6      25.2     1.5     1.9     1.9     0.8     1.0

RISULTATI COMPOSITI PER IL SERVER -serverMODE (test avanti e indietro combinati)

Nota: questo è il test per Java 32 bit in modalità server su un AMD64. La modalità server per Java 64 bit era la stessa di Java 32 bit in modalità client, tranne per il fatto che l'accesso al campo iniziava a vincere dopo la dimensione di 32 caratteri.

Size     WINNER  charAt1 charAt2  stream streamPar   reuse    new1    new2  field1  field2
1        charAt     74.5    95.5   524.5     783.0    90.5   102.5    90.5   135.0   151.5
2        charAt     48.5    53.0   305.0   30851.3    59.3    57.5    52.0    88.5    91.8
4        charAt     28.8    32.1   132.8    2465.1    37.6    33.9    32.3    49.0    47.0
8          new2     18.0    18.6    63.4    1541.3    18.5    17.9    17.6    25.4    25.8
16         new2     14.0    14.7   129.4    1034.7    12.5    16.2    12.0    16.0    16.6
32         new2      7.8     9.1    19.3     431.5     8.1     7.0     6.7     7.9     8.7
64        reuse      6.1     7.5    11.7     204.7     3.5     3.9     4.3     4.2     4.1
128       reuse      6.8     6.8     9.0     101.0     2.6     3.0     3.0     2.6     2.7
256      field2      6.2     6.5     6.9      57.2     2.4     2.7     2.9     2.3     2.3
512       reuse      4.3     4.9     5.8      28.2     2.0     2.6     2.6     2.1     2.1
1,024    charAt      2.0     1.8     5.3      17.6     2.1     2.5     3.5     2.0     2.0
2,048    charAt      1.9     1.7     5.2      11.9     2.2     3.0     2.6     2.0     2.0
4,096    charAt      1.9     1.7     5.1       8.7     2.1     2.6     2.6     1.9     1.9
8,192    charAt      1.9     1.7     5.1       7.6     2.2     2.5     2.6     1.9     1.9
16,384   charAt      1.9     1.7     5.1       6.9     2.2     2.5     2.5     1.9     1.9
32,768   charAt      1.9     1.7     5.1       6.1     2.2     2.5     2.5     1.9     1.9
65,536   charAt      1.9     1.7     5.1       5.5     2.2     2.4     2.4     1.9     1.9
131,072  charAt      1.9     1.7     5.1       5.4     2.3     2.5     2.5     1.9     1.9
262,144  charAt      1.9     1.7     5.1       5.1     2.3     2.5     2.5     1.9     1.9

CODICE DI PROGRAMMA COMPLETO ESEGUIBILE

(per testare su Java 7 e precedenti, rimuovere i due test sui flussi)

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.function.IntPredicate;

/**
 * @author Saint Hill 
 */
public final class TestStrings {

    // we will not test strings longer than 512KM
    final int MAX_STRING_SIZE = 1024 * 256;

    // for each string size, we will do all the tests
    // this many times
    final int TRIES_PER_STRING_SIZE = 1000;

    public static void main(String[] args) throws Exception {
        new TestStrings().run();
    }

    void run() throws Exception {

        // double the length of the data until it reaches MAX chars long
        // 0,1,2,4,8,16,32,64,128,256 ... 
        final List sizes = new ArrayList<>();
        for (int n = 0; n <= MAX_STRING_SIZE; n = (n == 0 ? 1 : n * 2)) {
            sizes.add(n);
        }

        // CREATE RANDOM (FOR SHUFFLING ORDER OF TESTS)
        final Random random = new Random();

        System.out.println("Rate in nanoseconds per character inspected.");
        System.out.printf("==== FORWARDS (tries per size: %s) ==== n", TRIES_PER_STRING_SIZE);

        printHeadings(TRIES_PER_STRING_SIZE, random);

        for (int size : sizes) {
            reportResults(size, test(size, TRIES_PER_STRING_SIZE, random));
        }

        // reverse order or string sizes
        Collections.reverse(sizes);

        System.out.println("");
        System.out.println("Rate in nanoseconds per character inspected.");
        System.out.printf("==== BACKWARDS (tries per size: %s) ==== n", TRIES_PER_STRING_SIZE);

        printHeadings(TRIES_PER_STRING_SIZE, random);

        for (int size : sizes) {
            reportResults(size, test(size, TRIES_PER_STRING_SIZE, random));

        }
    }

    ///
    ///
    ///  METHODS OF CHECKING THE CONTENTS
    ///  OF A STRING. ALWAYS CHECKING FOR
    ///  WHITESPACE (CHAR <=' ')
    ///  
    ///
    // CHECK THE STRING CONTENTS
    int charAtMethod1(final String data) {
        final int len = data.length();
        for (int i = 0; i < len; i++) {
            if (data.charAt(i) <= ' ') {
                doThrow();
            }
        }
        return len;
    }

    // SAME AS ABOVE BUT USE String.length()
    // instead of making a new final local int 
    int charAtMethod2(final String data) {
        for (int i = 0; i < data.length(); i++) {
            if (data.charAt(i) <= ' ') {
                doThrow();
            }
        }
        return data.length();
    }

    // USE new Java-8 String's IntStream
    // pass it a PREDICATE to do the checking
    int streamMethod(final String data, final IntPredicate predicate) {
        if (data.chars().anyMatch(predicate)) {
            doThrow();
        }
        return data.length();
    }

    // OH LA LA - GO PARALLEL!!!
    int streamParallelMethod(final String data, IntPredicate predicate) {
        if (data.chars().parallel().anyMatch(predicate)) {
            doThrow();
        }
        return data.length();
    }

    // Re-fill a resuable char[] with the contents
    // of the String's char[]
    int reuseBuffMethod(final char[] reusable, final String data) {
        final int len = data.length();
        data.getChars(0, len, reusable, 0);
        for (int i = 0; i < len; i++) {
            if (reusable[i] <= ' ') {
                doThrow();
            }
        }
        return len;
    }

    // Obtain a new copy of char[] from String
    int newMethod1(final String data) {
        final int len = data.length();
        final char[] copy = data.toCharArray();
        for (int i = 0; i < len; i++) {
            if (copy[i] <= ' ') {
                doThrow();
            }
        }
        return len;
    }

    // Obtain a new copy of char[] from String
    // but use FOR-EACH
    int newMethod2(final String data) {
        for (final char c : data.toCharArray()) {
            if (c <= ' ') {
                doThrow();
            }
        }
        return data.length();
    }

    // FANCY!
    // OBTAIN FIELD FOR ACCESS TO THE STRING'S
    // INTERNAL CHAR[]
    int fieldMethod1(final Field field, final String data) {
        try {
            final char[] chars = (char[]) field.get(data);
            final int len = chars.length;
            for (int i = 0; i < len; i++) {
                if (chars[i] <= ' ') {
                    doThrow();
                }
            }
            return len;
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    // same as above but use FOR-EACH
    int fieldMethod2(final Field field, final String data) {
        final char[] chars;
        try {
            chars = (char[]) field.get(data);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
        for (final char c : chars) {
            if (c <= ' ') {
                doThrow();
            }
        }
        return chars.length;
    }

    /**
     *
     * Make a list of tests. We will shuffle a copy of this list repeatedly
     * while we repeat this test.
     *
     * @param data
     * @return
     */
    List makeTests(String data) throws Exception {
        // make a list of tests
        final List tests = new ArrayList();

        tests.add(new Jobber("charAt1") {
            int check() {
                return charAtMethod1(data);
            }
        });

        tests.add(new Jobber("charAt2") {
            int check() {
                return charAtMethod2(data);
            }
        });

        tests.add(new Jobber("stream") {
            final IntPredicate predicate = new IntPredicate() {
                public boolean test(int value) {
                    return value <= ' ';
                }
            };

            int check() {
                return streamMethod(data, predicate);
            }
        });

        tests.add(new Jobber("streamPar") {
            final IntPredicate predicate = new IntPredicate() {
                public boolean test(int value) {
                    return value <= ' ';
                }
            };

            int check() {
                return streamParallelMethod(data, predicate);
            }
        });

        // Reusable char[] method
        tests.add(new Jobber("reuse") {
            final char[] cbuff = new char[MAX_STRING_SIZE];

            int check() {
                return reuseBuffMethod(cbuff, data);
            }
        });

        // New char[] from String
        tests.add(new Jobber("new1") {
            int check() {
                return newMethod1(data);
            }
        });

        // New char[] from String
        tests.add(new Jobber("new2") {
            int check() {
                return newMethod2(data);
            }
        });

        // Use reflection for field access
        tests.add(new Jobber("field1") {
            final Field field;

            {
                field = String.class.getDeclaredField("value");
                field.setAccessible(true);
            }

            int check() {
                return fieldMethod1(field, data);
            }
        });

        // Use reflection for field access
        tests.add(new Jobber("field2") {
            final Field field;

            {
                field = String.class.getDeclaredField("value");
                field.setAccessible(true);
            }

            int check() {
                return fieldMethod2(field, data);
            }
        });

        return tests;
    }

    /**
     * We use this class to keep track of test results
     */
    abstract class Jobber {

        final String name;
        long nanos;
        long chars;
        long runs;

        Jobber(String name) {
            this.name = name;
        }

        abstract int check();

        final double nanosPerChar() {
            double charsPerRun = chars / runs;
            long nanosPerRun = nanos / runs;
            return charsPerRun == 0 ? nanosPerRun : nanosPerRun / charsPerRun;
        }

        final void run() {
            runs++;
            long time = System.nanoTime();
            chars += check();
            nanos += System.nanoTime() - time;
        }
    }

    // MAKE A TEST STRING OF RANDOM CHARACTERS A-Z
    private String makeTestString(int testSize, char start, char end) {
        Random r = new Random();
        char[] data = new char[testSize];
        for (int i = 0; i < data.length; i++) {
            data[i] = (char) (start + r.nextInt(end));
        }
        return new String(data);
    }

    // WE DO THIS IF WE FIND AN ILLEGAL CHARACTER IN THE STRING
    public void doThrow() {
        throw new RuntimeException("Bzzzt -- Illegal Character!!");
    }

    /**
     * 1. get random string of correct length 2. get tests (List) 3.
     * perform tests repeatedly, shuffling each time
     */
    List test(int size, int tries, Random random) throws Exception {
        String data = makeTestString(size, 'A', 'Z');
        List tests = makeTests(data);
        List copy = new ArrayList<>(tests);
        while (tries-- > 0) {
            Collections.shuffle(copy, random);
            for (Jobber ti : copy) {
                ti.run();
            }
        }
        // check to make sure all char counts the same
        long runs = tests.get(0).runs;
        long count = tests.get(0).chars;
        for (Jobber ti : tests) {
            if (ti.runs != runs && ti.chars != count) {
                throw new Exception("Char counts should match if all correct algorithms");
            }
        }
        return tests;
    }

    private void printHeadings(final int TRIES_PER_STRING_SIZE, final Random random) throws Exception {
        System.out.print("  Size");
        for (Jobber ti : test(0, TRIES_PER_STRING_SIZE, random)) {
            System.out.printf("%9s", ti.name);
        }
        System.out.println("");
    }

    private void reportResults(int size, List tests) {
        System.out.printf("%6d", size);
        for (Jobber ti : tests) {
            System.out.printf("%,9.2f", ti.nanosPerChar());
        }
        System.out.println("");
    }
}

Questa è solo una micro-ottimizzazione di cui non ci si dovrebbe preoccupare.

char[] chars = str.toCharArray();

restituisce una copia di str degli array di caratteri (in JDK, restituisce una copia dei caratteri chiamando System.arrayCopy).

Oltre a questo, str.charAt() controlla solo se l'indice è effettivamente nei limiti e restituisce un carattere all'interno dell'indice dell'array.

Il primo non crea memoria aggiuntiva nella JVM.

Solo per curiosità e per fare un confronto con la risposta di Saint Hill.

Se avete bisogno di elaborare dati pesanti non dovreste usare la JVM in modalità client. La modalità client non è fatta per le ottimizzazioni.

Confrontiamo i risultati dei benchmark di @Saint Hill utilizzando una JVM in modalità client e in modalità server.

Core2Quad Q6600 G0 @ 2.4GHz
JavaSE 1.7.0_40

Vedere anche: Differenze reali tra "java -server" e "java -client"?


MODALITÀ CLIENTE:

len =      2:    111k charAt(i),  105k cbuff[i],   62k new[i],   17k field access.   (chars/ms) 
len =      4:    285k charAt(i),  166k cbuff[i],  114k new[i],   43k field access.   (chars/ms) 
len =      6:    315k charAt(i),  230k cbuff[i],  162k new[i],   69k field access.   (chars/ms) 
len =      8:    333k charAt(i),  275k cbuff[i],  181k new[i],   85k field access.   (chars/ms) 
len =     12:    342k charAt(i),  342k cbuff[i],  222k new[i],  117k field access.   (chars/ms) 
len =     16:    363k charAt(i),  347k cbuff[i],  275k new[i],  152k field access.   (chars/ms) 
len =     20:    363k charAt(i),  392k cbuff[i],  289k new[i],  180k field access.   (chars/ms) 
len =     24:    375k charAt(i),  428k cbuff[i],  311k new[i],  205k field access.   (chars/ms) 
len =     28:    378k charAt(i),  474k cbuff[i],  341k new[i],  233k field access.   (chars/ms) 
len =     32:    376k charAt(i),  492k cbuff[i],  340k new[i],  251k field access.   (chars/ms) 
len =     64:    374k charAt(i),  551k cbuff[i],  374k new[i],  367k field access.   (chars/ms) 
len =    128:    385k charAt(i),  624k cbuff[i],  415k new[i],  509k field access.   (chars/ms) 
len =    256:    390k charAt(i),  675k cbuff[i],  436k new[i],  619k field access.   (chars/ms) 
len =    512:    394k charAt(i),  703k cbuff[i],  439k new[i],  695k field access.   (chars/ms) 
len =   1024:    395k charAt(i),  718k cbuff[i],  462k new[i],  742k field access.   (chars/ms) 
len =   2048:    396k charAt(i),  725k cbuff[i],  471k new[i],  767k field access.   (chars/ms) 
len =   4096:    396k charAt(i),  727k cbuff[i],  459k new[i],  780k field access.   (chars/ms) 
len =   8192:    397k charAt(i),  712k cbuff[i],  446k new[i],  772k field access.   (chars/ms) 

MODALITÀ SERVER:

len =      2:     86k charAt(i),   41k cbuff[i],   46k new[i],   80k field access.   (chars/ms) 
len =      4:    571k charAt(i),  250k cbuff[i],   97k new[i],  222k field access.   (chars/ms) 
len =      6:    666k charAt(i),  333k cbuff[i],  125k new[i],  315k field access.   (chars/ms) 
len =      8:    800k charAt(i),  400k cbuff[i],  181k new[i],  380k field access.   (chars/ms) 
len =     12:    800k charAt(i),  521k cbuff[i],  260k new[i],  545k field access.   (chars/ms) 
len =     16:    800k charAt(i),  592k cbuff[i],  296k new[i],  640k field access.   (chars/ms) 
len =     20:    800k charAt(i),  666k cbuff[i],  408k new[i],  800k field access.   (chars/ms) 
len =     24:    800k charAt(i),  705k cbuff[i],  452k new[i],  800k field access.   (chars/ms) 
len =     28:    777k charAt(i),  736k cbuff[i],  368k new[i],  933k field access.   (chars/ms) 
len =     32:    800k charAt(i),  780k cbuff[i],  571k new[i],  969k field access.   (chars/ms) 
len =     64:    800k charAt(i),  901k cbuff[i],  800k new[i],  1306k field access.   (chars/ms) 
len =    128:    1084k charAt(i),  888k cbuff[i],  633k new[i],  1620k field access.   (chars/ms) 
len =    256:    1122k charAt(i),  966k cbuff[i],  729k new[i],  1790k field access.   (chars/ms) 
len =    512:    1163k charAt(i),  1007k cbuff[i],  676k new[i],  1910k field access.   (chars/ms) 
len =   1024:    1179k charAt(i),  1027k cbuff[i],  698k new[i],  1954k field access.   (chars/ms) 
len =   2048:    1184k charAt(i),  1043k cbuff[i],  732k new[i],  2007k field access.   (chars/ms) 
len =   4096:    1188k charAt(i),  1049k cbuff[i],  742k new[i],  2031k field access.   (chars/ms) 
len =   8192:    1157k charAt(i),  1032k cbuff[i],  723k new[i],  2048k field access.   (chars/ms) 

CONCLUSIONE:

Come si può vedere, la modalità server è molto più veloce.

Ti invitiamo ad aggiungere valore ai nostri contenuti partecipando con la tua esperienza alla critica.



Utilizzate il nostro motore di ricerca

Ricerca
Generic filters

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.