StampedLock bloqueo optimista bloqueo pesimista del componente de sincronización de trama JUC-AQS

StampedLock java1.8 proporciona un mejor rendimiento que ReadWriteLock.

Bloqueo optimista

El bloqueo optimista es una idea optimista, es decir, leer más y escribir menos, y encontrar escrituras concurrentes 可能性低(no sin, por lo que también debe bloquearse, que es diferente de la lectura optimista sin bloqueo). Cada vez que voy a obtener datos, creo que otros No se modificará, por lo que no se bloqueará, pero cuando se actualice, se juzgará si otros han actualizado estos datos durante este período. Tome la primera lectura de la corriente al escribir 版本号y luego agregue la operación de bloqueo (compare con el número de versión anterior , Si es lo mismo, actualizar), si falla, repita la operación de lectura-comparación-escritura. Todo lo básico en
　　
Java 乐观锁se realiza a través de CASoperaciones. CAS es una operación atómica de actualización. Compara si el valor actual es el mismo que el valor entrante. Si es el mismo, se actualiza, de lo contrario falla.

Cerradura pesimista

Un bloqueo pesimista es un pensamiento pesimista, es decir, pensar que hay demasiada escritura, y cuando escribe concurrentemente 可能性高, cada vez que va a obtener datos, cree que otros lo modificarán, por lo que cada vez que lea y escriba datos, lo bloqueará, por lo que otros quieren leer y escribir Los datos se bloquearán hasta que se obtenga el bloqueo.java中的悲观锁就是Synchronized

    final StampedLock sl = new StampedLock();
 
    /**
     * 悲观读锁
     * 与ReadWriteLock的读锁相似
     * 允许多个线程进行读操作
     * 与写锁互斥
    **/
    //获取悲观锁
    long stamp = sl.readLock();
    try {
      //。。。。
    }finally {
         sl.unlockRead(stamp);
       }


    /**
     * 写锁
     * 与ReadWriteLock的写锁相似
     * 只允许一个线程进行写操作
     * 与读锁互斥
    **/
     //获取写锁
    long stamp1 = sl.writeLock();
    try{
        //。。。
    }finally {
        //释放写锁
        sl.unlockWrite(stamp1);
    }


    /**
     * 乐观读锁升级为悲观读
     * 锁的严苛程度变强叫做升级，反之叫做降级
    **/
    //获取乐观锁
     long stamp = sl.tryOptimisticRead();
     //判断执行读操作期间,是否存在写操作,如果存在则sl.validate返回false
    if (!sl.validate(stamp)){
        //升级为悲观锁
        stamp = sl.readLock();
        try{
            //。。。
        }finally {
            //释放悲观读锁
            sl.unlockRead(stamp);
        }

Gramática

final StampedLock sl = new StampedLock();
 
/**
 * 悲观读锁
 * 与ReadWriteLock的读锁相似
 * 允许多个线程进行读操作
 * 与写锁互斥
**/
//获取悲观锁
long stamp = sl.readLock();
try {
  //。。。。
}finally {
     sl.unlockRead(stamp);
   }


/**
 * 写锁
 * 与ReadWriteLock的写锁相似
 * 只允许一个线程进行写操作
 * 与读锁互斥
**/
 //获取写锁
long stamp1 = sl.writeLock();
try{
    //。。。
}finally {
    //释放写锁
    sl.unlockWrite(stamp1);
}


/**
 * 乐观读锁升级为悲观读
 * 锁的严苛程度变强叫做升级，反之叫做降级
**/
//获取乐观锁
 long stamp = sl.tryOptimisticRead();
 //判断执行读操作期间,是否存在写操作,如果存在则sl.validate返回false
if (!sl.validate(stamp)){
    //升级为悲观锁
    stamp = sl.readLock();
    try{
        //。。。
    }finally {
        //释放悲观读锁
        sl.unlockRead(stamp);
    }

La lectura optimista proporcionada por StampedLock permite que un hilo adquiera un bloqueo de escritura, lo que significa que no todas las operaciones de escritura están bloqueadas.
La lectura optimista no es lo mismo que el bloqueo optimista. El funcionamiento de la lectura optimista es sin bloqueo. La lectura optimista piensa que no habrá operación de escritura al leer.

Ejemplos

import java.util.concurrent.locks.StampedLock;

/**
 * 悲观锁乐观锁
 **/
public class Point {
    private int x;
    private int y;
    final StampedLock sl = new StampedLock();

    //计算到原点的距离
    int distanceFromOrigin() throws  Exception{
        //乐观锁
        long stamp = sl.tryOptimisticRead();
        //读入局部变量,读的过程数据可能被修改
        int curX = x;
        int curY = y;

        //判断执行读操作期间,是否存在写操作,如果存在则sl.validate返回false
        if (!sl.validate(stamp)){
            //升级为悲观锁
            stamp = sl.readLock();
            try{
                curX = x;
                curY = y;
            }finally {
                //释放悲观读锁
                sl.unlockRead(stamp);
            }
        }

        return (int)Math.sqrt(curX*curX + curY*curY);
    }
}

1. StampedLockEs compatible con tres 写锁modos: , 悲观读y 乐观读.
2. Permita que varios subprocesos adquieran bloqueos optimistas y bloqueos de lectura pesimistas simultáneamente.
3. Solo un hilo puede adquirir el bloqueo de escritura, 写锁y 悲观读锁sí 互斥.
4. Cuando utilice StampedLock, no debe llamar a la operación de interrupción. Si necesita admitir la función de interrupción, debe usar 可中断的悲观读锁 readLockInterruptibly()y escribir el bloqueo writeLockInterruptibly().
5. Después del éxito 写锁y el 悲观读锁bloqueo en StampedLock , lo será 返回一个stamp; luego 解锁, debe pasar esto stamp.
6. StampedLock 不支持重入(soporte ReadWriteLock).
7. Los bloqueos de lectura y escritura pesimistas de StampedLock no admiten variables de condición.
8. StampedLock admite la degradación de bloqueo (mediante el método tryConvertToReadLock ()) y la actualización (mediante el método tryConvertToWriteLock ()), pero se recomienda que lo use con cuidado.

Bloqueo optimista en la base de datos.

1. Agregue una 版本号versión de campo numérico en la tabla .
2. Cada vez que se actualiza la tabla, el campo de versión se incrementa en 1.
3. Al modificar los datos, use la clave primaria y la versión como condiciones de modificación, version一致se modificará 成功.
4. Si la modificación falla, 主键查询获取最新数据realice la modificación nuevamente.