《Java技术》第十次作业

Java第十次作业

---

一 . 学习总结

1.XMind

2.龟兔赛跑

• 代码:

      class Tortoise implements Runnable {
      private int step;
      private int step1 = 0;
      public Tortoise(int step) {
          this.step = step;
      }
      public void run() {
          running();
      }
      private synchronized void running() {
          boolean flag = true;
          while (flag) {
  	        if (step1 < this.step) {
  		        try {
  			        Thread.sleep(300);
  			        int step = (int)(Math.random()*5+1);
  			        step1++;
  			        System.out.println("小乌龟走了" + step1 + "步");
  		        } catch (InterruptedException e) {
  			        e.printStackTrace();
  		        }
  	        } else {
  		        System.out.println("小乌龟到达终点");
  		        flag = false;
  	        }
          }
      }
  }
  class Hare implements Runnable {
      private int step;
      private int step2 = 0;
      public Hare(int step) {
          this.step = step;
  	}
  	public int getStep2() {
          return step2;
      }
  	public void setStep2(int step2) {
      	this.step2 += step2;
  	}
  	public void run() {
          running();
      }
      private synchronized void running() {
          boolean flag = true;
          while (flag) {
  	        if (step2 < this.step) {
  		        try {
  			        Thread.sleep(300);
  		        	int flag1 = (int) (Math.random() * 2 + 2);
  		        	if (flag1 == 2) {// 兔子睡觉
  		      		System.out.println("小兔子睡觉啦");
  		            } else {
  				        step2 = step2 + 2;
  				        System.out.println("小兔子走了" + step2 + "步");
  			        }
  		        } catch (InterruptedException e) {
  			        e.printStackTrace();
  		        }
  	        } else {
  		        System.out.println("小兔子到达终点");
  		        flag = false;
          	}
      	}
  	}
  }
  public class Test5 {
  	public static void main(String[] args) {
          Tortoise tortoise = new Tortoise(10);
          Hare hare = new Hare(10);
      	Thread tortoiseThread = new Thread(tortoise);
       	Thread hareThread = new Thread(hare);
      	tortoiseThread.start();
      	hareThread.start();
      }
  }
  

3.生产者——消费者

• 执行结果：

        消费者开始消耗整数......
        生产者开始生产整数......
        生产者设定 (1)
        生产者设定 (2)
        生产者设定 (3)
        生产者设定 (4)
        生产者设定 (5)
        生产者设定 (6)
        生产者设定 (7)
        生产者设定 (8)
        生产者设定 (9)
        生产者设定 (10)
        消费者取走 (10)
        消费者取走 (10)
        消费者取走 (10)
        消费者取走 (10)
        消费者取走 (10)
        消费者取走 (10)
        消费者取走 (10)
        消费者取走 (10)
        消费者取走 (10)
        消费者取走 (10)
        消费者取走 (10)

• 由于没进行代码的同步与等待唤醒，消费者只会读取最后一次的结果

• 修改后代码：

        class Consumer implements Runnable {
            private Clerk clerk;
            public Consumer(Clerk clerk) {
	            this.clerk = clerk;
            }
            public void run() {
	            System.out.println("消费者开始消耗整数......");
	            // 消耗10个整数
	            for (int i = 1; i <= 10; i++) {
		            try {
			            // 等待随机时间
			            Thread.sleep((int) (Math.random() * 3000));
		            } catch (InterruptedException e) {
			            e.printStackTrace();
		            }
		        }
           }
      }
      class Producer implements Runnable {
            private Clerk clerk;
            public Producer(Clerk clerk) {
	            this.clerk = clerk;
            }
            public void run() {
	            System.out.println("生产者开始生产整数......");
	            // 生产1到10的整数
	            for (int product = 1; product <= 10; product++) {
		            try {
			            Thread.sleep((int) Math.random() * 3000);
		            } catch (InterruptedException e) {
			            e.printStackTrace();
		            }
		            clerk.setProduct(product); // 将产品交给店员
	            }
                }
             }
    class Clerk {
        private int product = -1; // -1 表示目前没有产品
        private int p ;
        // 这个方法由生产者呼叫
        public synchronized void setProduct(int product) {
	        if (this.product != -1) {
		        try {
			        super.wait();
		        } catch (InterruptedException e) {
				    e.printStackTrace();
		        }
	        }
	        this.product = product;
	        p = this.product;
	        System.out.printf("生产者设定 (%d)%n", this.product);
	        getProduct();
	        try {
		        Thread.sleep(300);
	        } catch (InterruptedException e) {
		        e.printStackTrace();
    	    }
    	    this.product = -1;
    	    super.notify();
	    }
    	    // 这个方法由消费者呼叫
    	    public synchronized int getProduct() {
	    	    if (this.product == -1) {
		    	    try {
			    	    super.wait();
		    	    }catch (InterruptedException e) {
			    e.printStackTrace();
	    		    }
    	    	}
    	    try {
	        	Thread.sleep(300);
    	    } catch (InterruptedException e) {
    	    	e.printStackTrace();
        	}
        	System.out.printf("消费者取走 (%d)%n", p);
        	this.product = -1;
        	super.notify();
        	return this.product;
     	}
     }

• 执行结果：

    生产者开始生产整数......
    消费者开始消耗整数......
    生产者设定 (1)
    消费者取走 (1)
    生产者设定 (2)
    消费者取走 (2)
    生产者设定 (3)
    消费者取走 (3)
    生产者设定 (4)
    消费者取走 (4)
    生产者设定 (5)
    消费者取走 (5)
    生产者设定 (6)
    消费者取走 (6)
    生产者设定 (7)
    消费者取走 (7)
    生产者设定 (8)
    消费者取走 (8)
    生产者设定 (9)
    消费者取走 (9)
    生产者设定 (10)
    消费者取走 (10)

---

二 . 实验总结

1.分发作业

• 程序设计思路：

  • 创建一个类实现Runnable接口，实现线程分发作业功能，注意同步代码块，实现资源共享
  • 创建Test类，进行测试

2.银行存款

• 程序设计思路：

  • 创建银行类，实现存钱时，钱数会增加，深刻理解setter方法
  • 创建用户类，实现存钱功能
  • 创建Test类，进行测试

• 问题1：

  • 钱数增加不知道在哪设置

• 原因：

  • 不能对setter方法进行灵活运用

• 解决方案：

  • 使用setter方法进行设置钱的数量变化

---

三 .代码托管

• 码云commit历史截图 代码链接

---

四 .学习进度条

进程	代码行数（新增/累积）	学习时间（新增/累积）	本周学习内容
目标	5000行	300小时
第2-4周	500/500	45/45	自学了前四章的内容，自己练习了学习过程中的所有代码，并写了一些练习题提交到了码云中
第5周	200/700	15/55	学习了老师要求的内容
第6周	300/1000	15/70	学习了作业中要求的内容
第7-8周	200/1200	15/85	掌握了本次学习的全部内容
第9周	300/1500	10/95	掌握了本次学习的内容
第10周	400/1900	10/95	掌握了本次学习的内容
第11周	600/2500	20/95	对图形界面有了一定的理解
第12周	500/3000	20/115	对Java数据库编程有了深入的理解
第13周	300/3300	20/135	对JavaIO流有了一定的认识
第14周	500/3800	10/145	对Java多线程有了深刻的认识

---