Estaba implementando una cola FIFO de instancias de solicitudes (objetos de solicitud preasignados para velocidad) y comencé a usar la palabra clave "sincronizada" en el método add. El método fue bastante corto (verifique si hay espacio en el búfer de tamaño fijo, luego agregue valor a la matriz). Usando visualVM parecía que el hilo estaba bloqueando más a menudo de lo que me gustaba ("monitor" para ser precisos). Así que convertí el código para usar valores AtomicInteger para cosas como hacer un seguimiento del tamaño actual, luego usar compareAndSet () en bucles while (como AtomicInteger lo hace internamente para métodos como incrementAndGet ()). El código ahora parece bastante más largo.

Lo que me preguntaba es cuál es la sobrecarga de rendimiento del uso de código sincronizado y más corto versus código más largo sin la palabra clave sincronizada (por lo que nunca debería bloquearse en un bloqueo).

Aquí está el antiguo método get con la palabra clave sincronizada:

public synchronized Request get()
{
    if (head == tail)
    {
        return null;
    }
    Request r = requests[head];
    head = (head + 1) % requests.length;
    return r;
}

Aquí está el nuevo método get sin la palabra clave sincronizada:

public Request get()
{
    while (true)
    {
        int current = size.get();
        if (current <= 0)
        {
            return null;
        }
        if (size.compareAndSet(current, current - 1))
        {
            break;
        }
    }

    while (true)
    {
        int current = head.get();
        int nextHead = (current + 1) % requests.length;
        if (head.compareAndSet(current, nextHead))
        {
            return requests[current];
        }
    }
}

Supongo que la palabra clave sincronizada es peor debido al riesgo de bloqueo en el bloqueo (lo que puede causar cambios de contexto de hilo, etc.), aunque el código es más corto.

¡Gracias!