[笔记][Java7并发编程实战手册]系列目录

简介

本文继续学习信号量Semaphore机制。
在3.2中其实已经讲解完了，之前对于信号量并发的使用场景不知道，看了本章节才想到一些；
下面就以 租车为列子来讲解并发访问的控制。（示例都很简单或许不符合现实逻辑）

1. 信号量（非二进制信号量）是不保证同步的，需要额外的同步

示例

场景：有一个出租车公司，有三台车，有十个司机，每个司机工作的时间不一致，可以说是司机等待着别人还车后，接着租用汽车。

/**
 * Created by zhuqiang on 2015/8/17 0017.
 */
public class Client {
    public static void main(String[] args) {
        Semaphore sh = new Semaphore(3); //信号量，允许3个线程并发租用车辆
        Company company = new Company();  //创建公司

        Thread[] drivers = new Thread[10];
        for (int i = 0; i < drivers.length; i++) {
            drivers[i] = new Thread(new Driver(sh, company));
        }
        for (Thread d : drivers) {
            d.start();
        }
    }


}

/** 出租车公司 **/
class Company {
    boolean[] cars = new boolean[3]; //三台车的租用状态,下标作为车子的编号
    Lock lock = new ReentrantLock();

    /** 租车 * */
    public int rent() {
        int result = -1;
        lock.lock();
        for (int i = 0; i < cars.length; i++) {
            if (!cars[i]) {  //获取未被使用的车辆的编号
                result = i;
                cars[i] = true;  //置为使用状态
                break;
            }
        }
        System.out.printf("司机编号：%s :租用了编号为：%d 的出租车\n", Thread.currentThread().getName(), result);
        lock.unlock();
        return result;
    }

    /**
     * 归还车辆
     *
     * @param num 车辆编号
     */
    public void giveBack(int num) {
        lock.lock();
        cars[num] = false;   //置为空闲状态
        System.out.printf("司机编号：%s :归还了编号为：%d 的出租车\n", Thread.currentThread().getName(), num);
        lock.unlock();

    }
}

/** 司机 * */
class Driver implements Runnable {
    Semaphore sh = null;
    Company company = null;

    public Driver(Semaphore sh, Company company) {
        this.sh = sh;
        this.company = company;
    }

    /** 司机工作 * */
    @Override
    public void run() {
        try {
            sh.acquire();  //获取信号量
            int num = company.rent();  //获得租车的编号
            long time = (long) (Math.random() * 10);  //模拟工作了多少时间
            System.out.printf("司机编号：%s :正在驾驶车辆编号为：%d 的出租车，此次工作时间为：%d 秒;\n", Thread.currentThread().getName(), num, time);
            TimeUnit.SECONDS.sleep(time);  //休眠辅助类。按指定单位休眠
            company.giveBack(num);  //归还车辆
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            sh.release();
        }
    }
}

某一次运行结果：

司机编号：Thread-9 :租用了编号为：0 的出租车
司机编号：Thread-1 :租用了编号为：1 的出租车
司机编号：Thread-2 :租用了编号为：2 的出租车
司机编号：Thread-9 :正在驾驶车辆编号为：0 的出租车，此次工作时间为：8 秒;
司机编号：Thread-1 :正在驾驶车辆编号为：1 的出租车，此次工作时间为：4 秒;
司机编号：Thread-2 :正在驾驶车辆编号为：2 的出租车，此次工作时间为：2 秒;
司机编号：Thread-2 :归还了编号为：2 的出租车
司机编号：Thread-3 :租用了编号为：2 的出租车
司机编号：Thread-3 :正在驾驶车辆编号为：2 的出租车，此次工作时间为：9 秒;
司机编号：Thread-1 :归还了编号为：1 的出租车
司机编号：Thread-4 :租用了编号为：1 的出租车
司机编号：Thread-4 :正在驾驶车辆编号为：1 的出租车，此次工作时间为：8 秒;
司机编号：Thread-9 :归还了编号为：0 的出租车
司机编号：Thread-5 :租用了编号为：0 的出租车
司机编号：Thread-5 :正在驾驶车辆编号为：0 的出租车，此次工作时间为：8 秒;
司机编号：Thread-3 :归还了编号为：2 的出租车
司机编号：Thread-6 :租用了编号为：2 的出租车
司机编号：Thread-6 :正在驾驶车辆编号为：2 的出租车，此次工作时间为：3 秒;
司机编号：Thread-4 :归还了编号为：1 的出租车
司机编号：Thread-7 :租用了编号为：1 的出租车
司机编号：Thread-7 :正在驾驶车辆编号为：1 的出租车，此次工作时间为：2 秒;
司机编号：Thread-6 :归还了编号为：2 的出租车
司机编号：Thread-8 :租用了编号为：2 的出租车
司机编号：Thread-8 :正在驾驶车辆编号为：2 的出租车，此次工作时间为：8 秒;
司机编号：Thread-7 :归还了编号为：1 的出租车
司机编号：Thread-0 :租用了编号为：1 的出租车
司机编号：Thread-0 :正在驾驶车辆编号为：1 的出租车，此次工作时间为：8 秒;
司机编号：Thread-5 :归还了编号为：0 的出租车
司机编号：Thread-8 :归还了编号为：2 的出租车
司机编号：Thread-0 :归还了编号为：1 的出租车

说明：
可以看出上面的结果： 非常正确的让10个线程中的三个并发的使用出租车；该示例的成功要点：
1. 信号量资源数目 要 <= 并发访问的资源数目(否则将会租到 编号为 -1 的车辆)
2. 并发获取共享资源的操作必须要额外的同步