(1)某电影放映厅一共有10排，每排10个座位，座位号为“排
号+列号”，如第8排，座位号是8A-8J；
（2）此放映厅某一场次现有100张票要卖出，观众可以通过四个
渠道购票：电影院、时光网、美团和支付宝；
（3）各个售票点的效率不同，每卖出一张票，各个售票点所需要
的时间分别为：电影院3秒，时光网5秒，美团2秒，支付宝6秒；
现在这4个售票点同时售票，根据以上信息，用多线程模拟这4个
售票点的售票情况。要求打印出每个售票点所卖出电影票的座位号，
座位号随机确定。
1.定义Ticket类实现Runnable接口；
2.定义共享变量，代表票的总量；
3.使用同步技术实现，启动4个线程。
想混个采纳越来越难了
package com.home;
import lombok.SneakyThrows;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Demo {
//总票数
private static int count = 100;
//就这么多票
private static List<List<String>> list;
static {
list = new ArrayList<>(10);
for (int i = 1; i <= 10; i++) {
List<String> column = new ArrayList(10);
for (int j = 1; j <= 10; j++) {
column.add(i + "-" + j);
}
list.add(column);
}
}
public static void main(String[] args) {
Thread dianying = new Dianying();
Thread shiguang = new Shiguang();
Thread meituan = new Meituan();
Thread zhifubao = new Zhifubao();
dianying.start();
shiguang.start();
meituan.start();
zhifubao.start();
}
//0-9随机数
static int getRandom() {
Random random = new Random();
return random.nextInt(10);
}
//随机购票
static synchronized String goupiao(String name) {
if (count == 0) {
return null;
}
int i = 10;
int j = 10;
String str = null;
while (str == null) {
i = Demo.getRandom();
j = Demo.getRandom();
str = Demo.list.get(i).get(j);
}
list.get(i).set(j, null);
System.out.println("余票：" + --count);
return name + "：" + str;
}
}
class Dianying extends Thread {
@SneakyThrows
@Override
public void run() {
while (true) {
String piao = Demo.goupiao("Dianying");
if (piao == null) {
break;
}
Thread.sleep(3000l);
System.out.println(piao);
}
super.run();
}
}
class Shiguang extends Thread {
@SneakyThrows
@Override
public void run() {
while (true) {
String piao = Demo.goupiao("Shiguang");
if (piao == null) {
break;
}
Thread.sleep(5000l);
System.out.println(piao);
}
super.run();
}
}
class Meituan extends Thread {
@SneakyThrows
@Override
public void run() {
while (true) {
String piao = Demo.goupiao("Meituan");
if (piao == null) {
break;
}
Thread.sleep(2000l);
System.out.println(piao);
}
super.run();
}
}
class Zhifubao extends Thread {
@SneakyThrows
@Override
public void run() {
while (true) {
String piao = Demo.goupiao("Zhifubao");
if (piao == null) {
break;
}
Thread.sleep(6000l);
System.out.println(piao);
}
super.run();
}
}
嗯，下面代码可以参考下：
时间关系，剩下的自己解决下，关键是volatile的使用，当然，如果用静态修饰理论上也可以实现：
随机抽取没有实现，想实现的话，你可以把所有的号码随机初始化一个map，然后每次pull一个出来，就是把代码中的index++替换成成你的从号码吃取数据动作。
然后如果希望对每个售票点的票进行汇总，可以在取的时候放到一个容器里。最后输出。
import java.util.concurrent.TimeUnit;
/**
* @Classname TicketWindow
* @Description TODO
* @Date 2021/12/6 9:21
* @Created LiRuilong
*/
public class TicketWindow implements Runnable {
//最多受理100笔业务
private static final int MAX = 10*10;
// 开始业务
private volatile int index = 1;
// 受理时间
private int sleep = 0;
@Override
public void run(){
while (index <= MAX){
System.out.println("售票:"+Thread.currentThread().getName()+"\n座位号码是："+(index++));
try {
synchronized (this) {
// 这里可以把票放到对应的容器
if (Thread.currentThread().getName().equals("电影院")) {
TimeUnit.SECONDS.sleep(3);
} else if (Thread.currentThread().getName().equals("时光网")) {
TimeUnit.SECONDS.sleep(5);
} else if (Thread.currentThread().getName().equals("美团")) {
TimeUnit.SECONDS.sleep(2);
} else {
TimeUnit.SECONDS.sleep(6);
}
}
}catch( InterruptedException e){
e.printStackTrace();
}
}
}
public static void main(String[] args) {
final TicketWindow task = new TicketWindow();
//电影院3秒，时光网5秒，美团2秒，支付宝6秒；
Thread thread1 = new Thread(task,"电影院");
Thread thread2 = new Thread(task,"时光网");
Thread thread3 = new Thread(task,"美团");
Thread thread4 = new Thread(task,"支付宝");
thread1.start();
thread2.start();
thread3.start();
thread4.start();
}
}