La copia del código es la siguiente:
paquete com.yao;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.future;
import java.util.concurrent.locks.lock;
import java.util.concurrent.locks.readwriteLock;
import java.util.concurrent.locks.reentrantlock;
import java.util.concurrent.locks.reentrantreadwriteLock;
/**
* Casilleros
* Un concepto importante en la programación multiproceso es el bloqueo.
* Al realizar operaciones transaccionales, el recurso compartido debe bloquearse, lo que asegura que solo un hilo pueda operar en el recurso al realizar operaciones transaccionales.
* Esto garantiza la integridad de los datos. Antes de 5.0, la función de bloqueo se implementó mediante la palabra clave sincronizada.
*/
Lockers de clase pública {
/**
* Prueba el uso del bloqueo. El uso de bloqueo en el método puede evitar usar la palabra clave sincronizada.
*/
Public Static Class Locktest {
Bloqueo de bloqueo = nuevo reentrantlock (); // bloquear
valor doble = 0d;
int addTimes = 0;
/**
* Aumentar el valor del valor.
* Por lo tanto, el método debe ser sincronizado, la práctica anterior era usar la palabra clave sincronizada en la declaración del método.
*/
public void addValue (Double V) {
Lock.lock (); // Obtener el bloqueo
System.out.println ("Locktest a AddValue:" + V + ""
+ System.CurrentTimemillis ());
intentar {
Thread.sleep (1000);
} capt (interruptedException e) {
}
this.Value += V;
this.addtimes ++;
Lock.unlock (); // libera el bloqueo
}
público doble getValue () {
devolver este.value;
}
}
public static void twitlockTest () lanza la excepción {
Final Locktest Locktest = new LockTest ();
// Cree una nueva tarea 1 y llame al método addValue de Locktest
Runnable tarea1 = new runnable () {
public void run () {
LockTest.addValue (55.55);
}
};
// Crear nueva Tarea 2 y llamar al método GetValue de Locktest
Runnable task2 = new runnable () {
public void run () {
System.out.println ("Valor:" + LockTest.getValue ());
}
};
// crear un nuevo servicio de ejecución de tareas
EjecutorService CachedService = Ejecutors.NewCachedThreadPool ();
Futuro futuro = nulo;
// Ejecutar la tarea 1 tres veces al mismo tiempo.
para (int i = 0; i <3; i ++) {
futuro = Cachedservice.submit (Tarea1);
}
// Espere a que se ejecute la última tarea 1
futuro.get ();
// Ejecutar la Tarea 2 nuevamente para obtener el resultado
futuro = Cachedservice.submit (Tarea2);
// Después de esperar que se ejecute la Tarea 2, cierre el servicio de ejecución de la tarea
futuro.get ();
Cachedservice.shutdownnow ();
}
/**
* ReadWriteLock tiene dos cerraduras incorporadas, una es el bloqueo de lectura y el otro es el bloqueo escrito.
* Múltiples hilos pueden obtener bloqueos de lectura al mismo tiempo, pero solo un hilo puede obtener bloqueos escritos.
* Y después de que se bloquee el bloqueo escrito, ningún hilo puede obtener el bloqueo. Los métodos proporcionados por ReadWriteLock son:
* Readlock (): devuelve un bloqueo de lectura
* WriteLock (): Devuelve un bloqueo escrito, este bloqueo es exclusivo.
* ReadWriteLockTest es muy adecuado para manejar operaciones de lectura y escritura de archivos similares.
* Puede leer al mismo tiempo al leer, pero no puede escribir;
*/
clase pública estática ReadWriteLockTest {
// Cerrar
ReadWriteLock Lock = new ReEntantReadWriteLock ();
// Valor
valor doble = 0d;
int addTimes = 0;
/**
* Aumente el valor del valor y no permita que múltiples subprocesos ingresen el método al mismo tiempo.
*/
public void addValue (Double V) {
// Get WriteLock y Lock
LOCK WRITELOCK = LOCK.WriteLock ();
writeLock.lock ();
System.out.println ("ReadWriteLockTest a addValue:" + V + ""
+ System.CurrentTimemillis ());
intentar {
Thread.sleep (1000);
} capt (interruptedException e) {
}
intentar {
// hacer el trabajo de escritura
this.Value += V;
this.addtimes ++;
} finalmente {
// lanza el bloqueo de WriteLock
writeLock.unlock ();
}
}
/**
* Obtener información. Cuando un hilo llama al método AddValue, la información obtenida por GetInfo puede ser incorrecta.
* Por lo tanto, también es necesario asegurarse de que cuando se llame el método, ningún método llame al método addValue.
*/
public String getInfo () {
// Obtén Readlock y bloqueo
Lock ReadLock = Lock.ReadLock ();
readlock.lock ();
System.out.println ("ReadWriteLockTest para getInfo"
+ System.CurrentTimemillis ());
intentar {
Thread.sleep (1000);
} capt (interruptedException e) {
}
intentar {
// Haz el trabajo de lectura
devolver esto.value + ":" + this.addtimes;
} finalmente {
// lanza Readlock
readLock.unlock ();
}
}
}
public static void testreadwriteLockTest () lanza la excepción {
ReadwriteReLockTest final ReadWriteLockTest = new ReadWriteLockTest ();
// Cree una nueva tarea 1 y llame al método addValue de Locktest
Runnable task_1 = new runnable () {
public void run () {
readWriteLockTest.addValue (55.55);
}
};
// Crear nueva Tarea 2 y llamar al método GetValue de Locktest
Runnable task_2 = new runnable () {
public void run () {
System.out.println ("Info:" + ReadWriteLockTest.getInfo ());
}
};
// crear un nuevo servicio de ejecución de tareas
EjecutorService CachedService_1 = Ejecutors.newCachedThreadPool ();
Future Future_1 = null;
// ejecutar 5 tareas al mismo tiempo, de las cuales las primeras 2 tareas son tareas_1 y las dos últimas tareas son tareas_2
para (int i = 0; i <2; i ++) {
futuro_1 = Cachedservice_1.submit (tarea_1);
}
para (int i = 0; i <2; i ++) {
futuro_1 = Cachedservice_1.submit (tarea_2);
}
// La última tarea es Task_1
futuro_1 = Cachedservice_1.submit (tarea_1);
// La orden de ejecución de estas 5 tareas debe ser:
// La primera tarea_1 se ejecuta primero, y la segunda tarea_1 se ejecuta nuevamente;
// luego dos tareas_2 se ejecutan al mismo tiempo;
// porque se pueden leer al mismo tiempo, se ejecutan al mismo tiempo
// La última tarea_1 se ejecuta nuevamente. Esto se debe a que no puede escribir al leer, por lo que debe esperar hasta que termine la lectura antes de poder escribir.
// Espere a que se ejecute la última tarea_2
futuro_1.get ();
Cachedservice_1.shutdownnow ();
}
public static void main (string [] args) lanza la excepción {
Lockers.TestLockTest ();
System.out.println ("---------------------");
Lockers.TestreadWriteLockTest ();
}
}