java - que - ¿Por qué usar StringBuilder? StringBuffer puede trabajar con varios hilos, así como con un solo hilo?

stringbuilder java example

Question

Supongamos que nuestra aplicación tiene un solo hilo. y estamos utilizando StringBuffer , ¿cuál es el problema?

Quiero decir que si StringBuffer puede manejar múltiples hilos a través de la sincronización, ¿cuál es el problema para trabajar con un solo hilo?

¿Por qué usar StringBuilder lugar?

Answer 1

Esto les ayudará a ustedes, Be Straight Builder es más rápido que Buffer,

public class ConcatPerf {
        private static final int ITERATIONS = 100000;
        private static final int BUFFSIZE = 16;

        private void concatStrAdd() {
            System.out.print("concatStrAdd   -> ");
            long startTime = System.currentTimeMillis();
            String concat = new String("");
            for (int i = 0; i < ITERATIONS; i++) {
                concat += i % 10;
            }
            //System.out.println("Content: " + concat);
            long endTime = System.currentTimeMillis();
            System.out.print("length: " + concat.length());
            System.out.println(" time: " + (endTime - startTime));
        }

        private void concatStrBuff() {
            System.out.print("concatStrBuff  -> ");
            long startTime = System.currentTimeMillis();
            StringBuffer concat = new StringBuffer(BUFFSIZE);
            for (int i = 0; i < ITERATIONS; i++) {
                concat.append(i % 10);
            }
            long endTime = System.currentTimeMillis();
            //System.out.println("Content: " + concat);
            System.out.print("length: " + concat.length());
            System.out.println(" time: " + (endTime - startTime));
        }

        private void concatStrBuild() {
            System.out.print("concatStrBuild -> ");
            long startTime = System.currentTimeMillis();
            StringBuilder concat = new StringBuilder(BUFFSIZE);
            for (int i = 0; i < ITERATIONS; i++) {
                concat.append(i % 10);
            }
            long endTime = System.currentTimeMillis();
           // System.out.println("Content: " + concat);
            System.out.print("length: " + concat.length());
            System.out.println(" time: " + (endTime - startTime));
        }

        public static void main(String[] args) {
            ConcatPerf st = new ConcatPerf();
            System.out.println("Iterations: " + ITERATIONS);
            System.out.println("Buffer    : " + BUFFSIZE);

            st.concatStrBuff();
            st.concatStrBuild();
            st.concatStrAdd();
        }
    }

Output  

    run:
    Iterations: 100000
    Buffer    : 16
    concatStrBuff  -> length: 100000 time: 11
    concatStrBuild -> length: 100000 time: 4
    concatStrAdd   -> 

Answer 2

Hay un costo enorme para sincronizar objetos. No vea un programa como una entidad independiente; no es un problema cuando está leyendo los conceptos y aplicándolos en programas pequeños como ha mencionado en los detalles de su pregunta, los problemas surgen cuando queremos escalar el sistema. En ese caso, su programa de un solo hilo podría depender de varios otros métodos / programas / entidades, por lo que los objetos sincronizados pueden causar una seria complejidad de programación en términos de rendimiento. Por lo tanto, si está seguro de que no es necesario sincronizar un objeto, debe utilizar StringBuilder, ya que es una buena práctica de programación. Al final, queremos aprender a programar para hacer sistemas escalables de alto rendimiento, ¡así que eso es lo que debemos hacer!

Answer 3

Manish, aunque solo hay un subproceso que opera en su instancia de StringBuffer, existe cierta sobrecarga al adquirir y liberar el bloqueo del monitor en la instancia de StringBuffer cada vez que se invoca alguno de sus métodos. Por lo tanto, StringBuilder es una opción preferible en un entorno de un solo hilo.

Answer 4

Se supone que StringBuilder es un poco más rápido porque no está sincronizado (seguro para subprocesos).

Puedes notar la diferencia en aplicaciones realmente pesadas.

La clase StringBuilder generalmente se debe usar con preferencia a esta, ya que admite todas las mismas operaciones, pero es más rápida, ya que no realiza ninguna sincronización.

http://download.oracle.com/javase/6/docs/api/java/lang/StringBuffer.html

Answer 5

Usar StringBuffer en varios subprocesos es casi inútil y en realidad casi nunca sucede.

Considera lo siguiente

Thread1: sb.append(key1).append("=").append(value1);
Thread2: sb.append(key2).append("=").append(value2);

cada anexo está sincronizado, pero un hilo se puede inclinar en cualquier punto para que pueda tener cualquiera de las siguientes combinaciones y más

key1=value1key2=value2
key1key2==value2value1
key2key1=value1=value2
key2=key1=value2value1

Esto se puede evitar sincronizando toda la línea a la vez, pero esto anula el punto de usar StringBuffer en lugar de StringBuilder.

Incluso si tiene una vista correctamente sincronizada, es más complicado que simplemente crear una copia local de subproceso de toda la línea, por ejemplo, StringBuilder y líneas de registro de una clase como un escritor.

Answer 6

StringBuffer no está mal en una aplicación de un solo hilo. Funcionará tan bien como StringBuilder .

La única diferencia es la pequeña sobrecarga agregada al tener todos los métodos sincronizados, lo que no ofrece ninguna ventaja en una aplicación de un solo hilo.

Mi opinión es que la razón principal por la que se introdujo StringBuilder es que el compilador usa StringBuffer (y ahora StringBuilder ) cuando compila código que contiene concatenación de String : en esos casos, la sincronización nunca es necesaria y la sustitución de todos esos lugares con una lata StringBuilder sincronizada Proporcionar una pequeña mejora de rendimiento.

Answer 7

StringBuffers son seguros para subprocesos, lo que significa que tienen métodos sincronizados para controlar el acceso, de modo que solo un subproceso puede acceder al código sincronizado de un objeto StringBuffer a la vez. Por lo tanto, los objetos StringBuffer generalmente son seguros de usar en un entorno de múltiples subprocesos donde varios subprocesos pueden estar intentando acceder al mismo objeto StringBuffer al mismo tiempo.

StringBuilder''s acceso StringBuilder''s no está sincronizado, por lo que no es seguro para subprocesos. Al no estar sincronizado, el rendimiento de StringBuilder puede ser mejor que el de StringBuffer. Por lo tanto, si está trabajando en un entorno de un solo subproceso, el uso de StringBuilder en lugar de StringBuffer puede resultar en un mayor rendimiento. Esto también es válido para otras situaciones, como una variable local de StringBuilder (es decir, una variable dentro de un método) donde solo un hilo accederá a un objeto StringBuilder.

Por lo tanto, prefiero StringBuilder porque,

• Pequeña ganancia de rendimiento.
• StringBuilder es un reemplazo directo 1: 1 para la clase StringBuffer.
• StringBuilder no está sincronizado con subprocesos y, por lo tanto, funciona mejor en la mayoría de las implementaciones de Java

Mira esto :

• No utilice StringBuffer!
• Comparación de rendimiento de StringBuffer vs. StringBuilder

Answer 8

StringBuilder tiene un mejor rendimiento porque sus métodos no están sincronizados.

Por lo tanto, si no necesita crear una Cadena de forma concurrente (que de todos modos es un escenario bastante atípico), entonces no hay necesidad de "pagar" la sobrecarga de sincronización innecesaria.