Java homework 10

 

多线程

一、判断题(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.有三种原因可以导致线程不能运行，它们是ACD▁。
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.简述程序、进程和线程之间的关系？什么是多线程程序？

答：程序是一段静态的代码，它是应用软件执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行到执行完毕的一个完整过程。这个过程也是进程本身从产生、发展、到消亡的过程。线程是比进程更小的单位。一个进程在其执行过程中，可以产生多个线程，形成多个执行流。每个执行流即每个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念。多线程程序是指一个程序中包含多个执行流。
3.什么是线程调度？Java的线程调度采用什么策略？

答：在单个CPU上以某种顺序运行多个线程，称为线程的调度。Java的线程调度策略是一种优先级的抢先式调度。Java基于线程的优先级选择高优先级的线程进行运行。该线程将持续运行，直到它终止运行，或其他高优先级线程称为可运行的。
4.如何在Java程序中实现多线程？

答：多线程程序实现的第一种方式:

1)自定一个类:MyThread 继承自Thread类

2)在MyThread类中重写Thread类中的run()

3)在主线程中,创建该类的实例对象,启动线程

多线程程序实现的第二种方式:

1)自定义一个类MyRunnable,该类实现Runnable接口

2)实现该接口中的run()方法

3)在主线程中创建该类的实例对象,

4)创建Thread类对象

5)分别启动线程

多线程程序实现的第三种方式:

1)自己创建一个类并实现Callable接口；

2)创建线程池对象利用工厂类；

3)提交Callable任务；

4)结束线程池；

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

答：采用继承Thread类方法使程序代码简单，并可以在run（）方法中直接调用线程的其他方法。而实现Runnable接口更符合面向对象设计的思想，因为从OO设计的角度，thread类是虚拟CPU的封装，所以Thread的子类应该是关于CPU行为的类。但在继承Thread类之类构造线程的方法中，Thread类的子类大都是与CPU不相关的类。而实现Runnable接口的方法，将不影响Java类的体系，所以更加符合面向对象的设计思想。同时，实现了Runnable接口的类可以用extends继承其他的类。

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

答：优点：能够更高效的读写数据

原理：先将数据存入缓冲区，然后一起写入或者读取出来。

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

答： sleep()方法是属于Thread类中的，而wait()方法，则是属于Object类中的。

sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是它的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态，在调用sleep()方法的过程中，线程不会释放对象锁，而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备，获取对象锁进入运行状态。

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

答：Runnable和Callable的区别是：

(1)Callable规定的方法是call(),Runnable规定的方法是run().

(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得

(3)call方法可以抛出异常，run方法不可以

 

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

   publicclass StudentDemo { 

   publicstatic void main(String[] args) {   

      //创建一个资源对象

      Student s = new Student() ;   

      //创建资源对象

      SetThread st = new SetThread(s) ;

      GetThread gt = new GetThread(s) ;   

      //创建线程类对象

      Threadt 1 = new Thread(st) ;

      Threadt 2 = new Thread(gt) ;     

      //分别启动线程     

      t1.start();

      t2.start();   

   }

}

 

class Student {

   private String name;

   private int age ;

   //声明一个变量

   private boolean flag ; //默认没有数据,如果true,则说明有数据

   public synchronized void set(String name, int age) {

      //同步机制进行操作

      //判断有没有数据

      if(this.flag) {

         //处于等待状态

         try{

            this.wait();//阻塞式方法,立即释放锁 notify notifyAll();

         }catch (InterruptedException e) {

            e.printStackTrace();

         }

      }    

      //设置学生数据

      this.name= name ;

      this.age= age ;     

      //修改标记

      this.flag= true ;//有数据

      //通知t2:消费者线程来消费数据

      this.notify();//唤醒等待这种状态

   } 

   publicsynchronized void get(){

         if(!this.flag){

            try{

                this.wait();//调用的时候,会立即释放锁

            }catch (InterruptedException e) {

                e.printStackTrace();

            }

         }

         //输出语句

         System.out.println(this.name+"   "+this.age);    

         //修改标记

         this.flag= false ;//消费者线程

         //通知对方(t1线程),消费者线程没有数据类,赶紧来消费

         this.notify();//唤醒t1线程

   } 

}

 

//生产者线程

class SetThread implements Runnable{

   private Student s ;

   public SetThread(Student s){

      this.s= s ;

   } 

   privateint x = 0 ;

   publicvoid run() {

      while(true){

         if(x%2 ==0){

            s.set("Anny",33);

         }else{

            s.set("Lucy",22);

         }

         x++ ;

      }    

   }

}

 

//消费者线程

class GetThread implements Runnable{

   private Student s ;

   public GetThread(Student s){

      this.s= s ;

   }

   publicvoid run() {

      while(true) {

         //调用方法

         s.get();

      }

   }

}

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 ObjectStreamDemo {

       publicstatic void main(String[] args) throws IOException, ClassNotFoundException {

//            createFolder();

//            write();

              read();

       }

 

       privatestatic void read() throws IOException, ClassNotFoundException {

                            //创建一个反序列化流对象

                            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\0404\\a.txt"));                  

                            //使用反序列化

                            Object obj1 = ois.readObject();

                            Object obj2 = ois.readObject();

                            Object obj3 = ois.readObject();

                            Object obj4 = ois.readObject();

                            Object obj5 = ois.readObject();

                            Object obj6 = ois.readObject();

                            Object obj7 = ois.readObject();

                            Object obj8 = ois.readObject();

                             ArrayList<Object>  student = new ArrayList<Object>();

                             ArrayList<Object>  teacher = new ArrayList<Object>();

                             student.add(obj1);

                             student.add(obj2);

                             student.add(obj3);

                             student.add(obj4);

                             teacher.add(obj5);

                             teacher.add(obj6);

                             teacher.add(obj7);

                             teacher.add(obj8);

                             //遍历集合

                             for(Object  s : student) {

                                    System.out.println(s);

                             }

                             for(Object  t : teacher) {

                                    System.out.println(t);

                             }                        

                            //关闭资源

                            ois.close();

       }

 

       privatestatic void createFolder() throws IOException {

              //创建文件

              File f = new File("d:\\0404");

              f.mkdirs();

              File file = new File(f,"a.txt");

              file.createNewFile();

             

       }

 

       privatestatic void write() throws IOException {

              Student s1 = new Student("郭嘉", 26);

              Student s2 = new Student("荀彧", 36);

              Student s3 = new Student("贾诩", 45);

              Student s4 = new Student("周瑜", 25);

              Teacher t1 = new Teacher("孔子", 80);

              Teacher t2 = new Teacher("老子", 70);

              Teacher t3 = new Teacher("庄子", 75);

              Teacher t4 = new Teacher("孟子", 60);

             

              //创建一个序列化流对象

              ObjectOutputStream oos = new ObjectOutputStream(newFileOutputStream("d:\\0404\\a.txt"));

              //写数据

              oos.writeObject(s1);

              oos.writeObject(s2);

              oos.writeObject(s3);

              oos.writeObject(s4);

              oos.writeObject(t1);

              oos.writeObject(t2);

              oos.writeObject(t3);

              oos.writeObject(t4);

              //释放资源

              oos.close();

       }

}

//学生类

import java.io.Serializable;

 

public class Student implements Serializable {

       private static final long serialVersion UID = 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 serialVersion UID = 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 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"Teacher [name=" + name + ", age=" + age + "]";

       }

 

}

4.实现字符串和字节数组之间的相互转换,比如:将字符串”西部开源技术中心xbkyjszx”转换为字节数组,并将字节数组再转换回字符串!

public class StringByte {

 public static void main(String[] args) {

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

       byte[]  bys=s.getBytes();

       String str=new String(bys);

       System.out.println(str);

}

}

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

public class DeadLockDemo {

public static void main(String[] args) {       

              //创建线程类对象

              DeadLockd l1 = new DeadLock(true);

              DeadLockd l2 = new DeadLock(false);       

              //启动线程

              dl1.start();

              dl2.start();

       }    

}

 

public class DeadLock extends Thread {

       //定义一个成员变量

       private boolean flag;

       public DeadLock(boolean flag) {

              this.flag= flag;

       }

       public void run() {

              //dl1,dl2线程

              if(flag) {

                     synchronized(MyLock.objA) {

                            System.out.println("ifobjA");

                            synchronized(MyLock.objB) {

                                   System.out.println("ifobjB");

                            }

                     }// 代码执行完毕,objA锁相当于才能被释放掉

              }else {

                     //dl2

                     synchronized(MyLock.objB) {

                            System.out.println("elseobjB");

                            synchronized(MyLock.objA) {

                                   System.out.println("elseobjA");

                            }

                     }

              }

       }

}

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

import java.io.File;

import java.util.Scanner;

 

public class GetFileName {

       public static void main(String[] args) {

              //输入任意目录

              Scanner sc=new Scanner(System.in);

              System.out.println("请输入一个目录：");

              String s=sc.nextLine();

              //封装目录

              File file = new File(s);

              //递归实现

              getFileName(file);

       }

       private static void getFileName(File file) {

              //获取该目录下的所有文件或者文件夹的File数组

              File [] fileArray = file.listFiles();

              if(fileArray != null) {

                     //遍历该File数组，得到每一个File对象

                     for(File f : fileArray) {

                            //判断该File对象是否是文件夹

                            if(f.isDirectory()) {

                                   getFileName(f);

                            }else{

                                   System.out.println("文件名为："+f.getName());

                            }

                     }

                     System.out.println("文件夹名为："+file.getName());

              }

       }

}