多线程练习题&多线程模拟龟兔赛跑
#千峰逆战班，NZJavaEE1901班#
在千峰"逆战"第32天学习打卡！
今天巩固学习了生产者和消费者模式、多线程练习题并简单了解了idea常用配置和使用……
继续加油！
1.你和你女朋友公用一张银行卡，你向银行卡中存取、你女朋友取钱！
package com.qf.zy1;
public class BankCard {
private int money;
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
package com.qf.zy1;
/**
* 取钱
* @author Administrator
*
*/
public class GetMoney implements Runnable {
private BankCard card;
public GetMoney(BankCard card) {
this.card = card;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if(card.getMoney()>=1000) {
synchronized (card) {
card.setMoney(card.getMoney()-1000);
System.out.println(Thread.currentThread().getName()+"取出1000元，余额为"+card.getMoney());
}
}else {
System.out.println("余额不足，请充值...");
i--;
}
}
}
}
package com.qf.zy1;
/**
* 存钱
* @author Administrator
*
*/
public class SaveMoney implements Runnable{
private BankCard card;
public SaveMoney(BankCard card) {
this.card = card;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
synchronized (card) {
card.setMoney(card.getMoney()+1000);
System.out.println(Thread.currentThread().getName()+"存入1000元，余额是"+card.getMoney());
}
}
}
}
package com.qf.zy1;
/**
* 1.你和你女朋友公用一张银行卡，你向银行卡中存取、你女朋友取钱！
* @author Administrator
*
*/
public class Test {
public static void main(String[] args) {
BankCard card=new BankCard();
SaveMoney save=new SaveMoney(card);
GetMoney get=new GetMoney(card);
Thread boy=new Thread(save, "boy");
Thread girl=new Thread(get, "girl");
boy.start();
girl.start();
}
}
2.设计两个线程，一个线程负责求出1~１０以内所有的偶数；然后，另外一个线程负责打印1~１０以内所有的奇数。
测试时，分别设置线程的优先级，观察执行的顺序。
package com.qf.zy2;
public class EvenNumber implements Runnable{
@Override
public void run() {
for (int i = 2; i <=10; i+=2) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
package com.qf.zy2;
public class OddNumber implements Runnable{
@Override
public void run() {
for (int i = 1; i <=10; i+=2) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
package com.qf.zy2;
/**
* 2.设计两个线程，一个线程负责求出1~１０以内所有的偶数；然后，另外一个线程负责打印1~１０以内所有的奇数。
* 测试时，分别设置线程的优先级，观察执行的顺序。
* @author Administrator
*
*/
public class Test2 {
public static void main(String[] args) {
Thread even=new Thread(new EvenNumber(), "偶数");
Thread odd=new Thread(new OddNumber(),"奇数");
even.setPriority(Thread.MAX_PRIORITY);
odd.setPriority(Thread.MIN_PRIORITY);
even.start();
odd.start();
}
}
3.贵妇正在看电视连续剧《芈月传》，从第1~88集，看到第10集时，来了一个送快递的，贵妇收完快递后后，继续看电视。
package com.qf.zy3;
public class Courier implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+":签收快递！");
}
}
package com.qf.zy3;
/**
* 3.贵妇正在看电视连续剧《芈月传》，从第1~88集，看到第10集时，来了一个送快递的，贵妇收完快递后后，继续看电视。
* @author LXM
* @time:2020年3月21日上午11:04:40
*/
public class Woman {
public static void main(String[] args) throws InterruptedException {
Thread courier=new Thread(new Courier(),"快递员");
for (int i = 1; i <=88; i++) {
System.out.println("贵妇看电视连续剧《芈月传》，看到了第"+i+"集!");
if(i==10) {
courier.start();
courier.join();
}
}
}
}
4.多线程模拟龟兔赛跑：
乌龟和兔子进行1000米赛跑，兔子前进5米，乌龟只能前进1米。
但兔子每20米要休息500毫秒，而乌龟是每100米休息500毫秒。
谁先到终点就结束程序，并显示获胜方
package com.qf.zy4;
public class Rabbit implements Runnable{
@Override
public void run() {
for (int i = 5; i <=1000; i+=5) {
System.out.println("兔子前进5米,兔子一共跑了"+i+"米！");
if(i==1000) {
System.out.println("比赛结束！兔子胜利");
System.exit(0);
}
if(i%20==0) {
try {
System.out.println("兔子共跑了"+i+"米,休息500毫秒！");
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
package com.qf.zy4;
public class Tortoise implements Runnable{
@Override
public void run() {
for (int i = 1; i <=1000; i++) {
System.out.println("乌龟前进1米,乌龟共跑了"+i+"米！");
if(i==1000) {
System.out.println("比赛结束！乌龟胜利");
System.exit(0);
}
if(i%100==0) {
try {
System.out.println("乌龟共跑了"+i+"米,休息500毫秒！");
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
package com.qf.zy4;
/**
* 乌龟和兔子进行1000米赛跑，兔子前进5米，乌龟只能前进1米。
* 但兔子每20米要休息500毫秒，而乌龟是每100米休息500毫秒。
* 谁先到终点就结束程序，并显示获胜方
* @author LXM
* @time:2020年3月21日上午11:17:24
*/
public class Test {
public static void main(String[] args) {
Thread rabbit=new Thread(new Rabbit(), "兔子");
Thread tortoise=new Thread(new Tortoise(), "乌龟");
System.out.println("比赛开始！");
rabbit.start();
tortoise.start();
}
}
5.编写多线程应用程序，模拟多个人通过一个山洞的模拟。这个山洞每次只能通过一个人，每个人通过山洞的时间为5秒，随机生成10个人，同时准备过此山洞，显示一下每次通过山洞人的姓名
package com.qf.zy5;
public class GuoShangDong implements Runnable {
public Object ob=new Object();
@Override
public void run() {
synchronized (ob) {
try {
System.out.println(Thread.currentThread().getName()+"进入山洞");
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName()+"通过山洞");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
package com.qf.zy5;
import java.util.HashSet;
import java.util.Set;
/**
* 5.编写多线程应用程序，模拟多个人通过一个山洞的模拟。这个山洞每次只能通过一个人，每个人通过山洞的时间为5秒，
* 随机生成10个人，同时准备过此山洞，显示一下每次通过山洞人的姓名
* @author LXM
* @time:2020年3月23日
*/
public class Test5 {
public static void main(String[] args) {
String[] peos={"张","王","李","赵","田","诸葛","孙","付","任","陈"};
Set peoslist=new HashSet();
for (String s : peos) {
peoslist.add(s);
}
GuoShangDong p=new GuoShangDong();
for (String s : peoslist) {
Thread t=new Thread(p, s);
t.start();
}
}
}
6. 铁道部发布了一个售票任务，要求销售1000张票，要求有5个窗口来进行销售，请编写多线程程序来模拟这个效果
i. 窗口001正在销售第1000张票
ii. 窗口001正在销售第999张票
iii. 窗口002正在销售第998张票
iv. 。。。
v. 窗口05正在销售第1张票
vi. 票已经销售完毕
package com.qf.zy6;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ShowTickets implements Runnable{
private int ticket=1000;
Lock l=new ReentrantLock();
@Override
public void run() {
while(true) {
try {
l.lock();
if(ticket>0) {
System.out.println(Thread.currentThread().getName()+"号窗口正在售第"+ticket+"张票");
ticket--;
}else {
System.out.println(Thread.currentThread().getName()+"号窗口票已售完！");
break;
}
} finally {
l.unlock();
}
}
}
}
package com.qf.zy6;
/**
* 6. 铁道部发布了一个售票任务，要求销售1000张票，要求有5个窗口来进行销售，请编写多线程程序来模拟这个效果
i. 窗口001正在销售第1000张票
ii. 窗口001正在销售第999张票
iii. 窗口002正在销售第998张票
iv. 。。。
v. 窗口05正在销售第1张票
vi. 票已经销售完毕
* @author LXM
* @time:2020年3月23日
*/
public class Test6 {
public static void main(String[] args) {
ShowTickets t=new ShowTickets();
for(int i=1;i<=5;i++) {
Thread a=new Thread(t,i+"");
a.start();
}
}
}
7. 计算任务，一个包含了2千个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。
package com.qf.zy7;
public class Calculate implements Runnable{
public int[] nums;
public int start;
public int end;
public int sum=0;
public Calculate(int[] nums, int start, int end) {
this.nums = nums;
this.start = start;
this.end = end;
}
@Override
public void run() {
for (int i = start; i < end; i++) {
sum+=nums[i];
}
}
}
package com.qf.zy7;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* 7. 计算任务，一个包含了2千个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。
* @author LXM
* @time:2020年3月23日
*/
public class Test7 {
public static void main(String[] args) {
int[] nums=new int[2000];
for (int i = 0; i < nums.length; i++) {
nums[i]=i+1;
}
System.out.println("请输入拆分几个线程进行计算");
Scanner input=new Scanner(System.in);
int count=input.nextInt();
int len=nums.length/count;
List clist=new ArrayList();
List tlist=new ArrayList();
for (int i = 0; i < count; i++) {
if(i==count-1) {
Calculate c=new Calculate(nums, i*len, nums.length);
clist.add(c);
Thread t=new Thread(c);
tlist.add(t);
t.start();
}else{
Calculate c=new Calculate(nums, i*len, (i+1)*len);
clist.add(c);
Thread t=new Thread(c);
tlist.add(t);
t.start();
}
}
for (Thread t : tlist) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
int a=0;
for (Calculate c : clist) {
a+=c.sum;
}
System.out.println(a);
}
}