更多 Java 并发编程方面的文章，请参见文集《Java 并发编程》

Lock

Lock是一个抽象概念。使得只有一个线程可以访问某个资源，并且Lock是不能被其他线程共享的。

Mutex

全程 MUTual EXclusion。

目的：保护共享资源。
典型的例子就是买票：票是共享资源，现在有两个线程同时过来买票。如果你不用 Mutex 在线程里把票锁住，那么就可能出现“把同一张票卖给两个不同的人（线程）”的情况。

Semaphore

目的：调度线程：一些线程生产（increase）同时另一些线程消费（decrease），Semaphore 可以让生产和消费保持合乎逻辑的执行顺序。
有的人用 Semaphore 也可以把上面例子中的票“保护"起来以防止共享资源冲突，必须承认这是可行的，但是 Semaphore 不是让你用来做这个的；如果你要做这件事，请用 Mutex。

一个最典型的使用 Semaphore 的场景：a 源自一个线程，b 源自另一个线程，计算 c = a + b 也是一个线程。显然，第三个线程必须等第一、二个线程执行完毕它才能执行。在这个时候，我们就需要调度线程了：让第一、二个线程执行完毕后，再执行第三个线程。

Semaphore 的使用

所在包：java.util.concurrent

A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each acquire blocks if necessary until a permit is available, and then takes it. Each release adds a permit, potentially releasing a blocking acquirer.
Semaphores are often used to restrict the number of threads than can access some (physical or logical) resource.
信号量 Semaphore 可以控制同时访问某个资源的线程个数。

• public Semaphore(int permits) 构造方法，设置许可的个数，默认为非公平锁
• public Semaphore(int permits, boolean fair) 构造方法，设置许可的个数，可以设置为公平锁（即等待越久的线程优先获得 permits）或非公平锁
• void acquire() 获得一个许可 permits，没有的话，线程就阻塞
• void acquire(int arg) 获得多个许可 permits，没有的话，线程就阻塞
• boolean tryAcquire() 获得一个许可 permits，没有的话就返回 false，线程不阻塞
• boolean tryAcquire(int permits) 获得多个许可 permits，没有的话就返回 false，线程不阻塞
• void release() 释放一个许可 permits，在释放之前，必须先获得许可 permits
• void release(int permits) 释放多个许可 permits，在释放之前，必须先获得许可 permits
• int availablePermits() 得到当前可用的许可数目

示例：
假设当前有 5 辆车，10 个司机，每个司机轮流用车。

public class Semaphore_Test {
    // 同时只能有 5 个线程访问某个资源 车
    private static Semaphore semaphore = new Semaphore(5);

    public static void main(String[] args) {
        // 10 个司机
        for (int i = 1; i <= 10; i++) {
            (new Driver(i)).start();
        }
    }

    static class Driver extends Thread {
        private int i;

        public Driver(int i) {
            this.i = i;
        }

        public void run() {
            try {
                semaphore.acquire();

                System.out.println("Driver " + i + " is using car");
                Thread.sleep(1000);
                System.out.println("Driver " + i + " return back car");

                semaphore.release();
            } catch (InterruptedException e) {
            }
        }
    }
}

可能的输出如下：

Driver 1 is using car
Driver 6 is using car
Driver 5 is using car
Driver 2 is using car
Driver 3 is using car
Driver 3 return back car
Driver 5 return back car
Driver 4 is using car
Driver 2 return back car
Driver 1 return back car
Driver 6 return back car
Driver 9 is using car
Driver 8 is using car
Driver 7 is using car
Driver 10 is using car
Driver 4 return back car
Driver 10 return back car
Driver 8 return back car
Driver 7 return back car
Driver 9 return back