多线程面试题

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不创建线程。仍然是同步。