20220422周测

目录

一、单选题

6、请问wait()方法在以下哪个代码中被调用

8、与InputStream流相对应的Java系统的标准输入对象是（）

二、多选题

3、关于sleep()和wait()，以下描述正确的是（）

6、能指定字符编码的I/O流类型是（）

9、在java中，被看作为输出流的选项是（）

三、判断题

四、简答

---

一、单选题

1、启动多线程的方式是调用如下哪一个方法（）

        A.start 
        B.do   
        C.run   
        D.sleep

        参考答案：A                run执行体；sleep休眠

2、哪个关键字可以对对象加锁（）

        A.transient  
        B.synchronized  
        C.serialize 
        D.static  

        参考答案：B               static 和 transient修饰后的字段不会被序列化serialize 

3、以下哪个方法用于定义线程的执行体（）

        A.start() 
        B.init() 
        C.run() 
        D.synchronized()

        参考答案：C

        start开启线程；

        init在实例被创建出来的事后调用，在类加载的时候就执行连接方法，且执行一次；        

        synchronized锁住对象；

4、线程通过（ ）方法可以休眠一段时间，然后恢复运行

        A.run 
        B.setPriority         
        C.yield         
        D.sleep

        参考答案：D

       run执行体；

       setPriority设置优先级 ；

       yield 让出时间片，进入和可运行状态，与其他等待的可运行状态线程竞争CPU时间片；        

       sleep 使线程停止一段时间，进入阻塞状态 

5、运行在操作系统上的每个应用都会独占一个独立的（）

        A.线程  
        B.进程   
        C.thread   
        D.Runnable

        参考答案：B

6、请问wait()方法在以下哪个代码中被调用

        A.一个while()循环体中        
        B.run方法中        
        C.同步化代码块中        
        D.代码的任何地方

        参考答案：C

7、下列流中那个使用了缓冲区技术（）

        A.BufferedOutputStream    
        B.FileInputStream
        C.FileOutputStream    
        D.FileReader

        参考答案：A

        FileOutputStream：文件字节输出流，往文件写入字节
        FileInputStream：文件字节输入流，从文件读取字节

        FileWriter 文件写入流，往文件写入字符
        FileReader 文件读取流，从文件读取字符

8、与InputStream流相对应的Java系统的标准输入对象是（）

        A.System.in    
        B.System.out    
        C.System.err    
        D.System.exit()

        参考答案：A

        System.in是InputStream，标准输入流，默认可以从键盘读取字节数组

        System.out是PrintStream，标准输出流，默认可以向Console中输出字符和字节数据，具有缓存功能，积攒到一定数量才会输出

        System.err是标准错误输出流，输出显示为红色，输出的字符串位置会随机出现，会随时输出

        System.exit:终止当前运行的Java虚拟机。

        正常终止：System.exit(0);异常终止：System.exit(非0的int型参数)

9、以下通过哪个类对象可以实现从文件读取数据（）

        A.FileWriter   
        B.FileOutputStream  
        C.BufferedWriter   
        D.FileInputStream

        参考答案：D

10、为了从文本文件中逐行读取内容，应该使用哪个处理流对象()

        A.BufferedReader    
        B.BufferedWriter    
        C.BufferedInputStream    
        D.BufferedOutputStream

        参考答案：A

        BufferedWriter   缓存写入流，不能单独使用，构造方法需要传入Writer对象
        BufferReader     缓存读取流，不能单独使用，构造方法需要传入Reader对象

        BufferedOutputStream：缓存字节输出流，不能单独使用，构造方法需要传入OutputStream
        BufferedInputStream：缓存字节输入流，不能单独使用，构造方法需要传入InputStream对象

11、使用Java IO流实现对文本文件的读写过程中，需要处理下列哪个异常（）

        A.ClassNotFoundException
        B.IOException
        C.SQLException
        D.RemoteException

        参考答案：B

12、从InputStream对象中如何创建一个Reader对象（）

        A.使用InputStream类中定义的createReader()方法   
        B.用Reader类中的createReader()方法   
        C.构造一个InputStreamReader实例，将InputStream对象作为InputStreamReader类构造器的参数传入   
        D.构造一个OutputStreamReader实例，将InputStream对象作为OutputStreamReader类构造器 的参数传入

        参考答案：C

二、多选题

1、以下关于ThreadLocal的作用描述正确的是（）

        A.ThreadLocal用来解决多线程程序的并发      
        B.多线程类需要继承ThreadLocal类;
        C.多线程类需要实现ThreadLocal接口
        D.ThreadLocal为每个使用该变量的线程提供独立的变量副本

        参考答案：AD

2、有三种原因可以导致线程不能运行，它们是（）

        A.等待        
        B.阻塞        
        C.休眠        
        D.挂起及由于I/O操作而阻塞

        参考答案：ABC

3、关于sleep()和wait()，以下描述正确的是（）

        A.sleep是线程类Thread的方法，wait是Object类的方法；
        B.sleep不释放对象锁，wait释放对象锁；
        C.sleep暂停线程、但监控状态仍然保持，结束后会自动恢复；
        D.wait后进入等待队列，只有针对此对象发出notify方法后获得对象锁进入运行状态。

        参考答案：ABC

A:

sleep是Thread类中的方法，而wait、notify、notifyAll都是Object类中的方法。

sleep是Thread类中的静态方法。因此无论是在a线程中调用b的sleep方法，还是在b线程中调用a的sleep方法，谁调用谁就sleep。也因此，sleep可以在任何地方使用。

wait、notify、notifyAll就很惨了，只能在同步控制方法或同步控制块中使用。

B:

因为sleep()并没释放锁，所以仍旧处在同步状态，监控仍旧存在，睡眠时间结束后自动恢复运行。

wait()释放掉锁，所以不再处于同步状态。

D:

Java中每个对象都有两个池：锁池、等待池。

锁池：假设线程A已经拥有了某个对象（不是类）的锁，而其他线程也想要调用这个对象的某个synchronized方法或者代码块。由于这些线程在进入对象的synchronized方法或者代码块时，必须要先获得该对象的锁的拥有权，但是该对象的锁正在被线程A拥有，所以这些线程就进入了该对象的锁池。

等待池：假设线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁（原因是wait()必须出现在synchronized锁里面，自然执行wait()方法前就拥有了这个对象的锁，源代码翻译中提到wait()释放监视器所有权，即释放锁），同时线程A进入该对象的等待池中。如果另一个线程调用了该相同对象的notifyAll()方法，那么处于该对象中的所有线程会进入该对象的锁池中，准备争夺锁的拥有权。如果另一个线程调用了该相同对象的notify()方法，那么仅仅只有一个处于该对象的等待池中的线程（随机的某个）进入锁池，准备得到锁的拥有权。

4、有关线程的哪些描述是正确的()

        A.一旦一个线程被创建，它就立即开始运行
        B.使用 start() 方法可以使一个线程成为可运行的，但是它不一定立即开始运行
        C.一个线程可能因为yield的原因停止，进入可运行状态
        D.当一个线程因为wait而停止运行时，它被放在锁池队列        等待池队列中

        参考答案：BC

5、以下哪几种是Java实现多线程的方式（）

        A.Thread类       
        B.Runnable类        
        C.Runnable接口
        D.Thread接口

        参考答案：AC

6、能指定字符编码的I/O流类型是（）

        A.Reader       
        B.InputStreamReader        
        C.BufferedReader
        D.OutputStreamWriter

        参考答案：BD

7、下列哪些选项的内容可以作为 FileInputStream 类构造方法的参数（）

        A.File    
        B.String    
        C.InputStream        
        D.FileOutPutStream

        参考答案：AB

8、以下哪几个是字节流（）

        A.InputStream       
        B.OutputStream        
        C.Read
        D.Write    

        参考答案：AB

9、在java中，被看作为输出流的选项是（）

        A.OutputStream     
        B.Reader        
        C.InputStream        
        D.Writer

        参考答案：AD

三、判断题

1、当时用IO流操作文件之后不需要关闭流，因为jvm会协助关闭的

        A、对

        B、错

        参考答案：B

2、从内存往外部设备写数据，称为输出。把数据读到内存中，称为输入

        A、对

        B、错

        参考答案：A

3、ByteArrayInutStream 和 ByteArrayOutputStream 对内存中的字节数组进行读写操作，属于字节流

        A、对

        B、错

        参考答案：A

4、实现 Serializable 接口的可以被序列化和反序列化。该接口中没有定义抽象方法，也没有定义常量

        A、对

        B、错

        参考答案：A

5、序列化是指将字节序列转换成 Java 对象，实现了Serializable或者Externalizable接口的类的对象才可以被序列化

        A、对

        B、错

        参考答案：B

        序列化是将java对象转换成字节码序列

6、RandomAccessFile类提供有删除磁盘文件的方法

        A、对

        B、错

        参考答案：B

7、Java流的方向是先进先出的方式

        A、对

        B、错

        参考答案：A

8、线程使用sleep方法去休眠后可以使用notify方法唤醒

        A、对

        B、错

        参考答案：B

        wait用notify方法唤醒

9、线程使用sleep方法休眠是会释放该线程同步锁定的对象

        A、对

        B、错

        参考答案：B

        sleep不会释放该线程同步锁对象，wait会释放

10、线程可以用yield方法使低优先级的线程运行

        A、对

        B、错

        参考答案：B

        线程优先级是:通过setPriority和getPriority方法来设置或返回优先级

11、一个线程在调用它的 start() 方法之前，该线程将一直处于新建状态

        A、对

        B、错

        参考答案：A

12、一个线程可以调用 yield() 方法使其他线程有机会运行

        A、对

        B、错

        参考答案：A

        让大家一起竞争CPU时间片

13、如果线程终止，它便不能运行

        A、对

        B、错

        参考答案：A

14、Thread的Stop()方法是终止当前线程，已经过时，不推荐使用

        A、对

        B、错

        参考答案：A

15、在Java中，高优先级的可运行线程会抢占低优先级线程

        A、对

        B、错

        参考答案：A

四、简答

1、现有Student类如下：
public class Student  implements Serializable{
      private String name;
      private int age;

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

      //getter和setter方法省略
}
完成Student对象序列化到文件中和从文件中反序列化成Student对象，文件名称student.dat
完成如下类对应的静态的方法 
public class StudentTest  {
    public static void main(String[] args) {
        writeStudent();
        readStudent();
    }
    //完成Student对象序列化到文件
    private static void writeStudent(){

    }
    //完成从文件中反序列化成Student对象并打印
    private static void readStudent(){

    }
}

Person类

public class Student implements Serializable {
    private String name;
    private int age;

    public Student(String name, int age) {
        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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

序列化

import java.io.*;

public class StudentTest {
    public static void main(String[] args) throws IOException {
        writeStudent();
        readStudent();
    }

    public static void writeStudent() {
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        try {
            //实例化FileOutputStream
            fos = new FileOutputStream("student.txt");
            //实例化ObjectOutputStream
            oos = new ObjectOutputStream(fos);
            //实例化Student
            Student student = new Student("jack", 10);
            oos.writeObject(student);
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                oos.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void readStudent() {
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            //实例化FileInputStream
            fis = new FileInputStream("student.txt");
            //实例化ObjectInputStream
            ois = new ObjectInputStream(fis);
            //从流中读取数据转换成Student
            Student s = (Student) ois.readObject();
            System.out.println(s.toString());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                ois.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 2、写两个线程，⼀个线程打印1~52，另⼀个线程打印A~Z，打印顺序是12A34B56C78D.........4748X4950Y5152Z

public class TwoThread {
    public static void main(String args[]) {
        //必须new了一个MyObject1对象，不能new2个
        MyObject myObject = new MyObject();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 26; i++) {
                    myObject.printNum();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 26; i++) {
                    myObject.printA();
                }
            }

        }).start();
    }
}

class MyObject {
    private static boolean flag = false;
    public int count = 1;

    //synchronized锁住this，只new了一个MyObject1对象所以this是全局的
    public synchronized void printNum() {
        while (flag == true) {
            try {
                //线程等待
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print((2 * count - 1));
        System.out.print(2 * count);
        flag = true;
        this.notify();
    }

    //synchronized锁住this，只new了一个MyObject1对象所以this是全局的
    public synchronized void printA() {
        while (flag == false) {
            try {
                //线程等待
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print((char) (count + 'A' - 1));
        count++;
        flag = false;
        this.notify();
    }
}