21.2并发(2)

并发编程第二篇

不正确的访问资源

在Java中，递增不是原子操作

当多线程操作EvenGerator对象时，A线程正在操作第一个++currentEvenValue，此刻又进来一个线程B操作，就产生出现了并发问题。

public class EvenGenerator extends IntGenerator {
    private int currentEvenValue = 0;

    public int next() {
        ++currentEvenValue; // Danger point here!
        ++currentEvenValue;
        return currentEvenValue;
    }

    public static void main(String[] args) {
        EvenChecker.test(new EvenGenerator(),10);
    }
}

public class EvenChecker implements Runnable {
    private IntGenerator generator;
    private final int id;

    public EvenChecker(IntGenerator g, int ident) {
        generator = g;
        id = ident;
    }

    public void run() {
        while (!generator.isCanceled()) {
            int val = generator.next();
            if (val % 2 != 0) {
                System.out.println(val + " not even!");
                generator.cancel(); // Cancels all EvenCheckers
            }
        }
    }

    // Test any type of IntGenerator:
    public static void test(IntGenerator gp, int count) {
        ExecutorService exec = Executors.newCachedThreadPool();
        for (int i = 0; i < count; i++)
            exec.execute(new EvenChecker(gp, i));
        exec.shutdown();
    }
}

解决共享资源竞争

Java提供关键字synchronized锁形式，当任务要执行被synchronized关键字保护的代码时，需要先请求锁(不可用需等待其他任务释放锁)，执行代码，释放锁。
JVM负责跟踪对象被加锁的次数，通俗的讲当任务获取到当前对象的锁时（对于其他任务来讲就是给此对象加锁），此对象的加锁次数+1，再操作此对象其他加锁的方法时，再+1(只有首先获得对象的锁才可以持续获取多个锁)，最后当任务离开加锁的方法时(释放锁)，加锁次数递减，直至为0；对于其他任务来讲就可以获取锁了，依次循环。
锁分类：方法锁(其实也是对象锁)，对象锁，类锁（静态方法锁）。

同步使用场景：

如果你正在写一个变量，它接下来可能会被其他线程操作，获取你正在操作的变量刚被其他线程操作过，就应该使用同步。并且，读写线程都需要使用相同的监视器(锁)。

注意事项：

1.使用并发时，将域设置为private时非常重要的，否则synchronized关键字就不能防止其他任务访问，将会产生冲突。
```
public class SynchronizedEvenGenerator extends IntGenerator {
    private int currentEvenValue = 0;

    public synchronized int next() {
        ++currentEvenValue;
//        Thread.yield(); // Cause failure faster
//        ++currentEvenValue;
        return currentEvenValue;
    }

    public static void main(String[] args) {
        EvenChecker.test(new SynchronizedEvenGenerator());
    }
}
```

使用显示的Lock对象:Lock对象必须显示的创建、锁定和释放，虽然看起来不太优雅，但会更灵活一些。

public class MutexEvenGenerator extends IntGenerator {
    private int currentEvenValue = 0;
    private Lock lock = new ReentrantLock();

    public int next() {
        lock.lock();
        try {
            ++currentEvenValue;
            Thread.yield(); // Cause failure faster
            ++currentEvenValue;
            return currentEvenValue;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        EvenChecker.test(new MutexEvenGenerator());
    }
}

ReentrantLock重入锁：允许你尝试获取但最终未获取锁，即使别人获取了锁你也可以去执行其他事情，而不用一直等待。

21.2并发(2)

并发编程第二篇

推荐阅读更多精彩内容