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.编译运行下面的代码会发生什么？

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

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

public class Agg {
    public static void main(String argv[]) {
        Agg a = new Agg();
        a.go();
    }
 
    public void go() {
        DSRoss ds1 = new DSRoss("one");
        ds1.start();
    }
}
 
class DSRoss extends Thread {
    private String sTname = "";
 
    DSRoss(String s) {
        sTname = s;
    }
 
    public void run() {
        notwait();
        System.out.println("finished");
    }
 
    public void notwait() {
        while (true) {
            try {
                System.out.println("waiting");
                wait();
            } catch (InterruptedException ie) {
            }
            System.out.println(sTname);
            notifyAll();
        }
    }
}

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

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

public class Test extends Thread {
    private String sThreadName;
 
    public static void main(String argv[]) {
        Test h = new Test();
        h.go();
    }
 
    Test() {
    }
 
    Test(String s) {
        sThreadName = s;
    }
 
    public String getThreadName() {
        return sThreadName;
    }
 
    public void go() {
        Test first = new Test("first");
        first.start();
        Test second = new Test("second");
        second.start();
    }
 
    public void start() {
        for (int i = 0; i < 2; i++) {
            System.out.println(getThreadName() + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

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

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

public class Test {
    public static void main(String argv[]) {
        Pmcraven pm1 = new Pmcraven("one");
        pm1.run();
        Pmcraven pm2 = new Pmcraven("two");
        pm2.run();
    }
}
 
class Pmcraven extends Thread {
    private String sTname = "";
 
    Pmcraven(String s) {
        sTname = s;
    }
 
    public void run() {
        for (int i = 0; i < 2; i++) {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
            }
            yield();
            System.out.println(sTname);
        }
    }
}

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