1.1 卖电影票
执行代码：
package ThreadExercises.exercise1;
//卖电影票
/*
* 共有1000张电影票可以在两个窗口领取
* 假设每次领取的时间为3000毫秒
* 要求:请用多线程模拟卖票过程并打印剩余电影票的数量
* */
public class Dom1 {
public static void main(String[] args) {
//创建两个窗口，卖票
cinema c1 = new cinema();
cinema c2 = new cinema();
//设置名字
c1.setName("窗口1");
c2.setName("窗口2");
//开启线程
c1.start();
c2.start();
}
}
继承的代码：
package ThreadExercises.exercise1;
public class cinema extends Thread{
//创建统一票数
static int ticket = 0;
@Override
public void run() {
while (true){
synchronized (cinema.class){
//判断是否达标
if (ticket == 1000){
break;
}else {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
//没有达标
ticket++;
System.out.println(getName() +"正在买第"+ticket+"张票，还剩余"+(1000-ticket));
}
}
}
}
}
1.2 送礼品
package ThreadExercises.exercise2;
import ThreadExercises.exercise1.cinema;
public class Dom2 {
public static void main(String[] args) {
//创建两个窗口，卖票
StoreThread c1 = new StoreThread();
StoreThread c2 = new StoreThread();
//设置名字
c1.setName("窗口1");
c2.setName("窗口2");
//开启线程
c1.start();
c2.start();
}
}
public class StoreThread extends Thread{
//创建统一票数
static int gift = 100;
@Override
public void run() {
while (true){
synchronized (cinema.class){
//判断是否达标
if (gift == 10){
break;
}else {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
//没有达标
gift--;
System.out.println(getName() +"正在送第"+(100-gift)+"礼物，还剩余"+gift);
}
}
}
}
}
1.3 打印奇数
package ThreadExercises.exercise3;
public class Dom3 {
public static void main(String[] args) {
//创建线程
NumThread t1 = new NumThread();
t1.start();
}
}
package ThreadExercises.exercise3;
public class NumThread extends Thread{
//创建一个数来同意统计数
static int number = 1;
@Override
public void run() {
while (true){
synchronized (NumThread.class){
//进行判断是否超过范围
if (number == 100){
//超过范围
break;
}else {
//没超过范围，进行奇数判断
if (number %2 != 0){
//当前为奇数，打印，然后+1
System.out.print(number+" ");
number++;
}else {
//当前为偶数，直接+1
number++;
}
}
}
}
}
}
1.4 抢红包
package ThreadExercises.exercise4;
/*
* 抢红包也用到了多线程假设:100块，分成了3个包，现在有5个人去抢。其中，红包是共享数据。
5个人是5条线程
打印结果如下:
XXX抢到了XXX元
XXX抢到了XXX元
XXX抢到了XXX元
XXX没抢到
XXX没抢到
* */
public class Dom4 {
public static void main(String[] args) {
//创建5个线程
MoneyThread t1 = new MoneyThread();
MoneyThread t2 = new MoneyThread();
MoneyThread t3 = new MoneyThread();
MoneyThread t4 = new MoneyThread();
MoneyThread t5 = new MoneyThread();
t1.setName("啊啊");
t2.setName("试试");
t3.setName("达到");
t4.setName("方法给");
t5.setName("刚刚");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
package ThreadExercises.exercise4;
import java.util.Random;
public class MoneyThread extends Thread{
//创建公用的红包大小
static double money = 100;
//创建公用的红包个数
static int count = 3;
//创建每个红包的最小值
static double MIN = 0.01;
@Override
public void run() {
synchronized (MoneyThread.class){
//首先判断是否还有红包
if (count == 0){
System.out.println(getName()+"没抢到");
}else {
//定义一个第三方变量来存储中奖数据
double prize = 0;
if (count == 1){
//表示为最后一个红包了，就把所有的钱拿给它
prize = money;
}else {
//随机大小
Random r = new Random();
double bounds = money - (count - 1 ) *2;
prize = r.nextDouble(bounds);
//不能超过最小的值
if (prize < MIN){
prize = MIN;
}
}
count--;
money = money - prize;
System.out.println(getName() + "抢到了"+prize+"块");
}
}
}
}
1.5 抽奖
package ThreadExercises.exercise5;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
/*
*
*有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为
* 110,5,20,50,100,200,500,800,2,80,300,700);
* 创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”，“抽奖箱2
* 随机从抽奖池中获取奖项元素并打印在控制台上,格式如下
每次抽出一个奖项就打印一个(随机)
抽奖箱1 又产生了一个10 元大奖
抽奖箱1 又产生了一个100 元大奖
抽奖箱1又产生了一个200 元大奖
抽奖箱1 又产生了一个 800 元大奖
抽奖箱2 又产生了一个 700 元大奖
* */
public class Dom5 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,110,5,20,50,100,200,500,800,2,80,300,700);
//创建抽奖箱
MyThread5 t1 = new MyThread5(list);
MyThread5 t2 = new MyThread5(list);
t1.setName("抽奖1");
t2.setName("抽奖2");
t1.start();
t2.start();
}
}
package ThreadExercises.exercise5;
import java.util.ArrayList;
import java.util.Collections;
public class MyThread5 extends Thread{
//创建唯一的集合
ArrayList<Integer> list;
public MyThread5(ArrayList<Integer> list) {
this.list = list;
}
@Override
public void run() {
while (true){
synchronized (MyThread5.class){
if (list.size() == 0){
//奖项全部拿出
break;
}else {
//奖项没有全部拿出
//打乱集合，创造随机性
Collections.shuffle(list);
int prize = list.remove(0);
System.out.println(getName()+"抽到了"+prize+"元");
}
}
//为了使得获取的值较为平均，让进去的线程先睡一会
try {
Thread.sleep(10);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
1.6 统计并且求最大值
package ThreadExercises.exercise6;
import MyThreadThod.MyThread;
import ThreadExercises.exercise5.MyThread5;
import java.util.ArrayList;
import java.util.Collections;
/*
* 在上一题基础上继续完成如下需求
每次抽的过程中，不打印，抽完时一次性打印(随机)在此次抽奖过程中，
* 抽奖箱1总共产生了6个奖项
分别为:10,20,100,500,2,300最高奖项为300元，总计额为932元在此次抽奖过程中，
* 抽奖箱2总共产生了6个奖项。
分别为:5,50,200,800,80,700最高奖项为800元，总计额为1835元
* */
public class Dom6 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,110,5,20,50,100,200,500,800,2,80,300,700);
//创建抽奖箱
MyThread6 t1 = new MyThread6(list);
MyThread6 t2 = new MyThread6(list);
t1.setName("抽奖1");
t2.setName("抽奖2");
t1.start();
t2.start();
}
}
package ThreadExercises.exercise6;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class MyThread6 extends Thread{
//创建唯一的集合
ArrayList<Integer> list;
public MyThread6(ArrayList<Integer> list) {
this.list = list;
}
@Override
public void run() {
ArrayList<Integer> boxList = new ArrayList<>();
while (true){
synchronized (MyThread6.class){
if (list.size() == 0){
System.out.println(getName()+boxList);
System.out.println(getName()+"最大值是："+Collections.max(boxList));
int sum = 0;
for (Integer integer : boxList) {
sum += integer;
}
System.out.println("总和是"+sum);
break;
}else {
//奖项没有全部拿出
//打乱集合，创造随机性
Collections.shuffle(list);
int prize = list.remove(0);
boxList.add(prize);
}
}
//为了使得获取的值较为平均，让进去的线程先睡一会
try {
Thread.sleep(10);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
1.7 多线程的比较
package ThreadExercises.exercise7;
import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Dom7 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,110,5,20,50,100,200,500,800,2,80,300,700);
//首先创建需要执行的任务
Mycallable7 mr = new Mycallable7(list);
//创建管理任务的窗口
FutureTask<Integer> f1 = new FutureTask<>(mr);
FutureTask<Integer> f2 = new FutureTask<>(mr);
//创建线程对象
Thread t1 = new Thread(f1);
Thread t2 = new Thread(f2);
t1.setName("抽奖箱1");
t2.setName("抽奖箱2");
//开启线程
t1.start();
t2.start();
int m1 = f1.get();
int m2 = f2.get();
if (m1>m2){
System.out.println("抽奖箱1抽到最大奖：" +m1);
}else {
System.out.println("抽奖箱2抽到最大奖：" +m2);
}
}
}
package ThreadExercises.exercise7;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.Callable;
public class Mycallable7 implements Callable {
ArrayList<Integer> list ;
public Mycallable7(ArrayList<Integer> list) {
this.list = list;
}
@Override
public Object call() throws Exception {
ArrayList<Integer> boxList = new ArrayList<>();
int max;
while (true){
synchronized (Mycallable7.class){
//首先判断是否抽奖完成
if (list.size() == 0){
//抽奖完成
//获取总的值
int sum = 0;
for (int num : boxList) {
sum += num;
}
System.out.println(Thread.currentThread().getName()+"获取到的总值"+sum+"抽到的数"+boxList);
break;
}else {
//抽奖没有完成
//将所抽到的奖项加入到boxList当中
//打乱集合，创造随机性
Collections.shuffle(list);
int prize = list.remove(0);
boxList.add(prize);
}
}
//为了使得获取到的数据较为平均
Thread.sleep(10);
}
if (boxList.size()==0){
return null;
}else {
return Collections.max(boxList);
}
}
}
1505
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
