Java作业_Day21_

多线程
一、判断题(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();    }}输出（节选）：请输入人物姓名刘诗诗请输入人物年龄23set线程名：Thread-0 姓名：刘诗诗  年龄：23get线程名：Thread-1 姓名：刘诗诗  年龄：23set线程名：Thread-0 姓名：刘诗诗  年龄：23get线程名：Thread-1 姓名：刘诗诗  年龄：23set线程名：Thread-0 姓名：刘诗诗  年龄：23

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

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西部开源技术中心xbkyjszx

5:用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