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 {
    private 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());
                }
            }
        }
    }
}