多线程练习题&多线程模拟龟兔赛跑

关注

原创 2022-10-17 16:50:03 2.3k 阅读 AI 写同款· GEO 优化 ›

使用多线程的方法来实现龟兔赛跑问题，使用语言：JAVA 使用JAVA创建多线程，并解决龟兔赛跑问题阅读详情

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<String> peoslist=new HashSet<String>();
		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<Calculate> clist=new ArrayList<Calculate>();
		List<Thread> tlist=new ArrayList<Thread>();
		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);
	}
}