多线程Atomic和ThreadLocal

public interface CounterI {
    void addOne();
    int getCount();
}

public class Counter implements CounterI {

    private static int count = 0;

    @Override
    public void addOne() {
        count++;
    }

    @Override
    public int getCount() {
        return count;
    }
}

import java.util.concurrent.atomic.AtomicInteger;

public class CounterAtomic implements CounterI{

    private static AtomicInteger count = new AtomicInteger();

    public void addOne() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

public class CounterThreadLocal implements CounterI{

    private static ThreadLocal<Integer> count = new ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };

    public void addOne() {
        count.set(count.get() + 1);
    }

    public int getCount() {
        return count.get();
    }
}

public class ClientThread extends Thread {

    private CounterI c;

    public ClientThread(CounterI c1) {
        this.c = c1;
    }
    
    public void run() {
        c.addOne();
        System.out.println(c.getCount()+" "+c.getClass().getName());
    }
}

public class MainThread {

    public static void main(String[] args) {
        System.out.println("不做任何处理的多线程是乱序的");
        CounterI c = new Counter();
        for (int i = 0; i < 10; i++) {            
            ClientThread t = new ClientThread(c);
            t.start();
        }
        
        System.out.println("Atomic控制的多线程是有序的");
        c = new CounterAtomic();
        for (int i = 0; i < 10; i++) {            
            ClientThread t = new ClientThread(c);
            t.start();
        }
        
        System.out.println("ThreadLocal控制的多线程是互不影响的");
        c = new CounterThreadLocal();
        for (int i = 0; i < 10; i++) {            
            ClientThread t = new ClientThread(c);
            t.start();
        }
    }
}