week 10 Java作业

 

多线程

一、判断题(T为正确,F为错误),每题1分
1.如果线程死亡，它便不能运行。（T）
2.在Java中，高优先级的可运行线程会抢占低优先级线程。（ F）
3.线程可以用yield方法使低优先级的线程运行。（F）
4...程序开发者必须创建一个线程去管理内存的分配。（F）
5.一个线程在调用它的start方法，之前，该线程将一直处于出生期。（ T）
6.当调用一个正在进行线程的stop( )方法时，该线程便会进入休眠状态。（F）
7.一个线程可以调用yield方法使其他线程有机会运行。（T）

8. 多线程没有安全问题(F)

9. 多线程安全问题的解决方案可以使用Lock提供的具体的锁对象操作(T)

10. Stop()方法是终止当前线程的一种状态(T)

 

二、选择题(不定项选择题),每题2分
1.Java语言中提供了一个▁线程，自动回收动态分配的内存。D
A．异步
B．消费者
C．守护
D．垃圾收集
2.Java语言避免了大多数的▁错误。C
A．数组下标越界
B．算术溢出
C．内存泄露
D．非法的方法参数
3.有三种原因可以导致线程不能运行，它们是▁。ABCD
A．等待
B．阻塞
C．休眠
D．挂起及由于I/O操作而阻塞
4.当A▁方法终止时，能使线程进入死亡状态。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包中的抽象类()ABCDEF

A. InputStream

B. OutputStream

C. PrintStream

D. Reader

E. FileInputStream

F. FileWriter

 

三、简述题,每题5分
1.简述程序、进程和线程之间的关系？什么是多线程程序？

进程,正在运行的应用程序

线程,依赖于进程存在,理解某一个进程的某一个任务

如果程序的执行路径有多条,就是多线程程序

3.什么是线程调度？Java的线程调度采用什么策略？

线程调度是对处于可运行状态的多个线程对象进行系统级的协调，防止多个线程争用有限资源而导致系统死机或者崩溃。

java 的调度策略是CPU时间片的轮转以及基于线程优先级的抢先式调度

4.如何在Java程序中实现多线程？

三种方式

第一种:继承Thread类

第二种:实现Runnable接口

第三种: 利用Executors工厂类实现由返回结果ExecutorService的线程池

 

5. 试简述Thread类的子类或实现Runnable接口两种方法的异同？

不同点:一个是继承自Thread类,,一个是采用实现Runnable接口

相同点:都要重写run方法

 

6. 说明缓冲流的优点和原理

优点:缓冲流输出和输入字节和字符流能够更高效率

原理:创建一个缓冲区,通过缓冲区进行写入和导出

8:在Java中wait()和sleep()方法的不同?

执行到wait()时,线程进行休眠等待并释放机锁

而sleep()可以不在synchornize的块下调用,而且使用sleep()方法时线程睡眠不会丢失当前线程对象的同步锁

 

9:Java中Runnable和Callable有什么不同?

Callable 使用 call()方法，Runnable 使用run()方法

call() 可以返回值,而run()方法不能返回。

call() 可以抛出受检查的异常，比如ClassNotFoundException，而run()不能抛出受检查的异常

Runnable 启动方法为start(),而Callable采用的是Future submit(Callable task)提交任务从而启动线程；

 

四、程序设计题
1.编写一个应用程序，在线程同步的情况下来实现“生产者―消费者”问题。

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

Thread t2 = new Thread(gt) ;

t1.start() ;

t2.start() ;

}

}

 

public class Student {

String name;

int age ;

boolean flag ;

}

 

 

 

 

//生产者线程

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 = "RNG" ;

s.age = 666;

}else{

s.name = "EDG" ;

s.age =233 ;

}

x ++ ;

s.flag = true ;

s.notify() ; }

}

}

 

}

 

//消费者线程

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 ;

s.notify() ;

}

}

}

}

 

 

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

同上,加入仓库类对象,

3

1)将若干个Student对象;若干个Teacher对象,写出到d:/0404/a.txt中,

  2)将该文件中所有的Student对象反序列化回来,装入List,所有的Teacher对象反序列化回来装入另一个List

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;

 

 

public class HomeWork4 {

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("RNG",666));

    obs.writeObject(new Student("EDG",233));

    obs.writeObject(new Student("LGD",433));

    obs.writeObject(new Teacher("OMG",134));

    obs.writeObject(new Teacher("JDG",234));

    obs.writeObject(new Teacher("IM",354));

    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<6;i++){

        if(i<3){

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

    }

}

}

 

//学生类

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 + "]";

}

 

}

 

//教师类

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”转换为字节数组,并将字节数组再转换回字符串!

public class HomeWork5 {

 

 

    public static void main(String[] args){

        String str="西部开源技术中心xbkyjszx";

        byte[] by=str.getBytes();

 

        String str1=new String(by);

        System.out.println(str1);

    }

}

5:用Java编程一个会导致死锁的程序,你将怎么解决?请你设计

class Dead implements Runnable {

public boolean flag;

public Object lock1 = new Object();

public Object lock2 = new Object();

 

public Dead(boolean flag) {

this.flag = flag;

}

 

public void run() {

while (true) {

if (flag) {

synchronized (Lock.lock1) {

System.out.println("if loc1");

synchronized (Lock.lock2) {

System.out.println("if lock2");

}

}

}

 

else {

synchronized (Lock.lock2) {

System.out.println("else lock2");

synchronized (Lock.lock1) {

System.out.println("else lock1");

}

}

}

}

}

}

 

class Lock {

static Object lock1 = new Object();

static Object lock2 = new Object();

}

 

public class HomeWork6 {

 

public static void main(String args[]) {

Thread t1 = new Thread(new Dead(true));

Thread t2 = new Thread(new Dead(false));

t1.start();

t2.start();

}

}

使用的锁不同,导致两个锁发生死锁

6:递归实现输入任意目录,列出文件以及文件夹

import java.io.File;

import java.util.Scanner;

 

class HomeWork8{

    public static void main(String[] args) {

    Scanner sc = new Scanner (System.in);

 

    File file =new File(sc.nextLine());

        print(file);

    }

    public static void print(File file){

       if(file!=null){

            if(file.isDirectory()){

                File[] fileArray=file.listFiles();

                if(fileArray!=null){

                    for (int i = 0; i < fileArray.length; i++) {

                    

                        print(fileArray[i]);

                    }

                }

            }

            else{

                System.out.println(file);

            }

        }

    }

}