Introducción al uso de BlockingQueue basado en java

Autor：Eve Cole Fecha de actualización：2024-11-18 14:48:02

Recientemente estoy manteniendo un proyecto Java y en el grupo estamos charlando sobre los pros y los contras de Java. Desafortunadamente, algunos fanáticos de Java siempre afirman que el rendimiento ya no es tan malo como el de C ++, y muchas bibliotecas estándar están escritas por maestros, cuán estables son, etc. Simplemente lo estudié detenidamente, y una de las instrucciones que me dieron fue que para entregar mensajes entre hilos basta con usar BlockingQueue, que ha sido encapsulado en java.

Como es suficiente, escribamos código para probarlo. Simplemente escriba un pequeño programa y haga algunas pruebas:

Copie el código de código de la siguiente manera:

//Paquete predeterminado
importar java.util.concurrent.*;

importar base.MyRunnable;

prueba de clase pública
{
principal vacío estático público (String [] argumentos)
{
Cola BlockingQueue<Integer> = new LinkedBlockingQueue<Integer>();
java.lang.Runnable r = new MyRunnable(cola);
Hilo t = nuevo hilo (r);
t.start();

mientras (verdadero)
{
intentar
{
mientras (verdadero)
{
para(int i =0;i < 10000;i++)
{
cola.oferta(i);
}
}
}
captura (Excepción e)
{
e.printStackTrace();
}
}
}
}

//Paquetes que deben agregarse
base del paquete;

importar java.lang.Runnable;
importar java.util.concurrent.*;
importar java.util.*;

clase pública MyRunnable implementa Runnable
{
público MyRunnable (cola BlockingQueue<Integer>)
{
this.queue = cola;
}
ejecución pública vacía()
{
Fecha d = nueva Fecha();
hora de inicio larga = d.getTime();
System.err.println(hora de inicio);
recuento int = 0;
mientras (verdadero)
{
intentar
{
Entero i = this.queue.poll();
si (yo! = nulo)
{
contar++;
}
si (cuenta == 100000)
{
Fecha e = nueva fecha();
hora de finalización larga = e.getTime();
System.err.println(recuento);
System.err.println(hora de finalización);
System.err.print(hora de finalización - hora de inicio);
romper;
}

}
captura (Excepción e)
{

}
}
}
cola privada BlockingQueue<Integer>;
}

Para transferir 100.000 datos, se necesitan unos 50 ms en mi máquina de prueba, ¡lo cual no está mal! Basta con echar un vistazo a la implementación subyacente de BlockingQueue.

Utilicé oferta y encuesta en el código de prueba anterior. Echemos un vistazo a estas dos funciones de implementación.

Copie el código de código de la siguiente manera:

encuesta pública E() {
recuento final de AtomicInteger = this.count;
si (count.get() == 0)
devolver nulo;
E x = nulo;
int c = -1;
final ReentrantLock takeLock = this.takeLock;
tomarLock.lock();
intentar {
si (count.get() > 0) {
x = extraer();
c = contar.getAndDecrement();
si (c > 1)
notEmpty.signal();
}
} finalmente {
tomarLock.desbloquear();
}
si (c == capacidad)
señalNotFull();
devolver x;
}

Es similar a un hilo de sincronización general, excepto que se agrega una señal más. Cuando aprendí programación avanzada en el entorno Unix, vi que las variables de condición se usan para la sincronización entre hilos, ¡y los hilos se pueden sincronizar de manera competitiva!
¡La implementación de la función de encuesta es similar!

Copie el código de código de la siguiente manera:

oferta booleana pública (E e) {
if (e == null) lanza una nueva NullPointerException();
recuento final de AtomicInteger = this.count;
si (count.get() == capacidad)
devolver falso;
int c = -1;
final ReentrantLock putLock = this.putLock;
putLock.lock();
intentar {
si (count.get() < capacidad) {
insertar(e);
c = contar.getAndIncrement();
si (c + 1 < capacidad)
notFull.señal();
}
} finalmente {
putLock.desbloquear();
}
si(c==0)
señalNotEmpty();
devolver c >= 0;
}