1. ¿Qué es FIFO?
FIFO ( primero en entrar , primero en salir ) es una estructura de datos común, también llamada cola de primeros en entrar, primeros en salir . Su característica es que los datos que entran primero en la cola salen primero.
Similar a la escena de hacer cola para comprar cosas en la realidad, los que llegan primero hacen la fila primero y los que compran los productos primero se van primero.
En el campo de la informática, FIFO se usa a menudo en escenarios como la gestión de caché y la programación de procesos.
En la gestión de caché, los datos que ingresan primero a la caché se reservarán primero y los datos que ingresen después se eliminarán; en la programación de procesos, el proceso que ingresa primero a la cola y espera a que los recursos de la CPU se asignen a la CPU para ejecutarse primero.
2. Java implementa el algoritmo FIFO
1. Esquema 1
import java.util.LinkedList;
public class FIFOQueue<T> {
private final LinkedList<T> queue = new LinkedList<T>();
private final int maxSize;
public FIFOQueue(int maxSize) {
this.maxSize = maxSize;
}
public void add(T item) {
if (queue.size() >= maxSize) {
queue.removeFirst();
}
queue.addLast(item);
}
public T remove() {
return queue.removeFirst();
}
public boolean isEmpty() {
return queue.isEmpty();
}
public int size() {
return queue.size();
}
public T peek() {
return queue.peek();
}
}
El código anterior usa LinkedList como la implementación subyacente y define una clase FIFOQueue, que admite operaciones como agregar y eliminar elementos, juzgar si la cola está vacía, obtener la longitud de la cola y obtener el elemento al principio de la cola. .
Entre ellos, maxSize es la capacidad máxima de la cola. Cuando el número de elementos de la cola alcanza la capacidad máxima, los primeros elementos agregados se eliminarán al agregar nuevos elementos.
El método removeFirst() y el método addLast() de LinkedList se utilizan aquí para garantizar que el elemento que encabeza la cola sea el primer elemento agregado a la cola.
Ejemplo de uso:
public class Test {
public static void main(String[] args) {
FIFOQueue<String> queue = new FIFOQueue<>(5);
queue.add("a");
queue.add("b");
queue.add("c");
System.out.println(queue.remove()); // 输出：a
System.out.println(queue.peek()); // 输出：b
System.out.println(queue.size()); // 输出：2
queue.add("d");
queue.add("e");
queue.add("f");
System.out.println(queue.remove()); // 输出：b
}
}
El código anterior demuestra cómo crear un objeto FIFOQueue, agregar y eliminar elementos y obtener información sobre el estado de la cola y otras operaciones.
Entre ellos, el elemento "a" que se añade primero se saca de la cola primero, y el elemento "f" que se añade después se saca de la cola el último.
2. Esquema 2
import java.util.LinkedList;
public class FIFOCache<K, V> {
private final int capacity;
private final LinkedList<K> keyList;
private final Map<K, V> cacheMap;
public FIFOCache(int capacity) {
this.capacity = capacity;
this.keyList = new LinkedList<>();
this.cacheMap = new HashMap<>();
}
public synchronized void put(K key, V value) {
if (keyList.size() == capacity) {
K removedKey = keyList.removeFirst();
cacheMap.remove(removedKey);
}
keyList.addLast(key);
cacheMap.put(key, value);
}
public synchronized V get(K key) {
return cacheMap.get(key);
}
}
En el código anterior, la clase LinkedList de Java se usa para mantener una lista de claves secuenciales, y el almacenamiento de valores clave en caché se implementa a través de la interfaz Map de Java.
Cuando la memoria caché esté llena, elimine el elemento más antiguo de la cola y elimine el par clave-valor correspondiente de la memoria caché. Al obtener un valor almacenado en caché, obtenga el valor correspondiente directamente del caché.
Cabe señalar que en un entorno de subprocesos múltiples, la palabra clave sincronizada debe agregarse para garantizar la seguridad del subproceso.
Al mismo tiempo, dado que la implementación de LinkedList y HashMap no es segura para subprocesos, es necesario usar clases de colección seguras para subprocesos para reemplazarlas en un entorno de subprocesos múltiples.