No hay mucho que decir, solo ve al código: la
primera clase de herramienta CountDownLatch:
CountDownLatch: CountDownLatch tiene principalmente dos métodos, cuando uno o más subprocesos llaman al método await, el subproceso de escritura se bloqueará. Cuando otros hilos llaman al método CountDownLatch, el contador se reducirá en 1 (el hilo que llama al método CountDownLatch no se bloqueará). Cuando el valor del contador sea 0, el hilo bloqueado por el método await se despertará y continuará la ejecución.
Tomemos un ejemplo a modo de comparación: 10 personas salen por la puerta y luego cierran la puerta.
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "出来了");
}, String.valueOf(i)).start();
}
System.out.println("锁门");
}
// 0出来了
// 锁门
// 3出来了
// 2出来了
// 1出来了
// 5出来了
// 6出来了
// 4出来了
// 8出来了
// 7出来了
// 9出来了
Obviamente no podemos hacerlo ¿Cómo podemos estar seguros de que la puerta está cerrada cuando salen las 10 personas?
En este momento, podemos usar nuestro
código CountDownLatch de la primera clase de herramienta de la siguiente manera:
CountDownLatch countDownLatch = new CountDownLatch(10);
for (int i = 0; i < 10; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "出来了");
countDownLatch.countDown();
}, String.valueOf(i)).start();
}
countDownLatch.await(); //减到0才继续
System.out.println("锁门");
// 0出来了
// 3出来了
// 1出来了
// 2出来了
// 4出来了
// 5出来了
// 7出来了
// 6出来了
// 8出来了
// 9出来了
// 锁门
Si no se reduce a 0, ¡siempre estará bloqueado aquí!
La segunda clase de herramienta CyclicBarrier:
CyclicBarrier es similar a la primera, podemos mirar su constructor:
CyclicBarrier(int parties, Runnable barrierAction)
创建一个新的 CyclicBarrier ，当给定数量的线程（线程）等待时，它将跳闸，当屏障跳闸时执行给定的屏障动作，由最后一个进入屏障的线程执行。
Siguiente en el código.
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(10, () -> {
System.out.println("锁门");
});
for (int i = 0; i < 10; i++) {
int finalI = i;
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "第" + finalI + "出门");
try {
cyclicBarrier.await();
System.out.println(finalI);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}, String.valueOf(i)).start();
}
}
El resultado es el siguiente:
Podemos encontrar que todos los subprocesos están bloqueados aquí por el método await (). Cuando un número determinado de subprocesos (subprocesos) están esperando, se disparará. Cuando la barrera se dispara, se ejecutará la acción de barrera dada y entrará el último. Ejecución del hilo de la barrera.
La tercera clase de herramienta Semaphore:
Imagine una escena donde hay plazas de aparcamiento. Si hay 3 o 6 plazas de aparcamiento, el código es el siguiente:
public class SemaphoreDemo {
public static void main(String[] args) {
Semaphore semaphore= new Semaphore(3);//模拟资源类，有3个空车位 为1的时候相当于synchronized
for(int i=0;i<6;i++){
new Thread(()->{
try {
semaphore.acquire(); //占用
System.out.println(Thread.currentThread().getName()+"\t抢占到了车位");
Thread.sleep(3000);
System.out.println(Thread.currentThread().getName()+"\t离开了车位");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore.release();//交还车位
}
},String.valueOf(i)).start();
}
}
}
Los resultados de la ejecución son los siguientes:
Definimos dos operaciones en el semáforo:
- adquirir (adquisición) Cuando un hilo llama a la operación de adquisición, debe adquirir con éxito el semáforo (el semáforo menos 1), o esperar hasta que sepa que un hilo
suelta el semáforo o se despierta - El lanzamiento en realidad agrega 1 al valor del semáforo y luego despierta el hilo en espera.
Los semáforos se utilizan principalmente para dos propósitos, uno es adecuado para el uso mutuamente exclusivo de múltiples recursos compartidos y el otro es adecuado para el control del número de subprocesos simultáneos