objective-c - periodica - peso atomico
¿Cuál es inseguro atómico o no atómico? (7)
Busqué y encontré inmutables son thread safe, mientras que mutable no lo es. Esto esta bien. Pero recibí notas engañosas, blogs, respuestas atómicas y no atómicas sobre la seguridad de los hilos, amablemente da una explicación de la respuesta.
Supongamos que hay una propiedad de cadena atómica llamada "nombre", y si llama [self setName:@"A"] desde el subproceso A, llame [self setName:@"B"] desde el subproceso B y llame a [self name] desde hilo C, entonces toda la operación en hilo diferente se realizará en serie, lo que significa que si un hilo está ejecutando setter o getter, entonces otros hilos esperarán. Esto hace que la propiedad "nombre" de lectura / escritura sea segura, pero si otro hilo D llama a [name release] simultáneamente, entonces esta operación puede producir un bloqueo porque no hay una llamada setter / getter involucrada aquí. Lo que significa que un objeto es de lectura / escritura segura (ATOMIC) pero no es seguro para subprocesos, ya que otros subprocesos pueden enviar simultáneamente cualquier tipo de mensajes al objeto.
Si la propiedad "nombre" no fuera atómica, todos los hilos en el ejemplo anterior - A, B, C y D se ejecutarán simultáneamente produciendo cualquier resultado impredecible. En caso de atómica, cualquiera de A, B o C se ejecutará primero pero D aún puede ejecutar en paralelo.
Su comentario sobre esto nos ayudará ...
Y mi pregunta es: "¿cuál es seguro para subprocesos en cacao, atómico o no atómico?"
1) Ambos no son seguros para subprocesos. 2) Atomic es solo una caja fuerte de lectura-escritura. 3) Sin embargo, si quieres hacer que el hilo sea seguro, debes implementar algún mecanismo de bloqueo para enhebrar como bloqueo mutex, bloqueo de giro. Leer más ... https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/Multithreading/ThreadSafety/ThreadSafety.html
Atomic garantiza el acceso atómico a la variable, pero NO hace que su código sea seguro. Tampoco lo hace no atómico.
Con "atómico", los métodos setter / getter sintetizados asegurarán que siempre se devuelva un valor completo desde el getter o establecido por el setter, independientemente de la actividad del colocador en cualquier otro hilo. Por lo tanto, si el hilo A está en el medio del captador mientras el hilo B llama al colocador, se devolverá un valor real viable al autor de la llamada en A. Para lo no atómico, no tiene tales garantías.
Debes considerar implementar un mecanismo de bloqueo para que no tengas un punto muerto dentro de tu aplicación. Además, si está implementando datos Core, debe leer sobre seguridad de hilos iOS.
Ver.
Hay otra propiedad de "atómica" que no se mencionó que era necesaria para la seguridad de la hebra antes de ARC (y probablemente todavía lo es). Primero explicando por qué es necesario: digamos que sin ARC, lees una propiedad de objeto y la retienes inmediatamente. Pero podría aparecer otro hilo justo entre la lectura de la propiedad y la llamada retener, establecer la propiedad del objeto en cero, haciendo que el objeto sea desasignado. Usted envía retener a un objeto desasignado, que no es saludable. Y sería un error muy raro porque solo ocurre cuando el momento es el correcto. Para evitar esto, las propiedades del objeto atómico siempre devuelven objetos liberados automáticamente.
No atómico es seguro para subprocesos. Guranted obtiene el valor de la variable.
Para las propiedades ObjC - Tampoco son seguras para hilos .
Atomic es más resistente a los errores de enhebrado. En general, es un curioso por defecto. Los escenarios que preferirías para atomic son muy pocos. Atomic puede aumentar la probabilidad de corrección, pero está en un nivel demasiado bajo como un sustituto de un mecanismo de bloqueo adecuado. Por lo tanto, si necesita seguridad de subprocesos, aún necesita alguna otra primitiva de sincronización encima de las lecturas / escrituras atómicas. Si no necesita seguridad de subprocesos (p. Ej., La instancia es inmutable o está pensada para ejecutarse solo desde el subproceso principal), atomic no agregará nada.
Ser resistente a los errores de enhebrado no es una "calidad"; sirve para enmascarar los errores reales de enhebrado y hacerlos más difíciles de reproducir y detectar.
También tenga en cuenta que los tipos mutables frente a los inmutables en realidad no garantizan la seguridad del hilo. ''Mutable'' se puede usar en los nombres de ObjC para referirse solo a la interfaz: las partes internas de una instancia inmutable pueden tener un estado mutable interno. En resumen, no puede suponer que un tipo que tiene una subclase mutable es seguro para subprocesos.
Pregunta expandida:
Supongamos que hay una propiedad de cadena atómica llamada "nombre", y si llama [self setName: @ "A"] desde el subproceso A, llame [self setName: @ "B"] desde el subproceso B y llame a [self name] desde hilo C, entonces toda la operación en hilo diferente se realizará en serie, lo que significa que si un hilo está ejecutando setter o getter, entonces otros hilos esperarán.
Si todos los hilos intentaban leer y / o escribir en la propiedad al mismo tiempo, solo un hilo tendría acceso a la vez y los otros se bloquearían si la propiedad fuera atómica. Si la propiedad no fuera atómica, todos tendrían acceso de lectura y escritura sin protección a la variable en el mismo "tiempo".
si otra secuencia D llama a [nombre de publicación] simultáneamente, esta operación puede producir un bloqueo porque no hay una llamada de establecimiento / recepción involucrada aquí.
Correcto.
Lo que significa que un objeto es de lectura / escritura segura (ATOMIC) pero no es seguro para subprocesos, ya que otros subprocesos pueden enviar simultáneamente cualquier tipo de mensajes al objeto.
Bueno, realmente hay mucho más. El ejemplo común es:
@interface MONPerson : NSObject
@property (copy) NSString * firstName;
@property (copy) NSString * lastName;
- (NSString *)fullName;
@end
Atómico, o no atómico, necesitarás un mecanismo de sincronización (por ejemplo, bloqueo) si un hilo está leyendo desde esa instancia y otro está escribiendo en él. Puede terminar con un primer nombre de MONPerson y el apellido de otro: el objeto puede haber cambiado antes de que se le devuelva el valor de devolución del comprador, o puede suceder:
Tema A:
p.firstName = @"Rob";
Hilo B:
p.firstName = @"Robert";
Tema A:
label.string = p.firstName; // << uh, oh -- will be Robert
Si la propiedad "nombre" no fuera atómica, todos los hilos en el ejemplo anterior - A, B, C y D se ejecutarán simultáneamente produciendo cualquier resultado impredecible.
Derecha: los síntomas iniciales pueden ser desequilibrios de cuenta de referencia (fuga, liberación excesiva).
En caso de atómica, cualquiera de A, B o C se ejecutará primero pero D aún puede ejecutar en paralelo. Amablemente comente sobre esto ...
Correcto. Pero si nos fijamos en el ejemplo anterior, atómico solo rara vez es un reemplazo adecuado para un bloqueo. Tendría que lucir así en su lugar:
Tema A:
[p lock]; // << wait for it… … … …
// Thread B now cannot access p
p.firstName = @"Rob";
NSString fullName = p.fullName;
[p unlock];
// Thread B can now access p
label.string = fullName;
Hilo B:
[p lock]; // << wait for it… … … …
// Thread A now cannot access p
…
[p unlock];
Los accesadores atómicos pueden tener un promedio de más de veinte veces más lento que los accesos no atómicos. Además, si su clase necesita ser enhebrable y tiene un estado mutable, es probable que termine usando un bloqueo cuando opera en un escenario concurrente. El bloqueo adecuado proporciona todas las garantías que necesita, los accesadores atómicos son redundantes en ese escenario, el uso de atomics solo agregaría tiempo de CPU. Otra cosa buena de la cerradura normal es que tienes toda la granularidad que necesitas, aunque a menudo es más pesada que la cerradura de giro utilizada para átomos, normalmente necesitarás menos adquisiciones, por lo que termina siendo muy rápida si usas cerraduras regulares correctamente. .
atomic hace que el siguiente hilo sea seguro.
self.myProperty = value;
o
id value = self.myProperty
no hace seguro el siguiente hilo
[myPorperty addObject:value];
Atomic lo hace seguro para establecer o obtener una propiedad, pero no hace que llamar a ningún método de esa propiedad sea seguro.
establecer u obtener valores puede tomar más de una instrucción de la CPU y eso significa que la configuración o obtención puede interrumpirse a mitad de camino y otro hilo puede hacer algo haciendo que el progreso de la secuencia anterior establezca o invalide el valor.
atomic dice establecer u obtener el valor de una manera para que ocurra como si sucediera en una instrucción indivisible y para que ningún otro subproceso pueda llegar a la mitad y arruinar las cosas.
Los objetos inmutables son seguros para el hilo porque no puedes cambiarlos, porque puedes cambiar una propiedad de un objeto inmóvil por otro para que esa parte no sea segura a menos que la conviertas en atómica.