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