Можно ли безопасно читать переменные класса в Objective-C?

Безопасность чтения переменных экземпляра в Objective-C

Краткий ответ: Чтение переменных экземпляра (instance variables) в Objective-C может быть безопасным только при определенных условиях, но в общем случае требует осторожности из-за особенностей многопоточности и динамической природы языка.

Основные риски и проблемы

1. Проблемы с многопоточностью (Thread Safety)

Самая серьезная проблема — отсутствие автоматической синхронизации при доступе из нескольких потоков:

// Потенциально небезопасный доступ в многопоточной среде
@interface UserProfile : NSObject {
    NSString *_username;  // Переменная экземпляра
    NSInteger _loginCount;
}

// В одном потоке:
- (void)updateProfile {
    _username = @"НовоеИмя";
}

// В другом потоке одновременно:
- (NSString *)currentUsername {
    return _username; // Может вернуть частично записанное значение!
}

2. Частичное обновление структур данных

При работе с структурами данных (struct) возможны состояния гонки:

typedef struct {
    CGFloat x;
    CGFloat y;
} Point;

@interface Shape : NSObject {
    Point _position;
}

// Один поток записывает:
_position = (Point){10.0, 20.0};

// Другой поток читает:
// Может получить {10.0, 0.0} или {0.0, 20.0} из-за отсутствия атомарности!

Рекомендованные подходы для безопасного чтения

1. Использование свойств (Properties) с правильными атрибутами

@interface BankAccount : NSObject

// Атомарное свойство (по умолчанию) - безопаснее для скалярных типов
@property (atomic, strong) NSString *accountNumber;

// Неатомарное свойство - быстрее, но требует ручной синхронизации
@property (nonatomic, strong) NSDecimalNumber *balance;

// Свойства только для чтения для публичного API
@property (nonatomic, copy, readonly) NSString *formattedBalance;

@end

2. Синхронизация доступа

@implementation ThreadSafeClass {
    NSMutableArray *_internalArray;
    NSLock *_arrayLock;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        _internalArray = [NSMutableArray new];
        _arrayLock = [NSLock new];
    }
    return self;
}

- (void)safeAddObject:(id)object {
    [_arrayLock lock];
    [_internalArray addObject:object];
    [_arrayLock unlock];
}

- (NSArray *)safeAllObjects {
    [_arrayLock lock];
    NSArray *copy = [_internalArray copy];
    [_arrayLock unlock];
    return copy;
}

3. Использование GCD (Grand Central Dispatch) для синхронизации

@implementation ConcurrentDataStore {
    dispatch_queue_t _syncQueue;
    NSMutableDictionary *_storage;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        // Серийная очередь для синхронизации
        _syncQueue = dispatch_queue_create("com.example.datastore", DISPATCH_QUEUE_SERIAL);
        _storage = [NSMutableDictionary new];
    }
    return self;
}

- (id)safeObjectForKey:(NSString *)key {
    __block id result;
    dispatch_sync(_syncQueue, ^{
        result = [_storage objectForKey:key];
    });
    return result;
}

- (void)safeSetObject:(id)object forKey:(NSString *)key {
    dispatch_async(_syncQueue, ^{
        self->_storage[key] = object;
    });
}

Практические рекомендации

1. Всегда используйте свойства для публичного API — они обеспечивают инкапсуляцию и контролируемый доступ

2. Избегайте прямого доступа к переменным экземпляра извне класса, даже внутри реализации используйте self-> только когда необходимо

3. Для многопоточного доступа применяйте:

   • @property (atomic) для простых скалярных типов
   • Синхронизацию через @synchronized, NSLock или GCD для сложных структур
   • Паттерн "чтение-копирование" для коллекций

4. Используйте readonly свойства для предоставления безопасного доступа на чтение:

@interface Configuration : NSObject
@property (nonatomic, copy, readonly) NSDictionary *settings;
@property (nonatomic, strong, readonly) NSDate *lastUpdate;
@end

Когда прямое чтение переменных может быть безопасным

1. В однопоточных приложениях или когда объект гарантированно используется только в одном потоке
2. В init и dealloc методах — здесь свойства еще/уже не полностью функциональны
3. Для readonly переменных, которые инициализируются при создании и никогда не изменяются
4. При использовании иммутабельных (immutable) классов типа NSString, NSNumber

Вывод

Прямое чтение переменных экземпляра в Objective-C не является безопасным по умолчанию в многопоточных средах. Безопасность должна обеспечиваться через:

• Правильное использование свойств с соответствующими атрибутами
• Явную синхронизацию при необходимости
• Проектирование классов с учетом многопоточности
• Использование иммутабельных структур данных там, где это возможно

Для современных проектов рекомендуется минимальное использование прямого доступа к переменным экземпляра, предпочитая свойства и современные механизмы синхронизации вроде GCD.