====== Потоки и переменные ======

===== Использование volatile - не безопастно к потокам =====
<code java>
import static java.lang.System.out;
import java.util.Collection;
import java.util.LinkedList;

public class EntryPoint {
    private volatile int counter = 0;
    
    class ChildThread extends Thread {
        public void run() {
            for (int i=0; i<1000; i++) {
                counter++;
            }
        }
    }

    public EntryPoint() throws InterruptedException {
        Collection<Thread> threads = new LinkedList<Thread>();
        for (int i=0; i<100; i++ ) {
            Thread th = new ChildThread();
            threads.add(th);
            th.start();
        }
        
        for (Thread thread : threads) {
            thread.join();
        }
        out.println("Done!");
        out.println(String.format("Now counter == %d", counter));
    }

     public static void main(String []args) throws InterruptedException {
        var ep = new EntryPoint();
     }
}
</code>
<code>
java -cp /tmp/WkigqTFpnD EntryPoint
Done!
Now counter == 97533
</code>

===== Использование Atomic - безопастно к потокам =====
<code java>
import static java.lang.System.out;
import java.util.Collection;
import java.util.LinkedList;
import java.util.concurrent.atomic.AtomicInteger;

public class EntryPoint {

    private AtomicInteger counter = new AtomicInteger(0);
    
    class ChildThread extends Thread {
        public void run() {
            for (int i=0; i<1000; i++) {
                counter.addAndGet(1);
            }
        }
    }

    public EntryPoint() throws InterruptedException {
        Collection<Thread> threads = new LinkedList<Thread>();
        for (int i=0; i<100; i++ ) {
            Thread th = new ChildThread();
            threads.add(th);
            th.start();
        }
        
        for (Thread thread : threads) {
            thread.join();
        }
        out.println("Done!");
        out.println(String.format("Now counter == %d", counter.get()));
    }

     public static void main(String []args) throws InterruptedException {
        var ep = new EntryPoint();
     }
}
</code>
<code>
java -cp /tmp/WkigqTFpnD EntryPoint
Done!
Now counter == 100000
</code>
===== Использование synchronized - безопастно к потокам =====
Интересное замечание, создание простых synchronized функций создают гораздо меньше байткода.
<code java>
import static java.lang.System.out;
import java.util.Collection;
import java.util.LinkedList;

public class EntryPoint {

    private int counter = 0;
    
    private synchronized void increment() { // Синхронизированная функция, меньше байткода
        this.counter++;
    }
    
    private void increment2() { // Синхронизированный блок
        synchronized(EntryPoint.class) {
            counter++;
        };
    }
    
    class ChildThread extends Thread {
        public void run() {
            for (int i=0; i<1000; i++) {
                increment2(); // И `increment` и `increment2` создают одинаковый результат
            }
        }
    }

    public EntryPoint() throws InterruptedException {
        Collection<Thread> threads = new LinkedList<Thread>();
        for (int i=0; i<100; i++ ) {
            Thread th = new ChildThread();
            threads.add(th);
            th.start();
        }
        
        for (Thread thread : threads) {
            thread.join();
        }
        out.println("Done!");
        out.println(String.format("Now counter == %d", counter));
    }

     public static void main(String []args) throws InterruptedException {
        var ep = new EntryPoint();
     }
}
</code>
<code>
java -cp /tmp/WkigqTFpnD EntryPoint
Done!
Now counter == 100000
</code>