¿Qué es el marco de concurrencia de Java?

El marco de concurrencia de Java java.util.concurrent se introdujo en la biblioteca estándar en JDK5 (utilizando la biblioteca de concurrencia de Doug

Lea). Las clases de este paquete se pueden dividir en los siguientes bloques:

Ejecutor

1) Interfaz:

Ejecutor (involucrado en el ejemplo): utilizado para ejecutar El objeto de tarea ejecutable enviado. Es una interfaz estandarizada simple para definir grupos de subprocesos, IO asincrónica, marcos de tareas livianos, etc. Las tareas pueden ser ejecutadas por un subproceso recién creado, un subproceso de ejecución de tareas existente o un subproceso que llama a ejecutar () directamente. La ejecución puede ser en serie o en paralelo, según la clase concreta de Ejecutor que se utilice.

ExecutorService (ejemplo involucrado): una subinterfaz de Executor que proporciona un marco más específico para la ejecución de tareas asincrónicas: proporciona métodos para gestionar cierres y la capacidad de generar futuros para rastrear el progreso de las tareas asincrónicas. . ExcutorService gestiona las colas de tareas y la programación de tareas.

ScheduledExecutorService (relativo a ejemplos): una subinterfaz de ExecutorService que agrega soporte para la ejecución de tareas periódicas y diferidas.

Invocable (ejemplo): una tarea que devuelve un resultado o genera una excepción. La clase de implementación necesita implementar uno de los métodos de llamada sin parámetros. Callabe es similar a Runnable, pero Runnable no devuelve resultados y no puede generar excepciones marcadas. ExecutorService proporciona métodos para programar la ejecución asincrónica invocable.

Futuro (ejemplo): representa el resultado de un cálculo asincrónico (debido a la ejecución concurrente, el resultado se puede calcular después de un período de tiempo, que probablemente es lo que significa el nombre) y proporciona métodos para determinar si la ejecución se ha completado y cancelado el método de ejecución.

2) Implementación:

ThreadPoolExecutor y ScheduledThreadPoolExecutor: grupo de subprocesos configurable (este último tiene capacidades de programación retrasada o periódica).

Ejecutores (relacionados con ejemplos): proporciona métodos de fábrica y de utilidad para Executor, ExecutorService, ScheduledExecutorService, ThreadFactory y Callable.

FutureTask: Implementación de Future

ExecutorCompletionService (con ejemplos): ayuda a coordinar el procesamiento de múltiples (grupos) de tareas asincrónicas.

Cola

Cola sin bloqueo: la clase ConcurrentLinkedQueue proporciona una cola FIFO sin bloqueo, escalable, eficiente y segura para subprocesos.

Blocking Queue: La interfaz BlockingQueue tiene cinco clases de implementación: LinkedBlockingQueue (con ejemplos), ArrayBlockingQueue, SynchronousQueue, PriorityBlockingQueue y DelayQueue. Corresponden a diferentes contextos de aplicación: productores/consumidores, mensajería, tareas concurrentes y diseños de concurrencia relacionados.

Timing

Clase TimeUnit (a la que se hace referencia en el ejemplo): proporciona una amplia gama de granularidad de tiempo (incluidos nanosegundos) para expresar y controlar operaciones basadas en tiempo de espera.

Los sincronizadores proporcionan sincronización específica del contexto

Semáforo (con ejemplos): conteo de semáforos, una herramienta de concurrencia clásica.

CountDownLatch (ejemplo involucrado): una herramienta simple de sincronización de cuenta regresiva que permite que uno o más subprocesos esperen hasta que se haya procesado un conjunto de operaciones en otros subprocesos.

CyclicBarrier (relativo a ejemplos): herramienta de sincronización multiplex reiniciable y reutilizable (CountDownLatch no es reutilizable).

Swapter: permite que dos hilos intercambien objetos en el punto de encuentro, lo cual es muy útil en ciertos diseños de tuberías.

Colecciones concurrentes

Además de las colas, este paquete también proporciona una serie de implementaciones de colecciones diseñadas específicamente para contextos multiproceso:

Nota: el prefijo es ​​Las clases "concurrentes" son diferentes de las clases con el prefijo "sincronización". Las colecciones "concurrentes" son seguras para subprocesos y no requieren control de bloqueo de una sola fila (sin bloqueo). Por ejemplo, ConcurrentHashMap permite cualquier cantidad de lecturas simultáneas y una cantidad ajustable de escrituras simultáneas. Por lo general, pasar un único Locks bloquea todo el acceso a la colección, lo que no solo es costoso sino también poco escalable.