java多线程面试题

面试题目

 

1.什么是多线程编程？什么时候使用？
多线程一般用于当一个程序需要同时做一个以上的任务。多线程通常用于GUI交互程序。一个新的线程被创建做一些耗时的工作，当主线程保持界面与用户的交互。

2.为什么wait(),notify()和notifyall()函数定义在Object类里面?
因为所有类都是继承于Object类，这样所有类就可以简单的进行多线程编程了。

3.wait()方法和sleep()方法有什么不同？
sleep()方法执行后仍然拥有线程，只是延时。而wait方法放弃了线程控制，其它线程可以运行。

4.Thread和Runnable有什么不同？
JAVA线程控制着程序执行的主路径。当你用java命令调用JVM时，JVM创建了一个隐式线程来执行main方法。Thread类提供了主线程调用其它线程并行运行的机制。

Runnable接口定义了一个能被Thread运行的类。实现Runnable的类只需要实行run方法。可以很灵活的扩展现在的已经继承自其它父类的类。而thread则不可以，因为java只允许继承一个父类。

5.我可以重载start()方法么？
因为Thread类的start()方法并不是final方法，因此可以，但不推荐这样做。因为在start()方法里创建一个新的线程，进行特定的操作。你可以传递一个实现了Runnable接口的类到Thread,或者继承Thread类，重载run()方法。

6. SwingUtilities.invokeLater(Runnable)方法是用来做什么用的?
这个方法可以在不干扰GUI的事件队列的情况下在应用程序中执行一个线程。它将runnable对象放在事件的队列中然后立即返回。只有当这个队象移到队列的最前端时它的run()方法才被调用。

7.volatile是用来做什么的？
volatile 的意思是变量的值不能被ＪＶＭ优化，这样可以在某一程度上保证变量的可见性。

8.什么是绿色线程？
绿色线程是指所有的代码JVM都执行在单个操作系统线程，即使是多线程程序，JVM间断的控制多线程程序而不是用其它的操作系统线程，这种模式已经被废弃了。

9.编译运行下面的代码会发生什么？

1. public class Bground extends Thread{
2.     public static void main(String argv[])
3.     {
4.         Bground b = new Bground();
5.         b.run();
6.     }
7.     public void start()
8.     {
9.        for (int i = 0; i <10; i++){
10.            System.out.println("Value of i = " + i);
11.        }
12.     }
13. }

A.编译错误，Thread类中的run方法没有定义
B.运行时错误，Thread类中的run方法没有定义
C.编译无错，打印0到9.
D.编译无错，不打印任何值
答案：Ｄ，调用run不创建线程。


10.关于下面一段代码，哪些描述是正确的

1. public class Agg {
2.     public static void main(String argv[]) {
3.         Agg a = new Agg();
4.         a.go();
5.     }
6.  
7.     public void go() {
8.         DSRoss ds1 = new DSRoss("one");
9.         ds1.start();
10.     }
11. }
12.  
13. class DSRoss extends Thread {
14.     private String sTname = "";
15.  
16.     DSRoss(String s) {
17.         sTname = s;
18.     }
19.  
20.     public void run() {
21.         notwait();
22.         System.out.println("finished");
23.     }
24.  
25.     public void notwait() {
26.         while (true) {
27.             try {
28.                 System.out.println("waiting");
29.                 wait();
30.             } catch (InterruptedException ie) {
31.             }
32.             System.out.println(sTname);
33.             notifyAll();
34.         }
35.     }
36. }

A.编译错误
B.能够编译，输出“waiting"
C.能够编译, 输出“waiting"，紧接着输出"finish"
D.运行时错误，会抛异常
答案：Ｄ，wait必须在Synchronize块或者函数里。


11.编译运行下面的代码会发生什么

1. public class Test extends Thread {
2.     private String sThreadName;
3.  
4.     public static void main(String argv[]) {
5.         Test h = new Test();
6.         h.go();
7.     }
8.  
9.     Test() {
10.     }
11.  
12.     Test(String s) {
13.         sThreadName = s;
14.     }
15.  
16.     public String getThreadName() {
17.         return sThreadName;
18.     }
19.  
20.     public void go() {
21.         Test first = new Test("first");
22.         first.start();
23.         Test second = new Test("second");
24.         second.start();
25.     }
26.  
27.     public void start() {
28.         for (int i = 0; i < 2; i++) {
29.             System.out.println(getThreadName() + i);
30.             try {
31.                 Thread.sleep(100);
32.             } catch (InterruptedException e) {
33.                 System.out.println(e.getMessage());
34.             }
35.         }
36.     }
37. }

A.编译错误
B.输出first0, second0, first1, second1.
C.输出first0, first1, second0, second1.
D.运行时错误
答案:C，如果要实现Ｂ的效果的话应该重载run,而不是start


12.编译运行下面的代码会发生什么

1. public class Test {
2.     public static void main(String argv[]) {
3.         Pmcraven pm1 = new Pmcraven("one");
4.         pm1.run();
5.         Pmcraven pm2 = new Pmcraven("two");
6.         pm2.run();
7.     }
8. }
9.  
10. class Pmcraven extends Thread {
11.     private String sTname = "";
12.  
13.     Pmcraven(String s) {
14.         sTname = s;
15.     }
16.  
17.     public void run() {
18.         for (int i = 0; i < 2; i++) {
19.             try {
20.                 sleep(1000);
21.             } catch (InterruptedException e) {
22.             }
23.             yield();
24.             System.out.println(sTname);
25.         }
26.     }
27. }

A.编译错误
B.输出One One Two Two
C.输出One Two One Two
D.输出One Two One Two
答案Ｂ　调用run不创建线程。仍然是同步。

 

来源：http://blog.sina.com.cn/s/blog_4127feea0100m2kj.html