Java第十次作业

欢迎使用 Cmd Markdown 编辑阅读器#Java第十次作业

（一）学习总结

1.用思维导图对javaIO操作的学习内容进行总结

2.下面是一个单线程实现的龟兔赛跑游戏。

public class TortoiseHareRace {
    public static void main(String[] args) {
        int totalStep = 10;
        int tortoiseStep = 0;
        int hareStep = 0;
        boolean[] flags = {true,false};
        System.out.println("龟兔赛跑开始了...");
        while(tortoiseStep < totalStep && hareStep < totalStep){
            tortoiseStep++;
            System.out.println("乌龟跑了"+tortoiseStep+"步...");
            boolean isHareSleep = flags[((int)(Math.random()*10))%2];
            if(isHareSleep){
                System.out.println("兔子睡着了zzzz");
            }else{
                hareStep += 2;
                System.out.println("兔子跑了"+hareStep+"步...");
            }
        }       
    }
}

阅读程序，采用实现Runnable接口的方式用多线程实现这个小游戏

public class Tortoise implements Runnable {
	int totalStep = 10;
	int tortoiseStep = 0;

	public void run() {
		while (tortoiseStep < totalStep) {
			synchronized (this) {
				tortoiseStep++;
				System.out.println("乌龟跑了" + tortoiseStep + "步...");
			}
		}
	}
}
public class Hare implements Runnable {
	int totalStep = 10;
	int hareStep = 0;
	boolean[] flags = { true, false };

	public void run() {
		while (hareStep < totalStep) {
			synchronized (this) {
				boolean isHareSleep = flags[((int) (Math.random() * 10)) % 2];
				if (isHareSleep) {
					System.out.println("兔子睡着了zzzz");
				} else {
					hareStep += 2;
					System.out.println("兔子跑了" + hareStep + "步...");
				}
			}
		}
	}
}

public class Test { 
    public static void main(String[] args) {
        Tortoise tortoise = new Tortoise();
         Hare hare = new Hare();
        Thread tortoiseThread = new Thread(tortoise);
        Thread hareThread = new Thread(hare);
        tortoiseThread.start();
        hareThread.start();
     
    }
}

3.下面的程序是模拟了生产者——消费者问题，生产者生产10个数，消费者依次消费10个数，运行程序，看结果是否正常？存在什么问题？说明原因。使用synchronized, wait, notify解决程序出现的问题。写出修改的部分程序即可。

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();
            }              
            clerk.getProduct();// 从店员处取走整数
        }
    }
 }
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); // 将产品交给店员
        }
    } 
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Thread consumerThread = new Thread(new Consumer(clerk)); 
        Thread producerThread = new Thread(new Producer(clerk)); 
        consumerThread.start(); 
        producerThread.start(); 
    }
}
class Clerk {
    private int product = -1; // -1 表示目前没有产品 
     // 这个方法由生产者呼叫
    public void setProduct(int product) {
        this.product = product; 
        System.out.printf("生产者设定 (%d)%n", this.product);      
    } 
    // 这个方法由消费者呼叫
    public int getProduct() {          
        int p = this.product; 
        System.out.printf("消费者取走 (%d)%n", this.product);      
        return p; 
    } 
}

• 执行结果：
  
• 存在的问题：（1）生产者放了若干次的数据，消费者才开始取数据。
  （2）消费者取重复的数据。
• 修改后的程序：

class Consumer implements Runnable {
	...
			this.clerk.getProduct();// 从店员处取走整数
	...
}
class Producer implements Runnable {
      ...
           clerk.setProduct(product); // 将产品交给店员
      ...
}
public class ProductTest {
   ...
}
class Clerk {
	private int product = -1; // -1 表示目前没有产品
	private boolean flag = true;
	// 这个方法由生产者呼叫
	public synchronized void setProduct(int product) {
		if (!flag) {
			try {
				super.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.product = product;
		System.out.println("生产者设定 (%d)%n        " + this.product);
		flag = false;
		super.notify();
	}
	// 这个方法由消费者呼叫
	public synchronized int getProduct() {
		int p = this.product;
		if (flag) {
			try {
				super.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}	
		}
			System.out.println("消费者取走 (%d)%n        " + this.product);
			flag=false;
			super.notify();
		
		    return p;
	}
}

3、其他总结：多线程的应用和调用方法的区别：
调用方法只能在执行完调用的方法才可以向下执行；
多线程可以一边执行线程一边向下执行。

（二）实验总结

实验内容：
1.模拟三个老师同时分发80分作业，每个老师相当于一个线程。

• 程序设计思想：

（1）定义一个teacher类，让teacher类事项Runnable接口，再类中定义一个变量存储作业份数，重run（）方法，如果作业的份数大于0，每循环一次作业份数减1.
（2）在测试类中，定义两个线程代表两个老师，并开启这两个线程。完成两个老师分发80份作业。

• 类图：
  
• 问题1：老师发了第0本作业，也就是作业已经发完了，还有老师在发。
  
• 原因：由于操作延迟，当一个老师已经访问了这个数据还没有发时，另一个老师也访问了这个数据，导致数据不同步。
• 解决方案：使用synchronized将一个方法声明为同步方法。
  添加synchronized(this)语句：

 for (int i=0;i<100;i++)
		{
			synchronized(this)
			{
				if(book>0)
				{
                                    ...
                                 }
                        }
                 }

2.模拟一个银行存款的程序。假设有两个储户都去银行往同一个账户进行存款，一次存100，每人存三次。要求储户每存一次钱，账户余额增加100，并在控制台输出当前账户的余额。

• 程序设计思路：

（1）定义一个银行类，在类中定义一个变量存储账户中原有的钱，在定义一个方法，用于每次存入钱更新余额。
（2）定义一个用户类实现Runnable接口，定义一个变量为存入的钱数；重写run（）方法，在方法中调用银行类中的方法，实现存钱，要求每个用户存入三次，定义循环的次数小于3.
（3）在测试类中，定义两个线程代表用户，开启线程，实现存钱。

• 问题2：
  
• 原因：在用户类中定义存入钱的变量名和在银行类中定义原有钱的变量名一样。没有同步代码快。
• 解决方案：重新定义一个变量名；使用synchronized将一个方法声明为同步方法。
• 问题3：每次存入固定的100元，直接调用方法时参数直接传100.

（三）代码托管

https://git.oschina.net/hebau_cs15/Java-CS01yxr.git

（四）学习进度条

	代码行数（新增/累积）	学习时间（新增/累积）	本周学习内容
目标	5000行	300小时
第2-4周	150/300	30/30	学习了....
第5周	220/300	30/50	学习了关于double类型存在精度问题，取指定位置和截取字符串；数组的应用
第6周	550/600	60/80
第8周	700/800	60/80	面向对象的继承和多态
第9周	800/800	80/100	工厂设计和Java常用的类
第10周	800/800	80/100	异常处理和集合类
第11周	1000/1000	90/100	图形界面管理
第12周	1100/1100	100/100	JBDC
第13周	1000/1100	80/80	JavaIo
第14周	800/800	70/70	多线程