多线程练习题，来自《疯狂java》
题目
假设又三个车位（可以用boolean[]数组来表示车库）可以停车，写一个程序模拟多个用户开车离开，停车入库的效果。注意车位有车的时候不能停车。
分析
开始时，车位为空，只准进行倒车入库操作（一共有三个车位，所以最多同时有三辆车进行倒库），超过三辆车以后，不允许车进入；同时，当某个车位有车的时候，新的车辆不能进入该车位；汽车出库完成，允许新的车进入其中。
用户（User）提供车位信息，倒车入库方法和出库离开方法，检查剩余车位并且返回空余车位的位置
代码
第一版
/**
# 题目
假设又三个车位（可以用boolean[]数组来表示车库）可以停车，
写一个程序模拟多个用户开车离开，停车入库的效果。注意车位有车的时候不能停车。
*/
/**
* 用户类，封装车位信息，提供入库和出库方法
*/
class User{
private boolean[] parking ={false,false,false};
public synchronized int findSpareParking(){
for(int i=0;i<parking.length; i++){
if(!parking[i]){
return i;
}
}
return -1;
}
/**
* 倒车入库,出库离开
*/
public synchronized void move(){
int p;
if((p=findSpareParking())>=0){
//停车进入
parking[p]=true;
System.out.println(Thread.currentThread().getName()+"在车位"+p+"倒车入库");
//模拟实际汽车在车位停留一定思维时间
//唤醒其他线程
notifyAll();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//出库
parking[p] = false;
System.out.println(Thread.currentThread().getName() +"在车位"+p+ "出库离开");
}
}
}
class CarThread extends Thread {
private String name;
private User user;
public CarThread(String name, User user) {
super(name);
this.user = user;
}
@Override
public void run() {
user.move();
}
}
public class Problem2 {
public static void main(String[] args) {
User user = new User();
//创建多个线程和用户
for (int i=0;i<12;i++){
new CarThread("car"+i,user).start();
}
}
}
问题
car0在车位0倒车入库
car0在车位0出库离开
car11在车位0倒车入库
car11在车位0出库离开
car10在车位0倒车入库
只有一个车位被启用，分析原因是因为move方法里面虽然有休眠和notifyAll()方法，但是程序实际上还是顺序执行
第二版
每位用户创建两个线程：倒车入库线程和出库离开线程；但是这个时候出现了新的问题，怎样知道某辆汽车停在哪个车位上呢？只有认识到这一点，才能完成汽车出库的操作。因此需要额外定义一个数组cars，同来表示汽车入库以后的车位信息。汽车在p位置入库，parking[p]=true,cars[p]=“car_name”；出库的时候，首先需要确保当前线程所代表的汽车的确是进入到车位当中，假设其位置是p，出库操作为parking[p]=false,cars[p]=“null”
/**
* # 题目
* 假设又三个车位（可以用boolean[]数组来表示车库）可以停车，
* 写一个程序模拟多个用户开车离开，停车入库的效果。注意车位有车的时候不能停车。
*/
/**
* 用户类，封装车位信息，提供入库和出库方法
*/
class User {
private boolean[] parking = {false, false, false};
private String[] cars = new String[3];
public synchronized int findSpareParking() {
for (int i = 0; i < parking.length; i++) {
if (!parking[i]) {
return i;
}
}
return -1;
}
public synchronized int findParkingWithCar() {
for (int i = 0; i < parking.length; i++) {
if (parking[i] && cars[i] != null && cars[i].equals(Thread.currentThread().getName())) {
return i;
}
}
return -1;
}
/**
* 倒车入库
*/
public synchronized void move() {
int p;
String name = Thread.currentThread().getName();
if((p= findSpareParking())>=0){
//停车进入
parking[p] = true;
cars[p] = name;
System.out.println(name + "在车位" + p + "倒车入库");
//模拟实际汽车在车位停留一定思维时间
//唤醒其他线程
notifyAll();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 出库离开
*/
public synchronized void leave() {
//出库离开
if((p = findParkingWithCar())>=0){
parking[p] = false;
cars[p] = null;
System.out.println(Thread.currentThread().getName() + "在车位" + p + "出库离开");
notifyAll();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class MoveThread extends Thread {
private String name;
private User user;
public MoveThread(String name, User user) {
super(name);
this.user = user;
}
@Override
public void run() {
user.move();
}
}
class LeaveThread extends Thread {
private String name;
private User user;
public LeaveThread(String name, User user) {
super(name);
this.user = user;
}
@Override
public void run() {
user.leave();
}
}
public class Problem2 {
public static void main(String[] args) {
User user = new User();
//创建多个线程和用户
for (int i = 0; i < 12; i++) {
new MoveThread("car" + i, user).start();
new LeaveThread("car" + i, user).start();
}
}
}
但是实际运行的结果发现每次只有少量的几次记录，如下所示
car0在车位0倒车入库
car11在车位1倒车入库
car10在车位2倒车入库
car0在车位0出库离开
问题
明明在main方法里面创建了24个线程，属于12辆汽车（包括入库和出库），为什么最终每次只有4个线程运行？
因为在main方法里面的确创建了24个线程，但是其中很多线程在执行run方法时，当不能满足里面的if判断的时候，线程将直接正常结束，这是我们不希望看见的，我们应该让其阻塞，直到满足if判断条件，因此在每个同步方法前面应该加入while判断，如果不满足，阻塞线程。
最终版
/**
* # 题目
* 假设又三个车位（可以用boolean[]数组来表示车库）可以停车，
* 写一个程序模拟多个用户开车离开，停车入库的效果。注意车位有车的时候不能停车。
*/
/**
* 用户类，封装车位信息，提供入库和出库方法
*/
class User {
private boolean[] parking = {false, false, false};//车位信息
private String[] cars = new String[3];//表示每个车位所停的汽车的名称，没有停车时为null
/**
* 从左往右找到空闲的车位
* @return
*/
public synchronized int findSpareParking() {
for (int i = 0; i < parking.length; i++) {
if (!parking[i]) {
return i;
}
}
return -1;
}
/**
* 出库操作判断，找到能够出库的汽车
* @return
*/
public synchronized int findParkingWithCar() {
for (int i = 0; i < parking.length; i++) {
//确保当前线程所代表的汽车的确是进入到车位当中
if (parking[i] && cars[i] != null && cars[i].equals(Thread.currentThread().getName())) {
return i;
}
}
return -1;
}
/**
* 倒车入库
*/
public synchronized void move() {
int p;
String name = Thread.currentThread().getName();
//不满足倒车入库条件阻塞当前线程
while (findSpareParking() < 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
p= findSpareParking();
//停车进入
parking[p] = true;
cars[p] = name;
System.out.println(name + "在车位" + p + "倒车入库");
//模拟实际汽车在车位停留一定思维时间
//唤醒其他线程
notifyAll();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* 出库离开
*/
public synchronized void leave() {
int p;
//不满足出库离开条件，阻塞线程
while (findParkingWithCar() < 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//出库离开
p = findParkingWithCar();
parking[p] = false;
cars[p] = null;
System.out.println(Thread.currentThread().getName() + "在车位" + p + "出库离开");
notifyAll();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class MoveThread extends Thread {
private String name;
private User user;
public MoveThread(String name, User user) {
super(name);
this.user = user;
}
@Override
public void run() {
user.move();
}
}
class LeaveThread extends Thread {
private String name;
private User user;
public LeaveThread(String name, User user) {
super(name);
this.user = user;
}
@Override
public void run() {
user.leave();
}
}
public class Problem2 {
public static void main(String[] args) {
User user = new User();
//创建多个线程和用户
for (int i = 0; i < 12; i++) {
new MoveThread("car" + i, user).start();
new LeaveThread("car" + i, user).start();
}
}
}