2021-11-23 JAVA实验五之线程

于 2021-11-24 14:49:44 发布
阅读量1.2k 收藏 8
点赞数 3
分类专栏： Java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52461904/article/details/121514953
版权

本博客仅为个人学习记录，查看标准答案请忽视个人作业，个人作业仅为我自己比对用。

实验内容：

（一）通过继承Thread类来创建线程

程序模板：ThreadExample.java

class Tortoise extends Thread {
	int sleepTime = 0, liveLength = 0;

	Tortoise(int sleepTime, String name, int liveLength) {
		this.sleepTime = sleepTime;
		this.liveLength = liveLength;
		setName(name); // 设置线程的名字为name
	}

	public void run() {
		while (true) {
			liveLength--;
			System.out.print("@");
			try {
				sleep(sleepTime); // 让线程调用sleep方法进入中断状态，sleepTime毫秒后线程重新排队，等待CUP资源
			} catch (InterruptedException e) {
			}
			if (liveLength <= 0) {
				System.out.print(getName() + "进入死亡状态\n");
				return; // 结束run方法的语句
			}
		}
	}
}

class Rabbit extends Thread {
	int sleepTime = 0, liveLength;

	Rabbit(int sleepTime, String name, int liveLength) {
		this.sleepTime = sleepTime;
		this.liveLength = liveLength;
		setName(name); // 设置线程的名字为name
	}

	public void run() {
		while (true) {
			liveLength--;
			System.out.print("*");
			try {
				sleep(sleepTime); // 让线程调用sleep方法进入中断状态，sleepTime毫秒后线程重新排队，等待CUP资源
			} catch (InterruptedException e) {
			}
			if (liveLength <= 0) {
				System.out.print(getName() + "进入死亡状态\n");
				return; // 结束run方法的语句
			}
		}
	}
}

public class ThreadExample {
	public static void main(String args[]) {
		Rabbit rabit;
		rabit = new Rabbit(4, "a", 3); // 新建线程rabit
		Tortoise tortoise;
		tortoise = new Tortoise(5, "b", 6); // 新建线程tortoise
		tortoise.start(); // 启动线程tortoise
		rabit.start(); // 启动线程rabit
	}
}

程序运行结果：

Tortoise线程先被启动，接着rabit线程被启动。

两个线程交替执行，具体执行情况跟初始化线程对象时指定的休眠时间和生命长度有关系。

同一个对象不能start()两次的原因是：

线程的状态会被明确的写入其公共内部枚举类型Java.lang.Thread.State中，分别是：新建（NEW），就绪（RUNNABLE），阻塞（BLOCKED），等待（WAITING）计时等待（TIMED_WAIT）,终止（TERMINATED）。在第二次调用start() 方法的时候，已经被start的线程已经不再是（NEW）状态了，所以会出错IllegalThreadStateException

程序提示：Exception in thread "main" @java.lang.IllegalThreadStateException         at java.lang.Thread.start(Thread.java:708) at ThreadExample.main(ThreadExample.java:70)

说明：tortoise.start()第一次被调用时，tortoise线程启动执行，当第二次被调用时抛出IllegalThreadStateException异常。

（二）通过向Thread()构造方法传递Runnable对象来创建线程

程序模板：ShopExample.java

class Shop implements Runnable {
	Thread zhangWorker, wangWorker, boss;

	Shop() {
		boss = new Thread(this); // 创建boss，Shop对象为boss的目标对象
		zhangWorker = new Thread(this); // 创建zhangWorker，Shop对象为zhangWorker的目标对象
		wangWorker = new Thread(this); // 创建wangWorker，Shop对象为wangWorker的目标对象
		zhangWorker.setName("张工");
		wangWorker.setName("王工");
		boss.setName("老板");
	}

	public void run() {
		int i = 0;
		if (Thread.currentThread() == zhangWorker) {
			while (true) {
				try {
					i++;
					System.out.println(zhangWorker.getName() + "已搬运了" + i + "箱苹果");
					if (i == 3)
						return;
					Thread.sleep(10000);// zhangWorker休眠10秒（10000毫秒）
				} catch (InterruptedException e) {
					System.out.println(boss.getName() + "让" + zhangWorker.getName() + "继续工作");
				}
			}
		} else if (Thread.currentThread() == wangWorker) {
			while (true) {
				try {
					i++;
					System.out.println(wangWorker.getName() + "已搬运了" + i + "箱香蕉");
					if (i == 3)
						return;
					Thread.sleep(10000);// wangWorker休眠10秒（10000毫秒）
				} catch (InterruptedException e) {
					System.out.println(boss.getName() + "让" + wangWorker.getName() + "继续工作");
				}
			}
		} else if (Thread.currentThread() == boss) {
			while (true) {
				zhangWorker.interrupt(); // 吵醒zhangWorker
				wangWorker.interrupt(); // 吵醒wangWorker
				if (!(wangWorker.isAlive() || zhangWorker.isAlive())) {
					System.out.println(boss.getName() + "下班");
					return;
				}
			}
		}
	}
}

class ShopExample {
	public static void main(String args[]) {
		Shop shop = new Shop();
		shop.zhangWorker.start();
		shop.wangWorker.start();
		shop.boss.start();
	}
}

程序运行结果：

 两次运行的结果可能会不同，原因是：

shop类内有三个线程，而java中多线程是抢占式运行，优先抢占cpu的cpu就会先分配时间片来运行，所以结果不尽相同

线程被启动后或者休眠的线程被唤醒后，会进入就绪状态，但是否进入运行状态，取决于处理机的调度

（三）按要求编写程序

1.定义抽象类Animal，定义两个行为吃eat()和移动move()；

2.通过继承实现类猫Cat、类狗Dog、类鸟Bird、猎鹰Falcon；

2.1 eat()：猫输出“吃鱼。”，狗输出“吃骨头。”，鸟输出“吃虫子。”，猎鹰输出“吃蛇。”

2.2 move(): 猫输出“跳。”，狗输出“跑。”，鸟输出“飞。”，猎鹰输出“飞很高。”

3.定义IPet接口，定义行为Play()；

4.实现类PetDog，PetCat，PetRobot；

4.1 Play的行为PetDog 输出“叼飞盘”，PetCat，输出“撸撸猫”，PetRobot，输出“编程玩吧”

4.2 为类PetDog，PetCat添加名字属性Name， 以及get_name和set_name方法

5.生成测试类Stage，在测试类中生成3只狗，2只猫，1只猎鹰，1只鸟，1只宠物狗，1只宠物猫，1只机器宠物；

5.1 为宠物猫和宠物狗取名

5.2生成list列表，用于存放生成的所有动物，通过迭代器遍历列表，让所有动物吃东西eat()，移动move()

5.3 为所有动物增加体重属性，每次吃东西后会增加体重，每个动物体重增加基于种类，且应该是随机的

5.4 按体重为动物排序 

5.5 将所有宠物存储在哈希表中，根据用户输入宠物名称，从哈希表中找出相应对象交互play()

标准答案：

Animal类：

import java.util.Random;

abstract class Animal implements Comparable<Animal> {
	private int _weight;
	abstract void eat();
	abstract void move();
	public int get_weight() {
		return _weight;
	}

	public void set_weight(int _weight) {
		this._weight = _weight;
	}

	@Override
	public int compareTo(Animal o) {
		// TODO Auto-generated method stub
		return this._weight - o._weight;
	}

	public void print_weight() {
		System.out.println(_weight);
	}
}

Bird类：

import java.util.Random;

public class Bird extends Animal {
	@Override
	void eat() {
		// TODO Auto-generated method stub
		this.set_weight(this.get_weight() + (new Random()).nextInt(10));
		System.out.println("吃虫子");
	}

	@Override
	void move() {
		// TODO Auto-generated method stub
		System.out.println("飞");
	}
}

Cat类：

import java.util.Random;

public class Cat extends Animal {
	@Override
	void eat() {
		// TODO Auto-generated method stub
		this.set_weight(this.get_weight() + (new Random()).nextInt(20));
		System.out.println("吃鱼");
	}

	@Override
	void move() {
		// TODO Auto-generated method stub
		System.out.println("跳");
	}
}

Dog类：

import java.util.Random;

public class Dog extends Animal {
	@Override
	void eat() {
		// TODO Auto-generated method stub
		this.set_weight(this.get_weight() + (new Random()).nextInt(130));
		System.out.println("吃骨头");
	}

	@Override
	void move() {
		// TODO Auto-generated method stub
		System.out.println("跑");
	}
}

Falcon类：

import java.util.Random;

public class Falcon extends Bird {
	@Override
	void eat() {
		// TODO Auto-generated method stub
		this.set_weight(this.get_weight() + (new Random()).nextInt(40));
		System.out.println("吃蛇");
	}

	@Override
	void move() {
		// TODO Auto-generated method stub
		System.out.println("飞很高");
	}
}

IPet接口：

public interface IPet {
	public void Play();
}

PetCat类：

public class PetCat extends Cat implements IPet {
	public PetCat(String _name) {
		this._name = _name;
	}

	private String _name;

	public String get_name() {
		return _name;
	}

	public void set_name(String _name) {
		this._name = _name;
	}

	@Override
	public void Play() {
		// TODO Auto-generated method stub
		System.out.println(this._name + "撸撸猫");
	}
}

PetDog类：

public class PetDog extends Dog implements IPet {
	private String _name;

	public String get_name() {
		return _name;
	}

	public void set_name(String _name) {
		this._name = _name;
	}

	@Override
	public void Play() {
		// TODO Auto-generated method stub
		System.out.println(this._name + "调飞盘");
	}
}

PetRobot类：

public class PetRobot implements IPet {
	public PetRobot(String _name) {
		this._name = _name;
	}

	public String get_name() {
		return _name;
	}

	public void set_name(String _name) {
		this._name = _name;
	}

	private String _name;

	@Override
	public void Play() {
		// TODO Auto-generated method stub
		System.out.println(this._name + "编程玩吧");
	}
}

Stage类：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Hashtable;

public class Stage {
	public static String s;

	public static void main(String[] args) { // TODO Auto-generated method stub
		List<Animal> animalList = new ArrayList<Animal>();
		for (int i = 0; i < 3; i++) {
			animalList.add(new Dog());
		}
		for (int i = 0; i < 2; i++) {
			animalList.add(new Cat());
		}
		animalList.add(new Bird());
		animalList.add(new Falcon());
		PetDog pd = new PetDog();
		pd.set_name("Dot");
		PetCat pc = new PetCat("Meow");
		PetRobot pr = new PetRobot("Alpha");
		animalList.add(pd);
		animalList.add(pc);
		for (Iterator<Animal> it = animalList.iterator(); it.hasNext();) {
			Animal a = it.next();
			a.eat();
			a.move();
			a.print_weight();
		}
		Collections.sort(animalList);
		Hashtable h = new Hashtable();
		h.put(pc.get_name(), pc);
		h.put(pr.get_name(), pr);
		h.put(pd.get_name(), pd);
		((IPet) h.get("Alpha")).Play();
	}
}

个人作业：

import java.util.*;

abstract class Animal {
	private int weight = 5;

	public int getWeight() {
		return weight;
	}

	public void setWeight(int w) {
		weight += w;
	}

	public abstract void eat();

	public abstract void move();
}

class Cat extends Animal {
	public void eat() {
		System.out.println("吃鱼");
		setWeight((int) (4 + Math.random() * 2));
	}

	public void move() {
		System.out.println("跳");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("吃骨头");
		setWeight((int) (6 + Math.random() * 3));
	}

	public void move() {
		System.out.println("跑");
	}
}

class Bird extends Animal {
	public void eat() {
		System.out.println("吃虫子");
		setWeight((int) (1 + Math.random() * 2));
	}

	public void move() {
		System.out.println("飞");
	}
}

class Falcon extends Animal {
	public void eat() {
		System.out.println("吃蛇");
		setWeight((int) (3 + Math.random() * 2));
	}

	public void move() {
		System.out.println("飞很高");
	}
}

interface IPet {
	public void Play();
}

class PetCat extends Cat implements IPet {
	private String Name;

	public String get_name() {
		return Name;
	}

	void set_name(String name) {
		Name = name;
	}

	public void Play() {
		System.out.println("撸撸猫");
	}
}

class PetDog extends Dog implements IPet {
	private String Name;

	public String get_name() {
		return Name;
	}

	void set_name(String name) {
		Name = name;
	}

	public void Play() {
		System.out.println("叼飞盘");
	}
}

class PetRobot implements IPet {
	private String Name;

	PetRobot(String name) {
		Name = name;
	}

	public String get_name() {
		return Name;
	}

	void set_name(String name) {
		Name = name;
	}

	public void Play() {
		System.out.println("编程玩吧");
	}

}

public class Stage {
	public static void main(String a[]) {
		List<Animal> animalList = new ArrayList<Animal>();
		for (int i = 0; i < 3; i++) {
			animalList.add(new Dog());
		}
		for (int i = 0; i < 2; i++) {
			animalList.add(new Cat());
		}
		animalList.add(new Falcon());
		animalList.add(new Bird());
		PetDog petdog = new PetDog();
		PetCat petcat = new PetCat();
		PetRobot petrobot = new PetRobot("阿尔玛狗");
		petdog.set_name("旺财");
		petcat.set_name("坚果");
		animalList.add(petdog);
		animalList.add(petcat);

        //通过迭代器遍历列表
		Iterator iter = animalList.iterator();
		while (iter.hasNext()) {
			Animal e = (Animal) iter.next();
			e.eat();
			e.move();
		}

        //按照体重给列表中的动物排序
		System.out.println("动物体重排序后：");
		Collections.sort(animalList, new Comparator<Animal>() {
			public int compare(Animal a1, Animal a2) {
				return a1.getWeight() - a2.getWeight();
			}
		});

		for (Animal e : animalList) {
			System.out.print(e.getClass().getSimpleName() + ':');
			System.out.println(e.getWeight());
		}

        //创建宠物的哈希表
		HashMap<String, IPet> petHashMap = new HashMap<>();
		petHashMap.put(petdog.get_name(), petdog);
		petHashMap.put(petcat.get_name(), petcat);
		petHashMap.put(petrobot.get_name(), petrobot);
		System.out.println("请输入宠物名称：");
		Scanner scanner = new Scanner(System.in);
		String str = scanner.next();
		if (petHashMap.containsKey(str)) {
			petHashMap.get(str).Play();
		}
	}
}

个人作业运行结果：

本次记录就到这~

椰子鸡米花
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值