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
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:递归实现输入任意目录,列出文件以及文件夹