Sincronizado vs ReentrantLock en el rendimiento

Question

He pasado por un conjunto de sorpresas cuando se trata de la implementación de cola para un sistema de subprocesamiento múltiple. Aquí está: -

El escenario: - 1 productor, 1 consumidor: - Un productor pone un número entero en una cola. Un consumidor simplemente lo elimina de la cola.

La estructura de datos subyacente de la cola: - TreeSet (que nunca pensé que voy a utilizar), LinkedList, LinkedBlockingQueue (con un tamaño indefinido)

El código: - de TreeSet como una cola: -

while (i < 2000000) { 
     synchronized (objQueue) { 

      if (!(objQueue.size() > 0)) { 
       try { 
        objQueue.wait(); 
       } catch (InterruptedException e) { 
        // TODO Auto-generated catch block 
        e.printStackTrace(); 
       } 
      } 
      Integer x = objQueue.first(); 
      if (x != null) { 
       objQueue.remove(x); 
       ++i; 
      } 
     } 
    } 

EDIT: -

 while (i < 2000000) { 
     synchronized (objQueue) { 
      objQueue.add(i); 
      ++i; 
      objQueue.notify(); 
     } 
    } 

Para LinkedBlockingQueue: -

 while (i < 2000000){ 
     try { 
      objQueue.put(i); 
      ++i; 
     } catch (InterruptedException e) { 
      // TODO Auto-generated catch block 
      Thread.currentThread().interrupt(); 
     } 
    } 

     while (i < 2000000) { 
     try { 
      objQueue.take(); 
      ++i; 

     } catch (InterruptedException e) { 
      // TODO Auto-generated catch block 
      Thread.currentThread().interrupt(); 
     } 
    } 

Para LinkedList: código similar con sincronizado.

las preguntas: -

1) Cuando he medido el rendimiento a través de Visual VM, he observado que la del código del productor, TreeSet se comporta mejor que LinkedBlockingQueue y LinkedList, a pesar de que toma O (log el tiempo n) , la creación de objetos en estructuras vinculadas es una sobrecarga significativa. ¿Por qué la teoría es bastante diferente de la práctica? ¿Por qué preferimos estructuras vinculadas y de matriz sobre estructuras de árbol en implementaciones de cola?

2) El sincronizado aparece como un ganador claro frente a ReeentrantLock porque TreeSet funcionó mejor que LinkedList, que tuvo un mejor rendimiento que LinkedBlockingQueue. Desearía poder adjuntar los resultados de Visual VM. No es en votos con el artículo, http://www.ibm.com/developerworks/java/library/j-jtp10264/index.html

Las operaciones se realizan en

Dell Vostro 1015, core 2 duo 2,10, 2 GB Ram con el sistema operativo de 32 bits y con

JVM: Java HotSpot (TM) VM cliente (20.1-b02, modo mixto) Java: la versión 1.6.0_26, proveedor de Sun Microsystems Inc.

Answer 1

1.ReentrantLock podría ser más propensos a utilizar si es necesario implementar un hilo que atraviesa una lista enlazada, bloquea el siguiente nodo y luego desbloquea el nodo actual.

2.Synchronized palabra clave es apto en situación como engrosamiento de bloqueo, proporciona hilado de adaptación, de bloqueo parcial y el potencial de elision de bloqueo a través de análisis de escape. Esas optimizaciones no están implementadas actualmente para ReentrantLock.

Para una comparación de rendimiento adecuado ver esto:

http://lycog.com/concurency/performance-reentrantlock-synchronized/

Answer 2

1. Debido a que su punto de referencia es defectuoso: en un caso de uso real, el tiempo necesario para producir y consumir los elementos de la cola es mucho más importante que el tiempo que lleva agregar y eliminar un elemento de la cola o desde ella. Por lo tanto, el rendimiento bruto de la cola no es tan importante. Por cierto, el código solo muestra cómo tomar elementos de la primera implementación de la cola y no cómo los agrega. Además, la elección de la estructura adecuada no se basa en el rendimiento, sino en el comportamiento. Si quieres algo concurrente, eliges una cola de bloqueo, porque está implementada para ti y no tiene errores como tu código. Si desea FIFO (que a menudo es lo que desea), no elegirá un TreeSet.

2. Si desea comparar sincronización frente a ReentrantLock, no debe utilizar una estructura de datos para uno y otra estructura de datos para el otro. ReentrantLock solía ser más rápido, pero están en el mismo nivel, hoy en día (si creo lo que dice Brian Goetz en JCIP). De todos modos, elegiría uno sobre el otro por razones de seguridad/capacidad. No por motivos de rendimiento.