La biblioteca de clases java.util.concurrent de java SE5 también contiene un mecanismo de exclusión mutua explícito definido en java.util.concurrent.locks. El objeto de bloqueo debe crearse, bloquearse y liberarse explícitamente.
Lo siguiente reescribe EvenGenerator con un bloqueo explícito:
public class MutexEvenGenerator extends IntGenerator{
private int currentEvenValue=0;
private Lock lock=new ReentrantLock();
@Override
public int next() {
// TODO Auto-generated method stub
lock.lock();
try {
++currentEvenValue;
Thread.yield();
++currentEvenValue;
return currentEvenValue;
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
EvenChecker.test(new MutexEvenGenerator());
}
}
MutexEvenGenerator agrega un bloqueo que se llama mutuamente excluyente y usa los métodos lock () y unlock () para crear recursos críticos dentro de next (). La declaración de retorno debe colocarse en la cláusula try para garantizar que unlock () no se produzca de forma prematura, exponiendo los datos a la segunda tarea .
public class AttempLocking {
private ReentrantLock lock=new ReentrantLock();
public void untimed() {
boolean captured=lock.tryLock();
try {
System.out.println("tryLock(): "+captured);
}finally {
if(captured) {
lock.unlock();
}
}
}
public void timed() {
boolean captured=false;
try {
captured=lock.tryLock(2,TimeUnit.SECONDS);
}catch(InterruptedException e) {
throw new RuntimeException(e);
}
try {
System.out.println("tryLock(2,TIMEUNIT.SECONDS): "+captured);
}finally {
if(captured) {
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
// TODO Auto-generated method stub
final AttempLocking al=new AttempLocking();
al.untimed();
al.timed();
new Thread() {
public void run() {
al.lock.lock();
System.out.println("aquired");
}
}.start();
// Thread.yield();
Thread.sleep(1000);
al.untimed();
al.timed();
}
}
/*
*tryLock(): true
tryLock(2,TIMEUNIT.SECONDS): true
aquired
tryLock(): false
tryLock(2,TIMEUNIT.SECONDS): false
*/
ReentrantLock le permite intentar adquirir pero no adquirir el bloqueo , por lo que si alguien más ha adquirido el bloqueo, puede decidir salir para realizar otra cosa en lugar de esperar hasta que se libere el bloqueo, como en el método untime () Como se vio en. Se intenta adquirir el bloqueo en el tiempo () y el intento puede fallar después de 2 segundos.
El objeto Lock explícito también le brinda un control más detallado en términos de bloqueo y liberación de bloqueos, en comparación con el bloqueo sincronizado incorporado .