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();

    }

}

输出（节选）：
请输入人物姓名
刘诗诗
请输入人物年龄
23
set线程名：Thread-0 姓名：刘诗诗  年龄：23
get线程名：Thread-1 姓名：刘诗诗  年龄：23
set线程名：Thread-0 姓名：刘诗诗  年龄：23
get线程名：Thread-1 姓名：刘诗诗  年龄：23
set线程名：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