[笔记][Java7并发编程实战手册]3.3 资源的多副本并发访问控制Semaphore

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

简介

本文继续学习信号量Semaphore机制。

在3.2中其实已经讲解完了，之前对于信号量并发的使用场景不知道，看了本章节才想到一些；

下面就以 租车为列子来讲解并发访问的控制。（示例都很简单或许不符合现实逻辑）

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

示例

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

/**
* 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. 并发获取共享资源的操作必须要额外的同步