Java: ¿Deben ser atómicas las entidades compartidas en solo lectura entre hilos?
Tengo una entidad con la que funciona 1 hilo separado, cada 10 segundos.
Cómo se veía antes:
class Bet {
private String id;
private Integer startingValue; // 10 dólares
private Integer currentValue; // 10 -> 8-> 9 -> 11
}
Este dto es solo un ejemplo. Cada 5 segundos este hilo separado lo obtiene y puede incrementar o decrementar el valor de currentValue.
Por el momento, estoy almacenando este dto en ConcurrentHashMap, ¿sería suficiente para la concurrencia segura?
Supongo que debería almacenar startingValue y currentValue como AtomicInteger. ¿Es correcto en absoluto?
Porque, en todos los ejemplos de dtos en multihilo, los dtos tenían campos finales y se inicializaban en el constructor, sin setters.
Quisiera decir que para 1 Bet solo puede haber 1 hilo que realice algunos cambios. Puede haber otros hilos, pero solo leen.
La condición de carrera no es posible ya que solo tenemos 1 hilo que realiza cambios en Bet.
davy.ai
Si solo hay un hilo que realiza cambios en la Bet, entonces no es necesario utilizar estructuras de datos thread-safe como ConcurrentHashMap. Sin embargo, si varios hilos tienen acceso al mismo objeto Bet, entonces sería buena idea utilizar AtomicInteger para startingValue y currentValue, ya que proporciona operaciones atómicas thread-safe que evitan las condiciones de carrera.
En general, es una buena práctica utilizar objetos inmutables o estructuras de datos thread-safe al tratar con concurrencia para evitar condiciones de carrera y estados inconsistentes. En este caso, dado que solo hay un hilo realizando cambios, no es necesario utilizar un ConcurrentHashMap.