笔试_多线程

一、选择题(每题2分，共20分)

1. 下列说法中错误的一项是（ ）

A. 线程就是程序

B. 线程是一个程序的单个执行流

C. 多线程是指一个程序的多个执行流

D. 多线程用于实现并发

 

1. 下列哪个方法可以使线程从运行状态进入阻塞状态（ ）

A. sleep

B. wait

C. yield

D.    start

 

2. 下列说法中错误的一项是（ ）

A. 一个线程是一个Thread类的实例

B. 线程从传递给纯种的Runnable实例run()方法开始执行

C. 线程操作的数据来自Runnable实例

D. 新建的线程调用start()方法就能立即进入运行状态

 

3. 下列关于Thread类提供的线程控制方法的说法中，错误的一项是（C ）

A. 在线程A中执行线程B的join()方法，则线程A等待直到B执行完成

B. 线程A通过调用interrupt()方法来中断其阻塞状态

C. 若线程A调用方法isAlive()返回值为true，则说明A正在执行中//isAlive()判断是否处于活动状态，就绪、运行和阻塞都属于活动状态

D. currentThread()方法返回当前线程的引用

 

4. 下列说法中，错误的一项是（ B ）

A. 对象锁在synchronized()语句执行完之后由持有它的线程返还

B. 对象锁在synchronized()语句中出现异常时由持有它的线程返还

C. 当持有锁的线程调用了该对象的wait()方法时，线程将释放其持有的锁

D. 当持有锁的线程调用了该对象的构造方法时，线程将释放其持有的锁

 

5. 哪个方法是实现Runnable 接口所需的( )？

A．wait()

B．run()

C．stop()

D．resume()

 

7.什么原因可导致线程停止执行。（  ）

A．线程调用了wait()方法；

B．线程调用了yield()方法；

C．线程调用了pause()方法；

D．线程调用了sleep() 方法。

 

 

8、以下代码的调试结果为?（ D  ）

public class Bground extends Thread{

public static void main(String argv[]){

Bground b = new Bground();

b.run();

}

public void start(){

for (int i = 0; i <10; i++){

System.out.println("Value of i = " + i);

}

}

}

A．编译错误，没有定义线程的run方法；

B．由于没有定义线程的run 方法，而出现运行错误；

C. 编译通过，运行输出values 0 to 9

D. 编译通过，运行无输出

 

我们打开Thread类的定义，可以发现run()的实现如下：

1. @Override  

2.     public void run() {  

3.         if (target != null) {  

4.             target.run();  

5.         }  

6.     }  

其中，这个target，是一个类型为Runnable的对象，并且是可以通过构造器传入的。

 

9、在java 程序中，下列关于线程的说法错误的是: ( )

A、run 方法是运行线程的主体

B、多个进程运行时执行顺序是按顺序执行的

C、如果线程死亡，它便不能运行

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

 

10．实现线程体的方式除了继承Thread 类，还可以实现接口（ ）

A、Cloneable

B、Runnable

C、Iterable

D、Serializable

 

二．填空题(每题3分，共15分)

1. 在Java程序中，run()方法的实现有两种方式：继承Thread类 和 实现接口Runnable_

2.一个进程可以包含多个 线程

3.若在高优先级线程的run( )方法中调用 yield() 方法，则该线程将让出CPU

4. 在执行Java 线程的程序中，程序通过调用___start()____方法启动线程，随后又调用____run()____方法执行线程体。

5.Java 线程程序可以调用____sleep()_____方法，使线程进入睡眠状态，可以通过调用_______setPriority()___________方法设置线程的优先级。

 

三、判断题简答题(每题3分，共15分)

1、启动多线程必须调用start()方法, 如果调用run 方法则没有启动新的线程。（ T ）

2、run 方法是运行线程的主体,若run 方法运行结束，线程就消亡了。（  T  ）

3、要在程序中实现多线程，必须在源程序前面使用import 语句显示的导入Thread 类。（ F ）

4、线程可以用yield 方法使较低优先级的线程运行。（ F）

5、每个Java 线程的优先级都设置在常数1~12 之间，默认的优先级设置为常数6。（ F）

四．简答题(每题2分，共10分)

1.同步和异步有何异同，在什么情况下分别使用他们？举例说明

一：同步在同一时刻，只能被一个对象来使用，而异步则可随机被多个对象使用

  二：资源在同一时刻只能被一个对象使用时可以考虑使用同步，例如：银行取款

      资源在同一时刻可被多个对象使用时可以考虑使用异步，例如：数据共享

答： 如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。 当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

2. 启动一个线程是用 run() 还是 start()?

   start()

答： 启动一个线程是调用start()方法，线程进入就绪状态，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

 

3.多线程有几种实现方法 , 都是什么 ?

继承Thread类 ,实现接口Runnable

答： 多线程有两种实现方法，分别是继承 Thread类与实现Runnable接口 

 

4.同步有几种实现方法 , 都是什么 ? 

2种  

  

同步代码块 :

synchronized{

  //同步代码块

}

 

和   

 

同步方法:

修饰符  synchronized返回类型 方法名{

//同步方法体内代码块

}

答：同步的实现方面有两种，分别是同步方法与同步代码块

 

5.线程的生命周期，以及他们的作用 

就绪状态：等待调度程序分配CPU资源给这个线程运行

运行状态：调度程序分配资源给该进程，该进程正在执行

阻塞状态：线程在等待某个条件，才会具备运行的条件

答：创建、就绪、运行、阻塞、死亡

五、编程题(每题20分，共40分)

1、利用多线程求解某范围被5整除的数,每个线程负责100 范围：线程1 找1-100；线

程2 找101-200；线程3 找201-300。编程程序将每个线程找到的数及时打印。

 

package com.lanqiao.demo_20170415_test;

public class MyThread1 extends Thread{

public MyThread1(String s){

super(s);

}

@Override

public void run() {

for (int i = 1; i <=100; i++) {

if(i%5==0){

System.out.println("我是"+this.getName()+"我找到的数有："+i);

}

}

}

}

 

 

 

 

package com.lanqiao.demo_20170415_test;

public class MyThread2 extends Thread{

public MyThread2(String s){

super(s);

}

@Override

public void run() {

for (int i = 101; i <=200; i++) {

if(i%5==0){

System.out.println("我是"+this.getName()+"我找到的数有："+i);

}

}

}

}

 

 

 

package com.lanqiao.demo_20170415_test;

public class MyThread3 extends Thread{

public MyThread3(String s){

super(s);

}

@Override

public void run() {

for (int i = 201; i <=300; i++) {

if(i%5==0){

System.out.println("我是"+this.getName()+"我找到的数有："+i);

}

}

}

}

 

 

package com.lanqiao.demo_20170415_test;

public class Test {

public static void main(String[] args) {

MyThread1 mt1 = new MyThread1("线程1");

MyThread2 mt2 = new MyThread2("线程2");

MyThread3 mt3 = new MyThread3("线程3");

mt1.start();

mt2.start();

mt3.start();

}

}

 

 

2、请编写一个多线程程序，其中一个线程完成对某个对象的int成员变量的增加操作，

即每次加1， 另一个线程完成对该对象的成员变量的减操作，即每次减1， 同时要保证该变量的值不会小于0，不会大于1，该变量的初始值为0

 》=0  《=1

 0    1

 

 

package com.lanqiao.demo_20170415_test_2;

public class MyThread {

private int a = 0;

public MyThread() {

super();

// TODO Auto-generated constructor stub

}

 

public MyThread(int a) {

super();

this.a = a;

}

 

public void add(){

a += 1;

}

public void substract(){

a -= 1;

}

public int getA() {

return a;

}

 

public void setA(int a) {

this.a = a;

}

}

 

 

 

package com.lanqiao.demo_20170415_test_2;

/**

 * 循环10次,5次是临界点，不满足条件

 * @author Administrator

 *

 */

public class MyThread1 extends Thread{

MyThread my;

public MyThread1(MyThread mt, String s){

super(s);

my = mt;

}

@Override

public void run() {

try {

synchronized(my){

for (int i =1; i <=10; i++) {

if(my.getA()<1){

//加操作

my.add();

System.out.println("我是"+this.getName());

System.out.println("a="+my.getA());

//唤醒

my.notifyAll();

}else{

//等待

my.wait();

}

}

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

 

 

 

package com.lanqiao.demo_20170415_test_2;

/**

 * 循环10次,5次是临界点，不满足条件

 * @author Administrator

 *

 */

public class MyThread2 extends Thread{

MyThread my;

public MyThread2(MyThread my , String s){

super(s);

this.my = my;

}

@Override

public void run() {

try {

synchronized(my){

for (int i =1; i <=10; i++) {

if(my.getA()>0){

//减操作

my.substract();

System.out.println("我是"+this.getName());

System.out.println("a="+my.getA());

//唤醒

my.notifyAll();

}else{

//等待

my.wait();

}

}

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

 

 

 

package com.lanqiao.demo_20170415_test_2;

/**

 * 总共循环20次，有10次是临界点不满足条件，所以结果只有10次

 * @author Administrator

 *

 */

public class Test {

public static void main(String[] args) {

MyThread mt = new MyThread();

MyThread1 my1 = new MyThread1(mt,"线程1");

my1.start();

MyThread2 my2 = new MyThread2(mt,"线程2");

my2.start();

}

}