高层次并发对象

到目前为止，本课程一直都专注于底层次的API——从非常早开始就一直是JAVA平台的组成部分。这些API对于解决一些基本问题是非常足够的，但是为了应对更高级的任务，就需要更高层次的组成模块。这对于充分利用了目前的多核和多CPU的大规模的并发应用来说就更是如此。

在这个章节，我们会探究一些在JAVA5.0才引入的高层次的并发特征。其中大部分的特征都在java.util.concurrent包中实现。JAVA集合框架中也有新的并发数据类型引入。

• Lock对象支持锁动作，这可以简化很多并发的开发。
• Executors定义了一个可以发起和管理线程的高层次API。由java.util.concurrent包提供的Executor实现提供了适合大型应用的线程池管理。
• 原子变量Atomic可以最小化同步的开销，以及帮助防止内存不一致性错误。
• ThreadLocalRandom类提供了使用多线程有效生成伪随机数的方法。

锁对象

同步代码依赖一种非常简单的可重入锁。这种重入锁使用很方便，但是有很多局限性。java.util.concurrent包支持更多复杂的锁操作。我们不会非常仔细地考察这个包，但是我们会关注它最底层的接口，Lock。

Lock对象的工作方式和同步方法使用的不确切锁很像。和不确切锁一样，同时只有一个线程能拥有锁。Lock对象也支持wait/notify机制，通过与他们相关联的Condition对象。

锁对象与不确切锁相比最大的优势在于它们能够从获取锁的尝试中返回。tryLock方法会返回如果不能立刻、或在某段时间内获得锁。lockInterruptibly方法会返回如果另一个线程在获取锁之前发送了一个中断。

让我们使用Lock对象来解决我们在活性章节看到的死锁问题。Alphonse和Gaston已经训练他们自己能够发现对方准备要鞠躬。我们规定如果想要鞠躬，Friend对象必须要获取两者的锁。

下面是安全锁Safelock的代码。为了显示这种用法的通用性，我们假设Alphonse和Gaston是如此痴迷于自己获得的新技能，以至于他们无法停止互相鞠躬了。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.Random;

public class Safelock {
    static class Friend {
        private final String name;
        private final Lock lock = new ReentrantLock();

        public Friend(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        public boolean impendingBow(Friend bower) {
            Boolean myLock = false;
            Boolean yourLock = false;
            try {
                myLock = lock.tryLock();
                yourLock = bower.lock.tryLock();
            } finally {
                if (! (myLock && yourLock)) {
                    if (myLock) {
                        lock.unlock();
                    }
                    if (yourLock) {
                        bower.lock.unlock();
                    }
                }
            }
            return myLock && yourLock;
        }
            
        public void bow(Friend bower) {
            if (impendingBow(bower)) {
                try {
                    System.out.format("%s: %s has"
                        + " bowed to me!%n", 
                        this.name, bower.getName());
                    bower.bowBack(this);
                } finally {
                    lock.unlock();
                    bower.lock.unlock();
                }
            } else {
                System.out.format("%s: %s started"
                    + " to bow to me, but saw that"
                    + " I was already bowing to"
                    + " him.%n",
                    this.name, bower.getName());
            }
        }

        public void bowBack(Friend bower) {
            System.out.format("%s: %s has" +
                " bowed back to me!%n",
                this.name, bower.getName());
        }
    }

    static class BowLoop implements Runnable {
        private Friend bower;
        private Friend bowee;

        public BowLoop(Friend bower, Friend bowee) {
            this.bower = bower;
            this.bowee = bowee;
        }
    
        public void run() {
            Random random = new Random();
            for (;;) {
                try {
                    Thread.sleep(random.nextInt(10));
                } catch (InterruptedException e) {}
                bowee.bow(bower);
            }
        }
    }
            

    public static void main(String[] args) {
        final Friend alphonse =
            new Friend("Alphonse");
        final Friend gaston =
            new Friend("Gaston");
        new Thread(new BowLoop(alphonse, gaston)).start();
        new Thread(new BowLoop(gaston, alphonse)).start();
    }
}