Java Language Serrures comme aides à la synchronisation


Exemple

Avant l'introduction du package simultané de Java 5, le thread était de niveau inférieur. L'introduction de ce package fournissait plusieurs aides / constructions de programmation concurrentes de niveau supérieur.

Les verrous sont des mécanismes de synchronisation de threads qui ont essentiellement le même objectif que les blocs synchronisés ou les mots-clés.

Verrouillage intrinsèque

int count = 0; // shared among multiple threads

public void doSomething() {
    synchronized(this) {
        ++count; // a non-atomic operation
    }
}

Synchronisation à l'aide de verrous

int count = 0; // shared among multiple threads

Lock lockObj = new ReentrantLock();
public void doSomething() {
    try {
        lockObj.lock();
        ++count; // a non-atomic operation
    } finally {    
        lockObj.unlock(); // sure to release the lock without fail
    }
}

Les verrous ont également des fonctionnalités disponibles que le verrouillage intrinsèque n'offre pas, telles que le verrouillage, mais en restant réactif aux interruptions, ou en essayant de se verrouiller, et non de bloquer le cas échéant.

Verrouillage, sensible aux interruptions

class Locky {
    int count = 0; // shared among multiple threads

    Lock lockObj = new ReentrantLock();

    public void doSomething() {
        try {
            try {
                lockObj.lockInterruptibly();
                ++count; // a non-atomic operation
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // stopping
            }
        } finally {
            if (!Thread.currentThread().isInterrupted()) {
                lockObj.unlock(); // sure to release the lock without fail
            }
        }
    }
}

Ne fais quelque chose que lorsque tu es capable de verrouiller

public class Locky2 {
    int count = 0; // shared among multiple threads

    Lock lockObj = new ReentrantLock();

    public void doSomething() {
        boolean locked = lockObj.tryLock(); // returns true upon successful lock
        if (locked) {
            try {
                ++count; // a non-atomic operation
            } finally {
                lockObj.unlock(); // sure to release the lock without fail
            }
        }
    }
}

Il existe plusieurs variantes de verrouillage disponibles .