Для чего нужен volatile?

Для чего нужен volatile

volatile — это ключевое слово в Kotlin/Java для гарантии видимости переменной между несколькими потоками. Это фундаментальное понятие многопоточного программирования.

Проблема без volatile

class Counter {
    private var count = 0
    
    fun increment() {
        count++
    }
    
    fun getCount() = count
}

// Два потока
val counter = Counter()
thread1 { repeat(1000) { counter.increment() } }
thread2 { repeat(1000) { counter.increment() } }

// Результат может быть не 2000!
// Каждый поток может иметь локальную копию в кеше CPU

Что делает volatile

volatile гарантирует:

• Запись в переменную видна всем потокам немедленно
• Все чтение переменной получает самое свежее значение
• Нет оптимизаций CPU кеша для этой переменной

class Counter {
    @Volatile
    private var count = 0
    
    fun increment() {
        count++  // Всегда видна другим потокам
    }
    
    fun getCount() = count  // Всегда читаем свежее значение
}

Как это работает

┌─────────────┐         ┌──────────────┐
│ Thread 1    │         │ Thread 2     │
│ CPU Cache   │         │ CPU Cache    │
└──────┬──────┘         └───────┬──────┘
       │                        │
       │    count = 5           │
       ├───────────────────────→│
       │  (видимо немедленно)   │
       │                        │
       │  read count = 5        │
       │←───────────────────────┤
       │    (свежее значение)   │

Примеры использования

1. Флаг остановки потока

class WorkerThread {
    @Volatile
    private var shouldStop = false
    
    fun stop() {
        shouldStop = true
    }
    
    fun run() {
        while (!shouldStop) {
            doWork()
        }
    }
}

// Основной поток
val worker = WorkerThread()
thread { worker.run() }
Thread.sleep(5000)
worker.stop()  // Другой поток увидит это немедленно

2. Двойная проверка блокировки (Double-Checked Locking)

class Singleton {
    companion object {
        @Volatile
        private var instance: Singleton? = null
        
        fun getInstance(): Singleton {
            if (instance == null) {
                synchronized(this) {
                    if (instance == null) {
                        instance = Singleton()
                    }
                }
            }
            return instance!!
        }
    }
}

3. Флаг инициализации

class DataCache {
    @Volatile
    private var initialized = false
    
    fun load(data: Data) {
        // Дорогостоящая операция
        processData(data)
        initialized = true  // Видно другим потокам
    }
    
    fun isReady() = initialized
}

// Другой поток может безопасно проверить
if (cache.isReady()) {
    useCache()
}

Важные ограничения

volatile НЕ гарантирует:

• Атомарность операций (count++ всё равно может быть неправильным)
• Безопасность составных операций

// НЕПРАВИЛЬНО даже с volatile
@Volatile
private var count = 0

fun increment() {
    count++  // Не атомарно! (read-modify-write)
}

// ПРАВИЛЬНО для атомарных операций
private val count = AtomicInteger(0)
fun increment() {
    count.incrementAndGet()  // Атомарно
}

volatile vs synchronized

volatile:

• Легче (нет блокировки)
• Для простых значений типа Boolean, Int
• Когда нужна видимость, но не атомарность

@Volatile
var flag = false  // Легко

synchronized:

• Для сложных операций
• Когда нужна полная атомарность
• Когда несколько операций должны быть неделимыми

synchronized(lock) {
    list.add(item)
    count++
}

Android примеры

1. Флаг в Service

class BackgroundService : Service() {
    @Volatile
    private var isRunning = false
    
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        isRunning = true
        thread {
            while (isRunning) {
                doBackgroundWork()
            }
        }
        return START_STICKY
    }
    
    override fun onDestroy() {
        super.onDestroy()
        isRunning = false
    }
}

2. Состояние в Singleton

class NetworkManager {
    @Volatile
    var isConnected = false
    
    fun checkConnection() {
        thread {
            isConnected = pingServer()
        }
    }
}

Ключевые моменты

• volatile гарантирует видимость между потоками
• НЕ гарантирует атомарность — используй AtomicInteger для счётчиков
• Используй для флагов и простых значений
• Для сложных операций используй synchronized или Lock
• На Android часто используется для остановки background потоков

Понимание volatile критически важно для написания thread-safe кода в многопоточных приложениях.