HOWTO · Java
Colecciones seguras para subprocesos en Java
Este tutorial analiza varias clases de colección seguras para subprocesos a través de ejemplos de código en Java.
En Java, un thread-safe es una clase que garantiza el estado interno de la clase y que los valores de los métodos son correctos mientras se invocan múltiples hilos simultáneamente.
Este tutorial analiza diferentes clases de colección a través de ejemplos de código que son seguros para subprocesos en Java.
Colecciones seguras para subprocesos en Java
En Java, las clases de colección thread-safe más populares son Vector, Stack, Hashtable, Properties, etc. Aprendamos cada una de ellas, comenzando con el Vector a continuación.
Clase de colección segura para subprocesos - Vector
El Vector es una matriz de objetos que pueden crecer según sea necesario. Esta clase admite métodos como add(), remove(), get(), elementAt() y size().
Código de ejemplo:
// Importing necessary packages
import java.util.*;
public class JavaVector {
public static void main(String[] arg) {
// Declaring a vector
Vector MyVector = new Vector();
// Adding data to vector
MyVector.add(12);
MyVector.add(3);
MyVector.add("ABC");
MyVector.add(10);
MyVector.add("DEF");
System.out.println("The vector is: " + MyVector);
// Removing data from the vector.
MyVector.remove(1);
System.out.println("The vector after removing an element is: " + MyVector);
}
}
Producción :
The vector is: [12, 3, ABC, 10, DEF]
The vector after removing an element is: [12, ABC, 10, DEF]
Clase de recopilación segura para subprocesos - Pilar
La clase Stack implementa la estructura de datos de la pila. Se basa en el LIFO o Last In First Out. La operación más común de la clase Stack es push(), pop(), empty() y search().
Código de ejemplo:
// Importing necessary packages
import java.util.*;
public class JavaStack {
public static void main(String[] args) {
// Declaring a stack
Stack<Integer> MyStk = new Stack<Integer>();
// Adding data to stack
MyStk.push(5);
MyStk.push(7);
MyStk.push(9);
// POP from the stack
Integer num1 = (Integer) MyStk.pop();
System.out.println("The Popped element is: " + num1);
// PUSH the stack
Integer num2 = (Integer) MyStk.peek();
System.out.println("The top element is: " + num2);
}
}
Producción :
The popped element is: 9
The top element is: 7
Clase de colección Thread Safe - Hashtable
La clase Java Hashtable implementa la tabla hash que asigna las claves a los valores. Además, implementa la interfaz Mapa y hereda el directorio.
Código de ejemplo:
// Importing necessary packages
import java.util.*;
public class JavaHashtable {
public static void main(String args[]) {
// Declaring a HashTable
Hashtable<Integer, String> HTable = new Hashtable<Integer, String>();
// Adding data to HashTable
HTable.put(100, "This");
HTable.put(102, "is");
HTable.put(101, "a");
HTable.put(103, "data");
for (Map.Entry MyMap : HTable.entrySet()) {
// Extracting data and keys from the HashTable
System.out.println(MyMap.getKey() + " " + MyMap.getValue());
}
}
}
Producción :
103 data
102 is
101 a
100 This
Clase de recopilación segura de subprocesos - Synchronize HashMap
Hay una versión sincronizada de HashMap que puede usar como una colección segura para subprocesos en Java. Este HashMap funciona de forma similar a Synchronize HashMap.
Código de ejemplo:
// Importing necessary packages
import java.util.*;
public class JavaHashMap {
public static void main(String[] args) throws Exception {
try {
// Declaring a HashMap
Map<String, String> HMap = new HashMap<String, String>();
// Adding values to the HashMap
HMap.put("1", "This");
HMap.put("2", "is");
HMap.put("3", "a");
HMap.put("4", "sample");
HMap.put("5", "data");
// Printing the value of HashMap
System.out.println("The Map is : " + HMap);
// Synchronizing the HashMap
Map<String, String> SMap = Collections.synchronizedMap(HMap);
// Printing the Collection after synchronizing the HashMap
System.out.println("The synchronized map is : " + SMap);
} catch (IllegalArgumentException e) {
// Printing exception if necessary
System.out.println("Exception thrown : " + e);
}
}
}
Producción :
The Map is : {1=This, 2=is, 3=a, 4=sample, 5=data}
The synchronized map is : {1=This, 2=is, 3=a, 4=sample, 5=data}
