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 SetThread
implements Runnable {
    private Student
s;
    privateintx = 0;
    public SetThread(Student
s) {
        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 GetThread
implements Runnable {
    private Student
s;
    public GetThread(Student
s){
        this.s=s;
    }
    @Override
    publicvoid
run() {
        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 TeacherDemo
implements Serializable{
    privatestaticfinallongserialVersionUID
= 1L;
    private String
name;
    privateintage;
    private String
sex;
    public TeacherDemo(String
name,
intage, String
sex) {
        super();
        this.name =
name;
        this.age =
age;
        this.sex =
sex;
    }
    public String getName() {
        returnname;
    }
    publicvoid setName(String
name) {
        this.name =
name;
    }
    publicint getAge() {
        returnage;
    }
    publicvoid setAge(intage)
{
        this.age =
age;
    }
    public String getSex() {
        returnsex;
    }
    publicvoid setSex(String
sex) {
        this.sex =
sex;
    }
    @Override
    public String toString() {
        return"TeacherDemo [name=" +
name +
", age=" + age +
", sex=" +
sex
                +
"]";
    }  
}
 

学生类:

package test3;
 
import java.io.Serializable;
publicclass StudentDemo
implements Serializable {
    privatestaticfinallongserialVersionUID
= 1L;
    private String
name;
    privateintage;
    private String
sex;
    public StudentDemo(String
name,
intage, String
sex) {
        super();
        this.name =
name;
        this.age =
age;
        this.sex =
sex;
    }
    public String getName() {
        returnname;
    }
    publicvoid setName(String
name) {
        this.name =
name;
    }
    publicint getAge() {
        returnage;
    }
    publicvoid setAge(intage)
{
        this.age =
age;
    }
    public String getSex() {
        returnsex;
    }
    publicvoid setSex(String
sex) {
        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(new
StudentDemo("张三",15,"男"));
        oos.writeObject(new
StudentDemo("李四",12,"女"));
        oos.writeObject(new
StudentDemo("王五",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){
                StudentDemo
s=(StudentDemo)ois.readObject();
                list.add(s);
            }else{
                TeacherDemo
t=(TeacherDemo)ois.readObject();
                list1.add(t);
            }
        }
        for(StudentDemo
student:list){
            System.out.println(student);
        }
        for(TeacherDemo
teacher: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 SetThread
implements Runnable {
      
       private Student
s;
       public SetThread(Student
s) {
              this.s =
s;
       }
      
       privateintx =0;
       @Override
       publicvoid run() {
              while(true) {
                     //同步机制进行操作
                     synchronized (s) {
                            //判断有没有数据
                            if(s.flag)
{
                                  
//处于等待状态
                                  
try {
                                         
s.wait();//阻塞式方法,立即释放锁
                                  
} catch (InterruptedException
e) {   

                                         
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 GetThread
implements Runnable {
      
       private Student
s;
       public GetThread(Student
s) {
              this.s =
s ;
       }
       @Override
       publicvoid run() {
              while(true) {
                     synchronized (s) {
                            //判断有没有数据
                            if(!s.flag)
{
                                  
try {
                                         
s.wait();
                                  
} catch (InterruptedException
e) {
                                         
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:递归实现输入任意目录,列出文件以及文件夹