头歌《习题答案》

最新推荐文章于 2024-04-22 22:13:53 发布
最新推荐文章于 2024-04-22 22:13:53 发布
阅读量1.9k 收藏 3
点赞数 2
文章标签： java android 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73485795/article/details/133902606
版权

1.第一关

（1）共享；小

（2）继承Thread类；实现Runnable接口

2.第二关

（1）新建状态

（2）就绪状态

（3）运行状态

（4）阻塞状态

（5）死亡状态

3.第三关

package step1;

class Thread1 extends Thread {
    @Override
    public void run() {//循环输出10次北京，每次显示后需休眠一段时间（1000毫秒以内）
        /******** Begin ********/
        for(int i = 0; i < 10; i++) {
System.out.println("北京");
try {
sleep(1000);
}
catch(Exception e) {}
}


        /********  End  ********/
    }
}
class Thread2 implements Runnable {
    @Override
    public void run() {//循环输出10次西安，每次显示后需休眠一段时间（1000毫秒以内）
        /******** Begin ********/
        for(int i = 0; i < 10; i++) {
System.out.println("西安");
try {
Thread.sleep(1000);
}
catch(Exception e) {}
}


        /********  End  ********/
    }
}
public class Exe8_3 {
    public static void main(String[] args) {
        //创建 Thread1 对象 和 Thread2 对象并启动两个线程
        /******** Begin ********/
        Thread1 thread1 = new Thread1();
Thread2 thread2 = new Thread2();
thread1.start();
new Thread(thread2).start();


        /********  End  ********/
    }
}

4.第四关

package step2;
// 协助三个线程之间通信的类
class SyncObject {
}
//线程A和B的类
class WaitThread extends Thread {
final SyncObject so;
String name;
WaitThread(SyncObject so, String name) {
this.so = so;
this.name = name;
}
@Override
public void run() {
synchronized(so) { //获得锁旗标
/******** Begin ********/
System.out.println(name + " start");
try {
so.wait(); 
}
catch(Exception e) {
e.printStackTrace();
}
so.notifyAll(); //唤醒其他线程
System.out.println(name + " end");
/******** End ********/
}
}
}
//线程C的类
class NotifyThread extends Thread {
String name;
final SyncObject so;
NotifyThread(SyncObject so, String name) {
this.so = so;
this.name = name;
}
@Override
public void run() {
synchronized(so) {
/******** Begin ********/
try {
sleep(5000); //sleep后唤醒其他线程，然后自己wait
so.notifyAll();
so.wait();
}
catch(Exception e) {
e.printStackTrace();
}
System.out.println(name + " end");
/******** End ********/
}
}
}
//测试类，执行A，B，C三个线程
public class Exe8_4 {
public static void main(String[] args) {
SyncObject so = new SyncObject();
WaitThread thread1 = new WaitThread(so, "A");
WaitThread thread2 = new WaitThread(so, "B");
NotifyThread thread3 = new NotifyThread(so,"C");
/******** Begin ********/
thread1.start();
thread2.start();
thread3.start();
/******** End ********/
}
}

5.第五关

package step3;

//数据单元类，在其中实现写入和读出的同步
class DataUnit {
int number;
String name;
boolean available;
DataUnit() {
this.number = 0;
this.name = "";
this.available = false;
}
public synchronized void write(int number, String name) {
/******** Begin ********/
if(available) { //如果有内容，则不能写，开始wait
try {
wait();
}
catch(Exception e) {
e.printStackTrace();
} 
}
/******** End ********/
System.out.println("Write " + number + "\t" + name);
this.number = number;
this.name = name;
available = true;
notify();
}
public synchronized void read() {
/******** Begin ********/
if(!available) { //如果没有内容，则不能读，开始wait
try {
wait();
}
catch(Exception e) {
e.printStackTrace();
}
}
/******** End ********/
System.out.println("Read " + number + "\t" + name);
available = false;
notify();
}
}
class DataWriter extends Thread{
DataUnit du;
DataWriter(DataUnit du) {
this.du = du;
}
@Override
public void run() {
/******** Begin ********/
for(int i = 0; i < 10; i++) { //写入10次
du.write(i, "Name" + i);
}
/******** End ********/
}
}
class DataReader extends Thread {
DataUnit du;
DataReader(DataUnit du) {
this.du = du;
}
@Override
public void run() {
/******** Begin ********/
for(int i = 0; i < 10; i++) { //读出10次
du.read();
}
/******** End ********/
}
}
public class Exe8_5 {
public static void main(String[] args) {
/******** Begin ********/
DataUnit du = new DataUnit();
DataWriter dw = new DataWriter(du);
DataReader dr = new DataReader(du);
dr.start();
dw.start();
/******** End ********/
}
}

6.第六关

package step4;
class CountThread extends Thread {
int num;
String name;
public CountThread(int num, String name) {
this.num = num;
this.name = name;
}
@Override
public void run() { // 在run方法中打印每次数数 
/******** Begin ********/
for(int i = 0; i < num; i++) {
System.out.println(name + ":" + i);
}
/******** End ********/
System.out.println(name + " counts finish");
}
}
public class Exe8_6 {
public static void main(String[] args) {
CountThread ct1 = new CountThread(50000, "thread 1");
CountThread ct2 = new CountThread(50000, "thread 2");
/******** Begin ********/
ct1.setPriority(2); //设置第一个线程优先级为2
ct2.setPriority(8); //设置第二个线程优先级为8
ct1.start(); //启动线程
ct2.start();
/******** End ********/
}
}

7.第七关

package step5;
import java.util.*;
//两个线程共享
class SyncObject {
public int flag;//标记位，用于控制线程2是否sleep以及是否打印
}
class Thread1 extends Thread{
SyncObject so;
Thread1 (SyncObject so) {
this.so = so;
}
@Override
public void run() {
//线程1打印2500次，此时线程2不sleep
/******** Begin ********/
Calendar start = Calendar.getInstance();
for(int i = 0; i < 1000; i++) {
System.out.println("thread1:" + i);
}
Calendar end = Calendar.getInstance();
long time1 = end.getTimeInMillis() - start.getTimeInMillis();
/******** End ********/
so.flag = 1;//设置flag为1，此后线程2将sleep
/******** Begin ********/
start = Calendar.getInstance();
for(int i = 0; i < 1000; i++) {
System.out.println("thread1 again:" + i);
}
end = Calendar.getInstance();
long time2 = end.getTimeInMillis() - start.getTimeInMillis();
/******** End ********/
System.out.println("第一次打印，用时：" + time1);
System.out.println("第二次打印，用时：" + time2);
so.flag = 2;//设置flag为2，此后线程2将不打印，便于查看结果
}
}
class Thread2 extends Thread {
SyncObject so;
Thread2(SyncObject so) {
this.so = so;
}
@Override
public void run() {
/******** Begin ********/
for(int i = 0; i < 2000; i++) {
if(so.flag == 1) { //若flag为1， 则sleep
try {
sleep(1000);
}
catch(Exception e) {
e.printStackTrace();
}
}
else if(so.flag == 0)//若flag为0，则线程2将不打印，便于查看结果
System.out.println("thraed2:" + i);
/******** End ********/
}
}
}
public class Exe8_7 {
public static void main(String[] args) {
SyncObject so = new SyncObject();
so.flag = 0;
Thread1 tr1 = new Thread1(so);
Thread2 tr2 = new Thread2(so);
/******** Begin ********/
tr1.setPriority(2);
tr2.setPriority(8);//设置线程2优先级高于线程1
tr1.start();
tr2.start();
/******** End ********/
}
}

8.第八关

package step6;
class SonThread extends Thread {
int flag = 0;
@Override
public void run() {
/******** Begin ********/
for (int i = 0; i < 5000; i++) {
if (flag == 0) {
System.out.println("i = " + i);
} else {
return;
}
}
/******** End ********/
}
}
public class Exe8_8 {
public static void main(String[] args) {
/******** Begin ********/
SonThread t = new SonThread();
t.start();
for (int j = 0; j < 200; j++) {
System.out.println("j = " + j);
}
t.interrupt();
t.flag = 1;
for (int j = 2000; j < 4000; j++) {
System.out.println("j = " + j);
}
    }
}

9.第九关

package step7;
import java.util.*;
class Goods {
    Goods(String name, float price) {
        this.name = name;
        this.price = price;
    }
    String name;
    float price;
}
class MyList {
    MyList() {
        goodsList = new ArrayList<Goods>();
    }
    ArrayList<Goods> goodsList;
    //放一个
    public synchronized void put(Goods g) {
        /******** Begin ********/
        goodsList.add(g);
        notifyAll();



        /********  End  ********/
    }
    //放若干个
    public synchronized void put(Goods[] g) {
        /******** Begin ********/
        goodsList.addAll(java.util.Arrays.asList(g));
        notifyAll();



        /********  End  ********/
    }
    //取一个
    public synchronized Goods get() {
        /******** Begin ********/
        while (goodsList.size() == 0) {
        try {
        wait();
        } catch (Exception e) {
// e.printStackTrace();
}
}
Goods g = goodsList.remove(0);
return g;



        /********  End  ********/
    }
    //取若干个，个数为n
    public synchronized Goods[] get(int n) {
        /******** Begin ********/
        while (goodsList.size() < n) {
try {
wait();
} catch (Exception e) {
// e.printStackTrace();
}
}
Goods[] g = new Goods[n];
for (int i = 0; i < n; i++) {
g[i] = goodsList.remove(0);
}
return g;



        /********  End  ********/
    }
}
class MyThread1 extends Thread {
    MyList goodsList;
    MyThread1(MyList goodsList) {
        this.goodsList = goodsList;
    }
    @Override
    public void run() {
        //循环10次，每次放一个
        for (int i = 1; i <= 10; i++) {
            goodsList.put(new Goods("thread1:" + i, (float) i / 10));
            System.out.println(i + ":Thread1 put");
        }
    }
}
class MyThread2 extends Thread {
    MyList goodsList;
    MyThread2(MyList goodsList) {
        this.goodsList = goodsList;
    }
    @Override
    public void run() {
        //循环10次，每次取一个
        for (int i = 1; i <= 10; i++) {
            goodsList.get();
            System.out.println(i + ":Thread2 get");
        }
    }
}
class MyThread3 extends Thread {
    MyList goodsList;
    MyThread3(MyList goodsList) {
        this.goodsList = goodsList;
    }
    @Override
    public void run() {
        //循环10次，每次放两个
        for (int i = 1; i <= 10; i++) {
            Goods[] goods = new Goods[2];
            goods[0] = new Goods("thread3:" + i, (float) i / 20);
            goods[1] = new Goods("thread3:" + i, (float) i / 50);
            goodsList.put(goods);
            System.out.println(i + ":Thread3 put");
        }
    }
}
class MyThread4 extends Thread {
    MyList goodsList;
    MyThread4(MyList goodsList) {
        this.goodsList = goodsList;
    }
    @Override
    public void run() {
        //循环10次，每次取两个
        for (int i = 1; i <= 10; i++) {
            goodsList.get(2);
            System.out.println(i + ":Thread4 get");
        }
    }
}
//测试类
public class Exe8_9 {
    public static void main(String[] args) {
        MyList goodsList = new MyList();
        MyThread1 thread1 = new MyThread1(goodsList);
        MyThread2 thread2 = new MyThread2(goodsList);
        MyThread3 thread3 = new MyThread3(goodsList);
        MyThread4 thread4 = new MyThread4(goodsList);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

10.第十关

package step8;
class MyThread extends Thread{
    String name;
    StringBuffer sendString;
    StringBuffer recvString;
    MyThread(String name, StringBuffer sendString, StringBuffer recvString) {
        this.name = name;
        this.sendString = sendString;
        this.recvString = recvString;
    }
    @Override
    public void run() {
        //循环100次，每次循环都sleep一段随机事件，然后收发消息
        /******** Begin ********/
        for(int i = 0; i < 100; i++) {
            int time = (int)(Math.random() * 100);
            try {
                sleep(time);
            }
            catch(Exception e) {
                e.printStackTrace();
            }
            sendMsg();
            recvMsg();
         /********  End  ********/
        }
    }
    //发送消息
    public void sendMsg() {
        synchronized(sendString) {
              /******** Begin ********/
            while(sendString.length() > 0) {
                try {
                    sendString.wait();
                }
                catch(Exception e) {
                    e.printStackTrace();
                }
            }
            double content = Math.random();
            sendString.append(name + content);
            /********  End  ********/
            System.out.println(name + " send " + content);
            sendString.notify();
        }
    }
    //接收消息
    public void recvMsg() {
        synchronized(recvString) {
              /******** Begin ********/
            while(recvString.length() == 0) {
                try {
                    recvString.wait();
                }
                catch(Exception e) {
                    e.printStackTrace();
                }
            }
            /********  End  ********/
            System.out.println(name + " recv " + recvString);
            recvString.delete(0, recvString.length());
            recvString.notify();
        }
    }
}
//测试类
public class Exe8_10 {
    public static void main(String[] args) {
        StringBuffer string1 = new StringBuffer();
        StringBuffer string2 = new StringBuffer();
        MyThread thread1 = new MyThread("A", string1, string2);
        MyThread thread2 = new MyThread("B", string2, string1);
        thread1.start();
        thread2.start();
    }
}

蜡 笔 小 辛
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java面向对象程序设计课后答案全解
12-28
java面向对象程序设计全书课后答案全解！ 包括每章节课后题的程序代码！
Python循环结构练习题答案及源码
03-12
练习1：输入一个正整数判断是不是素数。 练习2：输入两个正整数，计算它们的最大公约数和最小公倍数。 练习3：打印如下所示的三角形图案。
头歌Java实验面向对象高级
最新发布
toptopniba的博客
04-22 734
第1关：类的继承和super关键字。
头歌平台Java实验：Java面向对象高级
jing13_13的博客
04-18 4109
2.实现Demo接口，完善接口中的show方法，打印输出 “实现了接口中的show方法”System.out.println("实现了接口中的show方法");1.编写MyInterface接口，含一个抽象方法sayHi，返回值为void。System.out.println("接口定义完成");根据提示，在右侧编辑器补充代码，完成接口的书写和接口的实现。实现了接口中的show方法。
面向对象程序设计_头歌答案
wang_0206的博客
11-13 1699
Java入门 - Java初体验
EducoderJava面向对象 - 类与对象
热门推荐
qq_44921671的博客
03-10 1万+
EducoderJava面向对象 - 类与对象 1.什么是类，如何创建类 public class Test { public static void main(String[] args) { /********** Begin **********/ //创建Dog对象 //设置Dog对象的属性 Dog wuhuarou = new Dog(); wuhuarou.name = "五花肉"; wuhuarou.color = "棕色"; wuhuar
java常用类
李响
11-02 1235
package case6; import java.util.Scanner; import java.lang.Math; public class MathTest { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int a1 = sc.nextInt(); in...
java封装，继承和多态
李响
11-25 2549
1 package case8; public class TestPolymorphism { public static void main(String[] args) { // 以多态方式分别实例化子类对象并调用eat()方法 /********* begin *********/ Animal a=new Cat(); Animal b=new Dog(); Animal c...
java期末练习题和答案.doc
01-07
选择题 1. main 方法是 Java 应用程序执行的入口点，main 方法头的正确写法是 `public static void main(String[] args)`。 知识点：Java 应用程序的入口点是 main 方法，main 方法头的写法是固定的，`public ...
MongoDB查询练习题及答案
07-29
NoSQL数据库之MongoDB查询
JavaWeb编程技术沈泽刚版教材课后习题答案
07-02
JavaWeb编程技术沈泽刚版微课版教材课后习题详细答案 2、Servlet是在容器中运行的组件，有一个从创建到销毁的过程，其中包括加载和实例化、初始化、提供服务以及销毁几个阶段。其中生命周期方法有init()、service()...
《Java面向对象编程》思考题及答案PDF
07-12
《Java面向对象编程》思考题及答案PDF，需要的下载
C++面向对象程序设计课后题答案.pdf
09-30
C++面向对象程序设计课后题答案.pdf
Educoder题目：Java面向对象 - 封装、继承和多态答案解析.md
11-08
Educoder题目：Java面向对象 - 封装、继承和多态答案解析
头歌教学实践平台计算机组成原理实验题答案.zip
12-26
本资源“头歌教学实践平台计算机组成原理实验题答案.zip”为学习者提供了在头歌教学实践平台上进行相关实验的解答，帮助学生理解和掌握计算机硬件的基础知识。 一、运算器设计 运算器是计算机中的一个重要组成部分...
头歌 C#专题四 类与对象
qq_53679247的博客
01-31 2689
第3关：private、protected、public、internal的区别 任务要求 评论28 任务描述 相关知识 public internal private protected 编程要求 测试说明 任务描述 随着我国国力逐渐强盛，在多个城市中已经搭建了更为方便的公共交通：地铁。 搭乘地铁的之前，工作人员会对所有乘客进行安检，除了乘客的提包，而且还要确保乘客没有随身携带危险物品。 本关任务：编写一个乘客类，乘客成员属性包括提包和衣物，其中提包对工作人员是可见的，而
第六讲 Java面向对象-Java中的异常 （头歌答案）
Molly 的博客
03-14 9813
第六讲 内部类 异常处理 第1关：Java 中的异常处理机制 第2关：捕获异常 源码 第3关：抛出异常 源码： 第4关：自定义异常 源码
头歌 第7章 函数2（课后习题8~12）第1关：习题8 椰子数
Fs_Miko的博客
12-31 1026
堆，还剩下1个给猴子，自己藏起1堆；第3个和第4个等水手按此方法处理。最后1个水手把剩下的椰子分成等量的。个水手，再岛上发现一堆椰子，先由第一个水手把椰子分为等量的。堆，还剩下一个给猴子，自己藏起1堆；再由第2个水手将剩下的。输入水手个数，输出椰子个数。输入：3 输出：25。编程，并输出这堆椰子至少有多少个？堆，同样剩下1个给猴子。堆椰子混合后重新分成等量的。ps.此题答案设置有问题。
头歌educoder-Python程序设计-第五阶段 类与对象-类的基础语法
她与剑意皆失的博客
12-04 1万+
关卡一：类的声明与定义 # 请在下面填入定义Book类的代码 ########## Begin ########## class Book: ########## End ########## '书籍类' def __init__(self,name,author,data,version): self.name = name self.author = author self.data = data self.ve...
头歌实践作业答案c++之递归练习题
11-28
头歌实践作业答案c的递归练习题涉及到递归算法的理解和运用。在回答这道题目时，首先要明确递归的概念和特点。递归是指一个函数通过不断调用自身来解决问题的方法。在解答递归练习题时，需要考虑递归的终止条件和递归的处理过程。 对于头歌实践作业答案c的递归练习题，我首先会仔细阅读题目要求，理解问题的本质。然后，我会思考如何设计递归函数来解决这个问题。在编写递归函数时，我会注意设置递归的终止条件，以防止递归无限循环。接着，我会考虑递归的处理过程，确保每次递归调用都能有效地向问题的解决方向前进。 在实际编写代码时，我会先进行递归函数的定义，然后在主函数中调用递归函数，并传入初始参数。在调试过程中，我会逐步验证递归函数的逻辑是否正确，并注意处理边界情况。最后，我会进行测试用例的检验，确保递归函数能够正确地解决问题，并得出正确的结果。 总的来说，解答头歌实践作业答案c的递归练习题需要理解递归的概念，设计合适的递归函数，编写正确的代码，并进行充分的测试验证。递归是一种重要的算法思想，掌握好递归的使用方法对于解决问题非常有帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值