Java程序设计实验四 多线程程序设计

[1]实验目的：理解多线程的概念，掌握创建、管理和控制Java线程对象的方法，包括创建Java线程对象、改变线程状态、设置线程优先级及控制线程调度等方法，掌握实现线程互斥和线程同步的方法。

[2]实验内容：

1、编写一个有两个线程的程序，第一个线程用来计算1~100之间的偶数及个数，第二个线程用来计算1-100之间的偶数及个数。

package experiment4;
class NumberRunnable implements Runnable{
    private final int first;
    NumberRunnable(int first){
        this.first=first;
    }
    @Override
    public void run() {
        for (int i=first;i<=100;i+=2){
            System.out.println(i+ " ");
        }
        System.out.println("结束！");
    }
}
public class Exp4_1 {
    public static void main(String[] args){
        NumberRunnable runnable1 = new NumberRunnable(1);
        NumberRunnable runnable2 = new NumberRunnable(2);
        Thread thread_odd = new Thread(runnable1,"奇数线程");
        Thread thread_even = new Thread(runnable2,"偶数线程");
        thread_odd.start();
        thread_even.start();
    }
}

 

  

2、编写一个Java应用程序，在主线程中再创建两个线程，要求线程经历四种状态：新建，运行、中断和死亡。按模板要求，将【代码1】~【代码8】替换为Java程序代码。

class Tortoise extends Thread
{     int sleepTime=0, liveLength=0;
      public Tortoise(String name,int sleepTime, int liveLength)
      {      
            this.sleepTime=sleepTime;
            this.liveLength=liveLength; 
            【代码1】 // 设置线程的名字为name
      }
      public void run()
      {   while (true )
          {
              liveLength--;
	           System.out.println("@_@");
               try{  
                   【代码2】 // 让线程调用sleep()方法进入中断状态
                }
               catch (InterruptedException e) {}
                if (liveLength<=0 )
                {
                    System.out.println(getName()+"进入死亡状态\n");
	                【代码3】 // 结束run()方法的语句
                 }
             }
      }
}
class Rabit extends Thread
{
      int sleepTime=0, liveLength=0;
      public Rabit(String name,int sleepTime, int liveLength)
      {
            【代码4】 // 调用父类构造函数，设置线程的名字为name
            this.sleepTime=sleepTime;
            this.liveLength=liveLength;
      }
      public void run()
      {
             while (true )
             {
                  liveLength--;
	              System.out.println("*_*");
                 try{
                           sleep( sleepTime);
                }
               catch (InterruptedException e) {}
                if (liveLength<=0 )
                {
                     System.out.println(getName()+"进入死亡状态\n");
	                  break;
                 }
             }
      }
}
public  class ThreadExample
{
     public static void main(String a[])
    {
         Rabit rabit;
         rabit =【代码5】  // 新建线程rabit
        Tortoise tortoise =【代码6】  // 新建线程tortoise
        【代码7】  // 启动线程tortoise
        【代码8】  // 启动线程rabit
    }
}

package experiment4;
class Tortoise extends Thread
{
    int sleepTime,liveLength;
    public Tortoise(String name,int sleepTime,int liveLength)
    {
        super(name);//【代码1】设置线程的名字为name
        this.sleepTime=sleepTime;
        this.liveLength=liveLength;
    }
    public void run()
    {
        while(true)
        {
            liveLength--;
            System.out.println("@_@");
            try {
                sleep(sleepTime);//【代码2】让线程调用sleep（）方法进入中断状态
            }
            catch(InterruptedException ignored) {}
            if(liveLength<=0)
            {
                System.out.println(getName()+"进入死亡状态\n");
                break;//【代码3】结束run()方法的语句
            }
        }
    }
}

class Rabbit extends Thread
{
    int sleepTime,liveLength;
    public Rabbit(String name,int sleepTime,int liveLength)
    {
        super(name);//【代码4】调用父类构造函数，设置线程的名字为name
        this.sleepTime=sleepTime;
        this.liveLength=liveLength;
    }
    public void run()
    {
        while(true)
        {
            liveLength--;
            System.out.println("*_*");
            try {
                sleep(sleepTime);
            }
            catch(InterruptedException ignored) {}
            if(liveLength<=0)
            {
                System.out.println(getName()+"进入死亡状态\n");
                break;
            }
        }
    }
}

public class Exp4_2 {
    public static void main(String[] args){
        Rabbit rabbit;
        rabbit = new Rabbit("Rabbit",200,100);
        Tortoise tortoise = new Tortoise("Tortoise", 200,100);
        rabbit.start();
        tortoise.start();
    }
}

 

 

*3、编写Java应用程序模拟5个人排队买票。售票员只有1张五元的钱，电影票五元钱一张。假设5个人的名字及排队顺序是：赵、钱、孙、李、周。“赵”拿1张二十元的人民币买2张票，“钱”拿1张二十元的人民币买1张票，“孙”1张十元的人民币买1张票，“李”拿1张十元的人民币买2张票，“周”拿1张五元的人民币买1张票。

要求售票员按如下规则找赎：

（1）二十元买1张票，找零：1张十元；不许找零2张五元。

（2）二十元买1张票，找零：1张十元，1张五元；不许找零3张五元。

（3）十元买一张票，找零1张五元。

package experiment4;

import java.util.Objects;

class BuyTickets //临界资源
{
    private static int five =1, ten =0, twenty =0;//钱的张数可以根据这个来统计 
    public synchronized void buy(int money,int count) {
        //20元买两张票
        if (money == 20 && count == 2) {
            System.out.println("赵来买票");
            twenty++;//先收下钱
            //开始不能找钱
            if(ten <1)
            {
                try {
                    System.out.println("赵稍等"+"   此时售票员手中的票为:5元有 "+ five +" ,10元有："+ ten +" ，20元有："+ twenty);
                    this.wait();
                } catch (InterruptedException e) {}
            }
            //之后的没有办法成功找钱，就继续进入等待状态
            while(ten <1) {
                try {
                    this.wait();
                } catch (InterruptedException e) {}
            }
            ten--;//把钱找给他
            notify();//唤醒
            System.out.println("找给赵1张10元，赵结束"+"   此时售票员手中的票为:5元有"+ five +",10元有："+ ten +"，20元有："+ twenty);

        }
        //20元买1张票
        else if (money == 20 && count == 1) {
            twenty++;
            System.out.println("钱来买票");
            //找零：1张十元，1张五元
            if(ten <1|| five <1)
            {try {
                System.out.println("钱稍等"+"   此时售票员手中的票为:5元有 "+ five +" ,10元有："+ ten +" ，20元有："+ twenty);
                this.wait();
            } catch (InterruptedException e) {}
            }
            while(ten <1|| five <1) {
                try {
                    this.wait();
                } catch (InterruptedException e) {}
            }
            ten--;
            five--;
            notify();
            System.out.println("找给钱1张10元、1张5元，钱结束"+"   此时售票员手中的票为:5元有"+ five +" ,10元有："+ ten +" ，20元有："+ twenty
            );
        }
        //10元买1张票
        else if (money == 10 && count == 1) {
            ten++;
            System.out.println("孙来买票");
            if(five <1)
            {
                try {

                    System.out.println("孙稍等"+"   此时售票员手中的票为:5元有 "+ five +" ,10元有："+ ten +" ，20元有："+ twenty);
                    this.wait();
                } catch (InterruptedException e) {}
            }
            while(five <1) {
                try {
                    this.wait();
                } catch (InterruptedException e) {}
            }//没有办法成功找钱，就继续进入等待状态
            five--;
            notify();//唤醒
            System.out.println("找给孙1张5元，孙结束"+"   此时售票员手中的票为:5元有"+ five +",10元有："+ ten +"，20元有："+ twenty);
        }
        //10元买2张票
        else if (money == 10 && count == 2) {
            ten++;
            System.out.println("李来买票");
            System.out.println("李结束"+"   此时售票员手中的票为:5元有 "+ five +" ,10元有："+ ten +" ，20元有："+ twenty);
            notify();
        }
        //5元买1张票
        else if (money == 5 && count == 1) {
            five++;
            System.out.println("周来买票");
            System.out.println("周结束"+"   此时售票员手中的票为:5元有 "+ five +" ,10元有："+ ten +" ，20元有："+ twenty);
            notify();
        }
    }
}
class customer extends Thread//继承Thread类，创建多个线程
{
    String name;
    static final BuyTickets buyTickets = new BuyTickets();

    public customer(String name) {
        this.name = name;
    }

    public void run() {
            if (Objects.equals(name, "赵")) buyTickets.buy(20, 2);
            else if (Objects.equals(name, "钱")) buyTickets.buy(20, 1);
            else if (Objects.equals(name, "孙")) buyTickets.buy(10, 1);
            else if (Objects.equals(name, "李")) buyTickets.buy(10, 2);
            else if (Objects.equals(name, "周")) buyTickets.buy(5, 1);

    }
}

public class Exp4_3 {
    public static void main(String[] args) {
        new customer("赵").start();
        new customer("钱").start();
        new customer("孙").start();
        new customer("李").start();
        new customer("周").start();
    }
}

[3]实验分析

通过此次实验，熟悉了在Java中进行多线程编程的能力。在第三题中，由于买票的情况和找钱的情况有限，所有我将各种情况均枚举出来，作为临界区。临界资源则是售票员手里的各种钱的数量，同时这也作为各线程之间进行通信的信号量。

将五个人买票当作五个线程来进行，在临界区的方法声明中加入synchronized的关键字，实现线程互斥。

实验结果每次运行均不一样，但是都能符合实际。