Java:volatile

Java中的原子性操作与同步问题

1.在Java中，原子操作是指不能被线程调度机制中断的操作，一旦操作开始，那么它一定可以在可能发生的"上下文切换"之前（切换到其它线程执行）执行完毕。

2.依赖原子性来处理同步问题时很棘手并且很危险的事情。

如下面的程序，尽管return i;确实是原子性操作，但是缺少同步使得其数值可以在处于不稳定的中间状态时被读取，尽管变量i添加上了volatile关键字。

正确的方法时同时将getValue()和evenIncrement()都是synchronized的。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class AtomicityTest implements Runnable {

    private int i = 0;
    
    public int getValue() {
        return i;
    }
    
    private synchronized void evenIncrement() {
        i++;
        i++;
    }
    
    @Override
    public void run() {
        while (true) {
            evenIncrement();
        }
    }
    
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        AtomicityTest at = new AtomicityTest();
        exec.execute(at);
        while (true) {
            int val = at.getValue();
            if (val % 2 != 0) {
                System.out.println("error..." + val + " is odd.");
                System.exit(0);
            }
        }
 
    }

}
/**
 * 程序运行结果：
 * error...53683 is odd.
 */

再如下面的程序，一方面虽然用volatile关键字修饰了SerialNumberGenerator.serialNumber成员，但是nextSerialNumber()中的++运算并不是原子操作，所以还是会出现问题。

解决问题得方法就是把nextSerialNumber()方法改为synchronized的。

public class SerialNumberGenerator {
    
    private static volatile int serialNumber = 0;
    
    public static int nextSerialNumber() {
        return serialNumber++;
    }
}

public class CircularSet {
    
    private int[] array;
    private int len;
    private int index = 0;
    
    public CircularSet(int size) {
        array = new int[size];
        len = size;
        for (int i = 0; i < len; i++) array[i] = -1;
    }
    
    public synchronized void add(int i) { 
        array[index] = i;
        index = (index + 1) % len;
    }
    
    public synchronized boolean contains(int val) {
        for (int i = 0; i < len; i++) {
            if (array[i] == val) return true;
        }
        return false;
    }

}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class SerialNumberChecker {
    
    private static final int SIZE = 10;
    private static CircularSet serials = new CircularSet(1000);
    private static ExecutorService exec = Executors.newCachedThreadPool();
    
    public static void main(String[] args) {
        
        for (int i = 0; i < SIZE; i++) {
            exec.execute(new Runnable() {

                @Override
                public void run() {
                    while (true) {
                        int serial = SerialNumberGenerator.nextSerialNumber();
                        if (serials.contains(serial)) {
                            System.out.println("error... " + serial + " duplicate.");
                            System.exit(0);
                        }
                        serials.add(serial);
                    }
                }
                
            });
        }
    }

}

/**
 * 程序执行结果：
 * error... 8298 duplicate.
 * error... 9049 duplicate.
 * error... 9051 duplicate.
 * error... 9045 duplicate.
 * error... 9050 duplicate.
 * error... 9048 duplicate.
 * error... 9047 duplicate.
 * error... 9046 duplicate.
 */