12.2_java作业

 

多线程

一、判断题(T为正确,F为错误),每题1分
1.如果线程死亡，它便不能运行。（T）
2.在Java中，高优先级的可运行线程会抢占低优先级线程。（T）
3.线程可以用yield方法使低优先级的线程运行。（F）
4...程序开发者必须创建一个线程去管理内存的分配。（F）
5.一个线程在调用它的start方法，之前，该线程将一直处于出生期。（ T）
6.当调用一个正在进行线程的stop()方法时，该线程便会进入休眠状态。（F）
7.一个线程可以调用yield方法使其他线程有机会运行。（T）

8.    多线程没有安全问题(F)

9.    多线程安全问题的解决方案可以使用Lock提供的具体的锁对象操作(T)

10. Stop()方法是终止当前线程的一种状态(T)

 

二、选择题(不定项选择题),每题2分
1.Java语言中提供了一个D▁线程，自动回收动态分配的内存。
A．异步
B．消费者
C．守护
D．垃圾收集
2.Java语言避免了大多数的C▁错误。
A．数组下标越界
B．算术溢出
C．内存泄露
D．非法的方法参数
3.有三种原因可以导致线程不能运行，它们是ACD▁。
A．等待
B．阻塞
C．休眠
D．挂起及由于I/O操作而阻塞
4.当A▁方法终止时，能使线程进入死亡状态。
A．run
B．setPrority//更改线程优先级
C．yield//暂停当前线程的执行  执行其他线程
D．sleep//线程休眠
5.用B▁方法可以改变线程的优先级。
A．run
B．setPrority
C．yield
D．sleep
6.线程通过▁C▁方法可以使具有相同优先级线程获得处理器。
A．run
B．setPrority
C．yield
D．sleep
7.线程通过▁D▁方法可以休眠一段时间，然后恢复运行。
A．run
B．setPrority
C．yield
D．sleep
8.方法resume( )负责重新开始▁D▁线程的执行。
A．被stop( )方法停止
B．被sleep( )方法停止
C．被wait( )方法停止
D．被suspend( )方法停止
9.▁BCD▁方法可以用来暂时停止当前线程的运行。
A．stop( )
B．sleep( )
C．wait( )
D．suspend( )

10. 请问下列哪些类是定义在java.io包中的抽象类(ABD)

A.      InputStream

B.       OutputStream

C.       PrintStream

D.      Reader

E.       FileInputStream

F.       FileWriter

 

三、简述题,每题5分
1.简述程序、进程和线程之间的关系？什么是多线程程序？

 答:多线程多个线程在同时运行.进程,是正在运行的应用程序.线程依赖于进程存在.

多线程程序:程序的执行路径有多条.
3.什么是线程调度？Java的线程调度采用什么策略？

答: 线程调度是线程对于CPU执行权的抢占；
线程调度采用CPU时间片的轮转以及线程的优先级（优先级高的抢占到CPU执行权的概率就高，但不一定就能抢到）
4.如何在Java程序中实现多线程？

答: 方法一（创建一个类并继承自Thread类）：
1、自己创建一个类继承自Thread类
2、在继承Thread类的类中重写Run()方法；
3、在主线程中创建该类的实例；
4、启动线程；
方法二：（创建一个类并实现Runnable接口）：
1、自己创建一个类并实现Runnable接口；
2、在实现Runnable接口的类中重写run()方法；
3、在主线程中创建该类的对象；
4、再创建Thread类对象，将实现了Runnable接口的类的对象作为参数进行传递；
5、启动线程；
方法三（实现Callable接口）：
1、自己创建一个类并实现Callable接口；
2、创建线程池对象利用工厂类；
3、提交Callable任务；
4、结束线程池；

5.试简述Thread类的子类或实现Runnable接口两种方法的异同？     

答: 相同点：都要重写run()方法；
不同点：一个继承自Thread类；另一个采用实现Runnable接口的方式；

6.说明缓冲流的优点和原理

首先缓冲流分为字符缓冲流（BufferedInputStream和BufferedOutputStream）和字符缓冲流（BufferedReader和BufferedWriter）；
优点：缓冲流能够高效的进行读写操作；
原理：先将数据存入缓冲区，然后再一起写入或者一起读出；

8:在Java中wait()和sleep()方法的不同?

不同点：wait() 线程等待，一旦调用就会立即释放锁；
Sleep() 线程睡眠，不会释放锁；
相同点：都是阻塞式，并且一旦打破两个状态都会抛出中断异常（InterruptedException）

 

9:Java中Runnable和Callable有什么不同?

. 1、Runnablle运行线程采用run()方法而Callable采用call()方法；
2、Runnable采用start()方法启动程序而Callable采用 Future submit(Callable task)提交任务从而启动线程；
3、call()方法有返回值而run()方法没有返回值；
4、call()方法会抛出异常而run()方法不会抛出异常；

 

四、程序设计题
1.编写一个应用程序，在线程同步的情况下来实现“生产者―消费者”问题。

   学生类:

package test1;

 

publicclass Student {

    String name;

    intage;

  

}

 

生产者线程:

package test1;

 

publicclass SetThreadimplements Runnable {

    private Students;

    privateintx = 0;

    public SetThread(Students) {

        this.s =s;

    }

    @Override

    publicvoid run() {

        while (true) {

            synchronized (s) {

                if (x % 2 == 0) {

                    s.name ="张三";

                    s.age = 24;

                   

                } else {

                    s.name ="李四";

                    s.age = 18;

                 

                }

            }

            x++;

        }

    }

}

 

消费者线程

package test1;

 

publicclass GetThreadimplements Runnable {

    private Students;

    public GetThread(Students){

        this.s=s;

    }

    @Override

    publicvoidrun() {

        while(true){

            synchronized(s){

                System.out.println(s.name+"---"+s.age);

            }

        }

    }

}

 

测试类:

package test1;

 

publicclass StudentDemo {

    publicstaticvoid main(String[]args) {

        //创建学生类的资源对象

        Student s = new Student();

        //创建资源对象

        SetThread std = new SetThread(s);

        GetThread gtd = new GetThread(s);

        //创建线程类对象

        Thread t1 = new Thread(std);

        Thread t2 = new Thread(gtd);

        //启动线程

        t1.start();

        t2.start();

    }

}

 

 

2.修改上题，由于各个线程是异步运行的，因此无法预计其相对速度，为了使生产者能够不断地生产，可以使用循环缓冲区，保证有足够多的内存区保存更多的产品。（生产者——仓库——消费者）

 

 

3 :

1)将若干个Student对象;若干个Teacher对象,写出到d:/0404/a.txt中,

  2)将该文件中所有的Student对象反序列化回来,装入List,所有的Teacher对象反序列化回来装入另一个List

 

老师类:

package test3;

 

import java.io.Serializable;

 

publicclass TeacherDemoimplements Serializable{

    privatestaticfinallongserialVersionUID = 1L;

    private Stringname;

    privateintage;

    private Stringsex;

    public TeacherDemo(Stringname, intage, Stringsex) {

        super();

        this.name =name;

        this.age =age;

        this.sex =sex;

    }

    public String getName() {

        returnname;

    }

    publicvoid setName(Stringname) {

        this.name =name;

    }

    publicint getAge() {

        returnage;

    }

    publicvoid setAge(intage) {

        this.age =age;

    }

    public String getSex() {

        returnsex;

    }

    publicvoid setSex(Stringsex) {

        this.sex =sex;

    }

    @Override

    public String toString() {

        return"TeacherDemo [name=" +name + ", age=" + age +", sex=" + sex

                + "]";

    }  

}

 

学生类:

package test3;

 

import java.io.Serializable;

publicclass StudentDemoimplements Serializable {

    privatestaticfinallongserialVersionUID = 1L;

    private Stringname;

    privateintage;

    private Stringsex;

    public StudentDemo(Stringname, intage, Stringsex) {

        super();

        this.name =name;

        this.age =age;

        this.sex =sex;

    }

    public String getName() {

        returnname;

    }

    publicvoid setName(Stringname) {

        this.name =name;

    }

    publicint getAge() {

        returnage;

    }

    publicvoid setAge(intage) {

        this.age =age;

    }

    public String getSex() {

        returnsex;

    }

    publicvoid setSex(Stringsex) {

        this.sex =sex;

    }

    @Override

    public String toString() {

        return"StudentDemo [name=" +name + ", age=" + age +", sex=" + sex

                + "]";

    }

}

 

测试类:

package test3;

 

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.util.ArrayList;

 

publicclass Demo {

    publicstaticvoid main(String[]args) throws IOException, ClassNotFoundException{

        File file=new File("D:\\0404");

        file.mkdir();

        File file1=new File("D:\\0404\\a.txt");

        file1.createNewFile();

        //序列化

        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(file1));

        oos.writeObject(newStudentDemo("张三",15,"男"));

        oos.writeObject(newStudentDemo("李四",12,"女"));

        oos.writeObject(newStudentDemo("王五",19,"女"));

        oos.writeObject(new TeacherDemo("赵六",30,"男"));

        oos.writeObject(new TeacherDemo("熊明",26,"男"));

        oos.writeObject(new TeacherDemo("小红",28,"女"));

 

        oos.flush();

        //反序列化

        ObjectInputStream ois=new ObjectInputStream(new FileInputStream(file1));

        ArrayList<StudentDemo>list=new ArrayList<StudentDemo>();

        ArrayList<TeacherDemo>list1=new ArrayList<TeacherDemo>();

        for(inti=0;i<6;i++){

            if(i<3){

                StudentDemos=(StudentDemo)ois.readObject();

                list.add(s);

            }else{

                TeacherDemo t=(TeacherDemo)ois.readObject();

                list1.add(t);

            }

        }

        for(StudentDemostudent:list){

            System.out.println(student);

        }

        for(TeacherDemoteacher:list1){

            System.out.println(teacher);

        }

    }

}

 

4:实现字符串和字节数组之间的相互转换,比如:将字符串”西部开源技术中心xbkyjszx”转换为字节数组,并将字节数组再转换回字符串!

package test4;

 

import java.io.UnsupportedEncodingException;

 

publicclass Demo {

publicstaticvoid main(String[]args) throws UnsupportedEncodingException {

    String s="西部开源技术中心xbkyjszx";

    byte[]zbyte =s.getBytes("UTF-8");

    System.out.print(zbyte);

 

    String s2 = new String(zbyte,"UTF-8");

    System.out.println(s2);

}

}

 

5:用Java编程一个会导致死锁的程序,你将怎么解决?请你设计

 

学生类:

package thread5;

 

publicclass Student {

       String name;

       intage;

       //声明一个变量

       booleanflag;//默认没有数据,如果true,则说明有数据

}

 

生产者线程:

package thread5;

 

publicclass SetThreadimplements Runnable {

      

       private Students;

       public SetThread(Students) {

              this.s =s;

       }

      

       privateintx =0;

       @Override

       publicvoid run() {

              while(true) {

                     //同步机制进行操作

                     synchronized (s) {

                            //判断有没有数据

                            if(s.flag) {

                                   //处于等待状态

                                   try {

                                         s.wait();//阻塞式方法,立即释放锁

                                   } catch (InterruptedExceptione) {   

                                         e.printStackTrace();

                                   }

                            }

                            if(x%2 == 0) {

                                   //x = 0

                                   //设置学生数据

                                   s.name ="李四";

                                   s.age =20;

                            }else {

                                   //设置学生数据

                                   s.name ="张三";

                                   s.age = 22;

                            }

                            x++;

                           

                            //修改标记

                            s.flag =true;//有数据了

                            //通知t2:消费者线程来消费数据

                            s.notify();//唤醒这种等待状态

                     }

              }

 

       }

 

}

 

消费者线程:

package thread5;

 

publicclass GetThreadimplements Runnable {

      

       private Students;

       public GetThread(Students) {

              this.s =s ;

       }

       @Override

       publicvoid run() {

              while(true) {

                     synchronized (s) {

                            //判断有没有数据

                            if(!s.flag) {

                                   try {

                                         s.wait();

                                   } catch (InterruptedExceptione) {

                                         e.printStackTrace();

                                   }

                            }

                            //输出语句

                            System.out.println(s.name+"---"+s.age);

                           

                            //修改标记

                            s.flag =false;//消费者线程

                            //通知对方(t1),消费者线程没有数据类

                            s.notify();//唤醒t1线程

                     }

              }

       }

 

}

 

 

测试类:

 

package thread5;

 

publicclass StudentThreadDemo {

       publicstaticvoid main(String[]args) {

             

              //创建一个资源对象

              Student s = new Student();

             

              //创建资源对象

              SetThread st = new SetThread(s);

              GetThread gt = new GetThread(s);

             

              //创建线程对象

              Thread t1 = new Thread(st);

              Thread t2= new Thread(gt);

             

              //分别启动线程

              t1.start();

              t2.start();

       }

}

 

 

6:递归实现输入任意目录,列出文件以及文件夹