多线程
一、判断题(T为正确,F为错误),每题1分
1.如果线程死亡，它便不能运行。（T）
2.在Java中，高优先级的可运行线程会抢占低优先级线程。（ T）
3.线程可以用yield方法使低优先级的线程运行。（F）
4…程序开发者必须创建一个线程去管理内存的分配。（T）
5.一个线程在调用它的start方法，之前，该线程将一直处于出生期。（ ）
6.当调用一个正在进行线程的stop( )方法时，该线程便会进入休眠状态。（F）
7.一个线程可以调用yield方法使其他线程有机会运行。（T）
8. 多线程没有安全问题(F)
9. 多线程安全问题的解决方案可以使用Lock提供的具体的锁对象操作(T)
10. Stop()方法是终止当前线程的一种状态()
二、选择题(不定项选择题),每题2分
1.Java语言中提供了一个▁线程，自动回收动态分配的内存。ACD
A．异步
B．消费者
C．守护
D．垃圾收集
2.Java语言避免了大多数的▁错误。ACD
A．数组下标越界
B．算术溢出
C．内存泄露
D．非法的方法参数
3.有三种原因可以导致线程不能运行，它们是▁。BCD
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包中的抽象类()ABEF
A. InputStream
B. OutputStream
C. PrintStream
D. Reader
E. FileInputStream
F. FileWriter
三、简述题,每题5分
1.简述程序、进程和线程之间的关系？什么是多线程程序？
程序：具有能够正常运行的特性的代码
进程：运行在内存中的程序，活跃的程序
线程：线程是进程的独立运行单元
3.什么是线程调度？Java的线程调度采用什么策略？
线程调度是系统调节CPU，提高CPU的使用率，且能实现多个任务同时运行的一种机制。
Java线程调节是抢占式线程调节，即每个任务的每个线程都可以抢占处理器的使用权
4.如何在Java程序中实现多线程？
一、 对象类继承Thread类，重写run方法。测试类新建继承Thread的对象类。
二、 对象类实现Runnable接口，重写run方法。测试类新建对象类，把对象类作为新建Thread类的target。
三、 对象类实现Callable接口，重写call方法。测试类新建对象类，吧对象类作为fatureTask类的target。
5.试简述Thread类的子类或实现Runnable接口两种方法的异同？
两者都可以创建多线程。
Thread类的子类不能继承别的类，实现Runnable接口可以继承别的类；
Thread创建的类就是线程对象，实现Runnable接口创建的类是Thread类的target；
Thread类的子类的线程对象用this获取，实现Runnable接口的线程对象用Thread.currentThread获取。
6.说明缓冲流的优点和原理
8:在Java中wait()和sleep()方法的不同?
1、sleep()方法使当前线程暂时停止一段时间，但是不释放同步锁对象，一直持有同步锁对象，暂停时间过了以后继续运行。
wait()方法暂时停止运行，释放同步锁对象，等待用notify()方法唤醒。
2、sleep()方法是Thread类对象，wait()是Object类对象
9:Java中Runnable和Callable有什么不同?
.实现Runnable接口的方法，然后重写run方法，创建的类是Thread的target
实现Callable接口的方法，然后重写call方法，创建的类是FatureTask对象的target
四、程序设计题
1.编写一个应用程序，在线程同步的情况下来实现“生产者―消费者”问题。
star类：
public class Star {
private String name;
private int age;
private boolean flag= false;//false为没有值
public boolean getflag(){
return flag;
}
public boolean setflag(boolean flag1){
return this.flag=flag1;
}
public Star() {
super();
}
public Star(String name, int age) {
if(name!=null){
this.name = name;
}else{
System.out.println("姓名格式有误，请输入姓名！");
System.exit(0);
}
if(age>0){
this.age = age;
}else{
System.out.println("年龄格式有误，输入正确年龄！");
System.exit(0);
}
}
public String getName() {
return name;
}
public void setName(String name) {
}
public int getAge() {
return age;
}
public void setAge(int age) {
}
}
setstar类：
public class SetStar implements Runnable {
private Star s;
public SetStar(Star s){
this.s = s;
}
@Override
public void run() {
//加入循环，多线程出现数据错位，应使用同步代码块
while(true){
synchronized (s) {
if(s.getflag()==true){
try {
s.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("set线程名：" + Thread.currentThread().getName() + "\t姓名："
+ s.getName() + "\t年龄：" + s.getAge());
//如果生产者有数据，唤醒消费者线程拿数据
s.setflag(true);
s.notify();
}
}
}
}
getstar类：
public class GetStar implements Runnable {
private Star s;
public GetStar(Star s) {
this.s = s;
}
@Override
public void run() {
while (true) {
synchronized (s) {
if (s.getflag()==false) {
try {
s.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
StringBuffer sb = new StringBuffer();
sb.append("get线程名：")
.append(Thread.currentThread().getName())
.append("\t姓名：").append(s.getName())
.append("\t年龄：").append(s.getAge());
System.out.println(sb);
//消费者线程没有数据，唤醒生产者线程生产数据
s.setflag(false);
s.notify();
}
}
}
}
测试类：
package Day21_1;
import java.util.Scanner;
/**
*屏幕录入人物信息，然后多线程实现设置人物信息，获取人物信息
* @author Aoman_Hao
*/
public class StarTest {
public static void main(String[] args) {
//屏幕录入
Scanner sc_name = new Scanner(System.in);
System.out.println("请输入人物姓名");
String name = sc_name.next();
Scanner sc_age = new Scanner(System.in);
System.out.println("请输入人物年龄");
int age = sc_age.nextInt();
//创建资源对象
Star s1 = new Star(name,age);
SetStar ss1 = new SetStar(s1);
GetStar gs1 = new GetStar(s1);
//创建线程对象
Thread sT1 = new Thread(ss1);
Thread gT1 = new Thread(gs1);
//启动线程对象
sT1.start();
gT1.start();
}
}
输出（节选）：
请输入人物姓名
刘诗诗
请输入人物年龄
23
set线程名：Thread-0 姓名：刘诗诗 年龄：23
get线程名：Thread-1 姓名：刘诗诗 年龄：23
set线程名：Thread-0 姓名：刘诗诗 年龄：23
get线程名：Thread-1 姓名：刘诗诗 年龄：23
set线程名：Thread-0 姓名：刘诗诗 年龄：232.修改上题，由于各个线程是异步运行的，因此无法预计其相对速度，为了使生产者能够不断地生产，可以使用循环缓冲区，保证有足够多的内存区保存更多的产品。（生产者——仓库——消费者）
3 :
1)将若干个Student对象;若干个Teacher对象,写出到d:/0404/a.txt中,
2)将该文件中所有的Student对象反序列化回来,装入List,所有的Teacher对象反序列化回来装入另一个List
1）：
测试类
package Day21_3;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Set;
/**
* @author Aoman_Hao
*/
public class Demo {
public static void main(String[] args) throws IOException {
// 创建文件d:/0404/a.txt
File file1 = new File("d://0404");
file1.mkdir();
File file = new File("d://0404//a.txt");
file.createNewFile();
FileWriter FW = new FileWriter(file);
// 创建学生老师资源对象，HashSet
HashMap<String, Object> S = new HashMap<>();
S.put("1", new Student("Aoman", 30));
S.put("2", new Student("蓉蓉", 23));
S.put("001", new Teacher("一老师", "数学"));
S.put("002", new Teacher("二老师", "语文"));
Set<String> S_Keys = S.keySet();
StringBuffer sb = new StringBuffer();
for(String key : S_Keys){
sb.append("编号:").append(key).append(";信息:").append(S.get(key)).append("\r\n");
}
System.out.println(sb);
FW.write(sb.toString());
FW.flush();
FW.close();
}
}
student，teacher普通的对象类。
学生资源类：
public class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
public String getName() {
return name;
}
public void setName(String name) {
}
public int getAge() {
return age;
}
public void setAge(int age) {
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
教师资源类：
public class Teacher {
private String name;
private String subject;
public Teacher() {
super();
}
public Teacher(String name, String subject) {
super();
this.name = name;
this.subject = subject;
}
public String getName() {
return name;
}
public void setName(String name) {
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
}
@Override
public String toString() {
return "Teacher [name=" + name + ", subject=" + subject + "]";
}
}4:实现字符串和字节数组之间的相互转换,比如:将字符串”西部开源技术中心xbkyjszx”转换为字节数组,并将字节数组再转换回字符串!
package Day21_2;
/**
* @author Aoman_Hao
*/
public class Test {
public static void main(String[] args) {
String s = new String("西部开源技术中心xbkyjszx");
//字符串--字节数组
byte[] s_by = s.getBytes();
System.out.println("字节数组："+s_by);
//字节数组--字符串
String s2 = new String(s_by);
System.out.println(s2);
//字符串--字符数组
char[] s_ch= s.toCharArray();
System.out.println("字符数组："+s_ch);
//字符数组--字符串
StringBuffer sb = new StringBuffer();
for(char ch : s_ch){
sb.append(ch);
}
System.out.println(sb);
}
}
输出：
字节数组：[B@1afb7ac7
西部开源技术中心xbkyjszx
字符数组：[C@7439aca7
西部开源技术中心xbkyjszx5:用Java编程一个会导致死锁的程序,你将怎么解决?请你设计
资源对象A类：
public class DeadClassA {
public void FirstClassA(){
try {
Thread.sleep(100);
} catch (Exception e) {
System.out.println("进程名："+Thread.currentThread().getName()+"调用A的First方法内部");
}
}
public void LastClassA(){
System.out.println("A的Last方法内部");
}
}
资源对象B类：
public class DeadClassB {
public void FirstClassB(){
try {
Thread.sleep(100);
} catch (Exception e) {
System.out.println("进程名："+Thread.currentThread().getName()+"调用B的first方法");
}
}
public void LastClassB(){
System.out.println("进入B的Last方法内部");
}
}
线程对象：
public class DeadLock implements Runnable {
Object obj = new Object();
Object obj2 = new Object();
private boolean flag;//定义一个判断量
public void lockflag(boolean flag){
this.flag=flag;
}
@Override
public void run() {
if(flag){
//先调用A类的第一个方法，在调用B类的最后一个方法
synchronized (obj) {
new DeadClassA().FirstClassA();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (obj2) {
new DeadClassB().LastClassB();
}
}
}
else{
//先调用B类的第一个方法，在调用A类的最后一个方法
synchronized (obj2) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
new DeadClassB().FirstClassB();
synchronized (obj) {
new DeadClassA().LastClassA();
}
}
}
} }
测试类：
package Day21_Lock;
/**
* @author Aoman_Hao
*/
public class DeadLockTest {
public static void main(String[] args) {
DeadLock DL = new DeadLock();
DL.lockflag(true);
Thread T1 = new Thread(DL);
DeadLock DL2 = new DeadLock();
DL2.lockflag(false);
Thread T2 = new Thread(DL);
T1.start();
T2.start();
}
}解决死锁用等待唤醒机制
6:递归实现输入任意目录,列出文件以及文件夹
public class Test {
public static void main(String[] args) {
File file = new File("D://Java//JavaTest");
FindFolder(file);
}
//递归查询
public static void FindFolder(File file){
//读取文件列表
File[] F_list = file.listFiles();
//判断是否非空
if(F_list!=null){
//循环判断是文件夹的话，进去文件夹，是文件的话，输出文件名
for(File filename:F_list){
//如果是文件夹，递归寻找
if(filename.isDirectory()){
System.out.println("文件夹名："+filename.getName());
FindFolder(filename);
}else{
System.out.println("文件名："+filename.getName());
}
}
}
}
}
输出：
文件名：aaa.txt
文件名：Aoman_3.txt
文件名：Aoman_Hao.txt
文件夹名：Test
文件名：ab.txt
文件名：Aoman4122312q.txt
文件名：dwadwadwd.txt
