Java作业杨枝12.2/12.3

多线程

一、判断题(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()方法是终止当前线程的一种状态(F)

二、选择题(不定项选择题),每题2分

1.Java语言中提供了一个D▁线程，自动回收动态分配的内存。

A．异步

B．消费者

C．守护

D．垃圾收集

2.Java语言避免了大多数的▁C错误。

A．数组下标越界

B．算术溢出

C．内存泄露

D．非法的方法参数

3.有三种原因可以导致线程不能运行，它们是ABD▁。

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.简述程序、进程和线程之间的关系？什么是多线程程序？

答：

程序：程序只是一组指令的有序集合。

进程：观察任务管理器,发现正在运行的程序(桌面的应用程序,客户端程序..)就是一个进程，进程来说:进程是系统分配资源调用的一个独立单位。

线程：线程依赖于进程存在，一个线程相当于进程中的某个任务。

多线程：一个进程中开启了多个任务,每个一任务(线程),他们在互相抢占CPU的执行权,(提高程序的执行效率)多线程在抢占CPU的执行权:特点:具有随机性。

3.什么是线程调度？Java的线程调度采用什么策略？

答：

计算机通常只有一个CPU,在任意时刻只能执行一条机器指令,每个线程只有获得CPU的使用权才能执行指令.所谓多线程的并发运行,其实是指从宏观上看,各个线程轮流获得CPU的使用权,分别执行各自的任务.在运行池中,会有多个处于就绪状态的线程在等待CPU,JAVA虚拟机的一项任务就是负责线程的调度,线程调度是指按照特定机制为多个线程分配CPU的使用权。

4.如何在Java程序中实现多线程？

答：

实现方式一：1）自定义一个类，MyThread继承自Thread。

2）类中重写run()方法。

3）主线程中，创建该类实例对象，启动线程。

实现方式二：声明实现Runable接口

1）自定义一个类MyRunable，实现Runable接口。

2）实现接口中run()方法。

3）主线程中创建该类实例对象。

4）创建Thread类对象，将创建的对象作为参数进行传递。

5）分别启动线程。

5.试简述Thread类的子类或实现Runnable接口两种方法的异同？ 区别：第一种是扩展，第二种是实现

在实际开发中通常以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类可以避免继承的局限，一个类可以继承多个接口，适合于资源的共享。

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

答：缓冲流，则会将输出的内容先放置在内存中，等到有一定数据量的时候，或是流关闭、或调用flush()方法时，才会将相应的内容保存到硬盘或是其它目的地中。这样会重复减少重复字符串的创建，有利于提高效率。

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

答：

1）wait()属于Object类，sleep()属于Thread类。

2）Sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。

3）而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备。

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

.答：

(1)Callable规定的方法是call()，Runnable规定的方法是run()。其中Runnable可以提交给Thread来包装下，直接启动一个线程来执行，而Callable则一般都是提交给ExecuteService来执行。

(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得。

(3)call方法可以抛出异常，run方法不可以。

(4)运行Callable任务可以拿到一个Future对象，c表示异步计算的结果。

四、程序设计题

1.。

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

package prc02;

public class StudentDemo {
public static void main(String[] args) {
Student s = new Student();

SetThread st = new SetThread(s);
GetThread gt = new GetThread(s);

Thread t1 = new Thread(st, "a");
Thread t2 = new Thread(gt, "b");

t1.start();
t2.start();
}
}
//学生类
package prc02;

public class Student {
String name;
int age;
boolean flag;   //默认没有数据,如果true,则说明有数据
}
//生产者
package prc02;

public class SetThread implements Runnable {
private Student s;

// 用构造函数使得他们用的都是同一个对象资源
public SetThread(Student s) {
this.s = s;
}

private int x = 0;

public void run() {
while (true) {
synchronized (s) {
if (s.flag) {
try {
s.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (x % 2 == 0) {
// 设置学生数据
s.name = "杨枝";
s.age = 24;
} else {
s.name = "小明";
s.age = 12;
}
x++;
// 修改标记
s.flag = true;// 有数据了
// 通知t2:消费者线程来消费数据
s.notify();// 唤醒等待这种状态...
}
}
}
}
//消费者
package prc02;

public class GetThread implements Runnable {
pri
c9be
vate Student s;

public GetThread(Student s) {
this.s = s;
}

public void 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线程....
}

}
}
}

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

3 :

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

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

测试类

package test01;

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;

/*1)将若干个Student对象;若干个Teacher对象,写出到d:/0404/a.txt中,
2)将该文件中所有的Student对象反序列化回来,装入List,所有的Teacher对象反序列化回来装入另一个List
*/
public class Prac01 {
public static void 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 obs = new ObjectOutputStream(new FileOutputStream(file1));
obs.writeObject(new Student("a",10));
obs.writeObject(new Student("b",12));
obs.writeObject(new Teacher("c",33));
obs.writeObject(new Teacher("d",34));
obs.flush();

//反序列化
ObjectInputStream ois=new ObjectInputStream(new FileInputStream(file1));
ArrayList<Student> list1=new ArrayList<Student>();
ArrayList<Teacher> list2=new ArrayList<Teacher>();
for(int i=0;i<4;i++){
if(i<2){
Student s=(Student)ois.readObject();
list1.add(s);}else{
Teacher t=(Teacher)ois.readObject();
list2.add(t);}
}
for(Student  s1:list1){
System.out.println(s1);

}

for(Teacher t2:list2 ){
System.out.println(t2);
}
}
}

学生类

package test01;

import java.io.Serializable;

public class Student implements Serializable{

private static final long serialVersionUID = 1L;

private String name;
private int age;

public Student() {
super();

}

public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}

}

老师类

package test01;

import java.io.Serializable;

public class Teacher implements Serializable{

private static final long serialVersionUID = 1L;
private String name;
private int age;

public Teacher() {
super();

}

public Teacher(String name, int age) {
super();
this.name = name;
this.age = age;
}

public String toString() {
return "Teacher [name=" + name + ", age=" + age + "]";
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

}

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

package prac;

import java.io.UnsupportedEncodingException;

/*实现字符串和字节数组之间的相互转换如:将字符串”西部开源技术中心xbkyjszx”转换为字节数组
* ,并将字节数组再转换回字符串!*/
public class Test01 {
public static void main(String[] args) throws UnsupportedEncodingException {
String s="西部开源技术中心xbkyjszx";
byte[] srtbyte = s.getBytes("UTF-8");
System.out.print(srtbyte);

String s2 = new String(srtbyte,"UTF-8");
System.out.println(s2);
}
}

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

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

package prac05;

import java.io.File;

public class Prac05 {
public static void main(String[] args) {
File file = new File("f:\\A");
getFiles(file);
}

private static void getFiles(File file) {
File[] files = file.listFiles();
if (files != null) {
for (File f : files) {
if (f.isDirectory()) {
System.out.println(f.getName());
getFiles(f);
} else {
System.out.println(f.getName());
}
}
}
}
}