Являются ли объекты Stack общими

Являются ли объекты Stack общими?

Нет, объекты Stack в Java НЕ являются автоматически общими (shared) между потоками. Stack — это потокозависимая структура данных, каждый поток имеет свой собственный stack в памяти JVM.

Понимание Stack в многопоточном контексте

1. Каждый поток имеет свой Stack

В Java каждый поток получает собственный call stack (стек вызовов):

public class ThreadStackExample {
    public static void main(String[] args) {
        // main() выполняется в потоке main
        // main получает свой stack для локальных переменных
        
        Thread thread1 = new Thread(() -> {
            // У thread1 свой stack
            int localVar = 10;  // Хранится в stack потока thread1
            process(localVar);  // Стек вызовов: run → process
        });
        
        Thread thread2 = new Thread(() -> {
            // У thread2 свой другой stack
            int localVar = 20;  // Хранится в stack потока thread2
            process(localVar);  // Стек вызовов: run → process
        });
        
        thread1.start();  // Стек для thread1
        thread2.start();  // Стек для thread2
    }
    
    static void process(int value) {
        System.out.println("Value: " + value);
    }
}

// Памят JVM:
// Stack main:   [main() → ...]
// Stack thread1: [run() → process()]
// Stack thread2: [run() → process()]
// ВСЕ РАЗНЫЕ!

2. Локальные переменные НЕ общие

public class NotShared {
    static void criticalSection() {
        int count = 0;  // Локальная переменная в stack потока
        count++;        // Каждый поток работает со своей копией
        System.out.println(Thread.currentThread().getName() + ": " + count);
    }
    
    public static void main(String[] args) {
        // 100 потоков
        for (int i = 0; i < 100; i++) {
            new Thread(NotShared::criticalSection).start();
        }
    }
}

// Вывод: каждый поток выведет "1"
// Почему? Потому что каждый имеет свой count в своём stack

Когда Stack становится общим (Shared)

1. Через ссылки на Heap

Если в локальной переменной хранится ссылка на объект в Heap, то этот объект МОЖЕТ быть общим:

public class SharedHeap {
    static class Counter {
        int value = 0;  // В Heap
    }
    
    static Counter sharedCounter = new Counter();  // Глобальная ссылка
    
    public static void main(String[] args) {
        // 10 потоков
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    sharedCounter.value++;  // ВСЕ потоки пишут в ОДИН объект в Heap!
                }
            }).start();
        }
    }
}

// Памят:
// Stack thread1: [sharedCounter → 0x1000]  (ссылка)
// Stack thread2: [sharedCounter → 0x1000]  (ссылка)
// ...
// Heap: 0x1000: Counter(value = ???)  ОБЩИЙ для всех!

// Результат НЕПРЕДСКАЗУЕМ, т.к. нет синхронизации
// Может быть 5000, может быть 3000, может быть 10000

2. Поля класса (статические переменные)

public class SharedStatic {
    static int counter = 0;  // В Heap (в области памяти класса)
    
    public static void main(String[] args) {
        // 10 потоков
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter++;  // ВСЕ потоки пишут в ОДИН counter
                }
            }).start();
        }
    }
}

// Проблема: race condition
// counter++ не атомарный, состоит из трёх операций:
// 1. LOAD counter
// 2. INCREMENT
// 3. STORE counter

// Два потока одновременно:
// Thread1: LOAD (5) → INCREMENT (6) → STORE (6)
// Thread2: LOAD (5) → INCREMENT (6) → STORE (6)  // Перезаписал Thread1!
// Результат: 6 вместо 7

Модель памяти Java и Stack

public class MemoryModel {
    // HEAP (общая для всех потоков)
    static List<String> sharedList = new ArrayList<>();
    static int sharedValue = 0;
    
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            // Stack потока t1:
            String local1 = "t1";      // Только в stack t1
            int local2 = 10;            // Только в stack t1
            
            // Heap (общее):
            sharedList.add(local1);     // Записал в общий List
            sharedValue = 100;          // Записал в общую переменную
        });
        
        Thread t2 = new Thread(() -> {
            // Stack потока t2:
            String local1 = "t2";      // Другой local1, только в stack t2
            int local2 = 20;            // Другой local2, только в stack t2
            
            // Heap (общее):
            sharedList.add(local1);     // Добавил в ТОТ ЖЕ List
            sharedValue = 200;          // Перезаписал в ТУ ЖЕ переменную
        });
        
        t1.start();
        t2.start();
        
        t1.join();
        t2.join();
        
        System.out.println(sharedList);  // [t1, t2] или [t2, t1]? Undefined!
        System.out.println(sharedValue); // 100 или 200? Undefined!
    }
}

Java Stack Class — специальный случай

В Java есть класс java.util.Stack (и java.util.Collections.synchronizedList()):

// Stack класс
import java.util.Stack;

public class StackObject {
    static Stack<Integer> stack = new Stack<>();  // В Heap, может быть общим
    
    public static void main(String[] args) {
        // 10 потоков
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 100; j++) {
                    stack.push(j);  // Push в ОБЩИЙ Stack
                    stack.pop();    // Pop из ОБЩЕГО Stack
                }
            }).start();
        }
    }
}

// Stack в Java является synchronized (потокобезопасным)
// Но это МЕДЛЕННО из-за частых synchronization'ов

// Вместо этого используй ConcurrentHashMap, CopyOnWriteArrayList
// или collections.synchronizedList(new ArrayList<>())

Как сделать Stack общим (Shared) безопасно

1. Использование synchronized

public class SharedStack {
    static class Counter {
        private int value = 0;
        
        synchronized void increment() {  // Синхронизированный доступ
            value++;
        }
        
        synchronized int getValue() {
            return value;
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.increment();  // Безопасный доступ
                }
            }).start();
        }
    }
}

2. Использование AtomicInteger

import java.util.concurrent.atomic.AtomicInteger;

public class SharedAtomic {
    static AtomicInteger counter = new AtomicInteger(0);  // Потокобезопасный
    
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.incrementAndGet();  // Атомарная операция
                }
            }).start();
        }
        
        Thread.sleep(1000);
        System.out.println(counter.get());  // Всегда 10000
    }
}

3. Использование volatile

public class SharedVolatile {
    static volatile int counter = 0;  // volatile гарантирует видимость
    
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter++;  // Но это всё ещё не атомарно!
                }
            }).start();
        }
    }
}

// volatile помогает с visibility, но не с atomicity
// counter++ всё ещё состоит из трёх операций

Stack vs Heap в многопоточности

Практический пример проблемы

public class StackMemoryIssue {
    public static void main(String[] args) throws InterruptedException {
        class LocalStack {  // Не путать с java.util.Stack!
            int[] data = new int[100];  // В Heap (часть объекта)
        }
        
        LocalStack stack = new LocalStack();  // В Heap
        
        // Два потока пишут в ОДИНодин и тот же массив
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                stack.data[i] = i;  // Пишет в Heap
            }
        });
        
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(stack.data[i]);  // Читает из Heap
                // Может видеть частичные изменения от t1!
            }
        });
        
        t1.start();
        t2.start();
        
        t1.join();
        t2.join();
    }
}

Заключение

Стек (call stack) каждого потока НЕ общий:

• Call stack (стек вызовов методов) — уникален для каждого потока, НЕ общий
• Локальные переменные в stack — защищены, не видны другим потокам
• Но объекты в Heap — могут быть общими, если на них указывают несколько потоков
• Stack.class в Java — в Heap, может быть общим, потокобезопасный (synchronized)
• Для истинно безопасного обмена используй: synchronized, volatile, atomic classes, concurrent collections

Память делится на:

• Stack = локальные переменные, уникален для каждого потока
• Heap = объекты, общий для всех потоков (требует синхронизации!)