JAVA开发面试题&多线程篇&第一部分

1下面程序的运行结果（）（选择一项）

public static void main(String[] args) {
 Thread t=new Thread(){
   public void run(){
    pong();
     }
   };
 t.run();
 System.out.println("ping");
}
static void pong(){
 System.out.println("pong");
}

选项	内容
A	pingpong
B	pongping
C	pingpong和pongping都有可能
D	都不输出

答案：B
分析：启动线程需要调用start()方法，而t.run()方法，则是使用对象名.

2下列哪个方法可用于创建一个可运行的类（）

选项	内容
A	public class X implements Runnable{public void run() {……}}
B	public class X extends Thread{public void run() {……}}
C	public class X extends Thread{public int run() {……}}
D	public class X implements Runnable{protected void run() {……}}

答案：AB
分析： 继承Thread和实现Runable接口，并注意返回值类型

3说明类java.lang.ThreadLocal的作用和原理。列举在哪些程序中见过ThreadLocal的使用？

作用：
要编写一个多线程安全(Thread-safe)的程序是困难的，为了让线程共享资源，必须小心地对共享资源进行同步，同步带来一定的效能延迟，而另一方面，在处理同步的时候，又要注意对象的锁定与释放，避免产生死结，种种因素都使得编写多线程程序变得困难。
尝试从另一个角度来思考多线程共享资源的问题，既然共享资源这么困难，那么就干脆不要共享，何不为每个线程创造一个资源的复本。将每一个线程存取数据的行为加以隔离，实现的方法就是给予每个线程一个特定空间来保管该线程所独享的资源。
比如：在Hibernate中的Session就有使用。
ThreadLocal的原理
ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。

4说说乐观锁与悲观锁

答：悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。
乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于write_condition机制的其实都是提供的乐观锁。
两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下，即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果经常产生冲突，上层应用会不断的进行retry，这样反倒是降低了性能，所以这种情况下用悲观锁就比较合适。

5在Java中怎么实现多线程?描述线程状态的变化过程。

答：当多个线程访问同一个数据时，容易出现线程安全问题，需要某种方式来确保资源在某一时刻只被一个线程使用。需要让线程同步，保证数据安全线程同步的实现方案： 同步代码块和同步方法，均需要使用synchronized关键字
同步代码块：
public void makeWithdrawal(int amt) { synchronized (acct) { } }
同步方法：public synchronized void makeWithdrawal(int amt) { }
线程同步的好处：解决了线程安全问题
线程同步的缺点：性能下降，可能会带来死锁

6请写出多线程代码使用Thread或者Runnable，并说出两种的区别。

方式1：继承Java.lang.Thread类，并覆盖run() 方法。优势：编写简单；劣势：无法继承其它父类

public class ThreadDemo1 {
public static void main(String args[]) {
MyThread1 t = new MyThread1();
t.start();
while (true) {
System.out.println("兔子领先了，别骄傲");
}
}
}
class MyThread1 extends Thread {
public void run() {
while (true) {
System.out.println("乌龟领先了，加油");
}
}
}

方式2：实现Java.lang.Runnable接口，并实现run()方法。优势：可继承其它类，多线程可共享同一个Thread对象；劣势：编程方式稍微复杂，如需访问当前线程，需调用Thread.currentThread()方法

public class ThreadDemo2 {
public static void main(String args[]) {
MyThread2 mt = new MyThread2();
Thread t = new Thread(mt);
t.start();
while (true) {
System.out.println("兔子领先了，加油");
}
}
}
class MyThread2 implements Runnable {
public void run() {
while (true) {
System.out.println("乌龟超过了，再接再厉");
}
}
}

7在多线程编程里，wait方法的调用方式是怎样的？

答:wait方法是线程通信的方法之一，必须用在 synchronized方法或者synchronized代码块中，否则会抛出异常，这就涉及到一个“锁”的概念，而wait方法必须使用上锁的对象来调用，从而持有该对象的锁进入线程等待状态，直到使用该上锁的对象调用notify或者notifyAll方法来唤醒之前进入等待的线程，以释放持有的锁。

8Java线程的几种状态

答:线程是一个动态执行的过程，它有一个从产生到死亡的过程，共五种状态：
新建（new Thread）
当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）
例如：Thread t1=new Thread();
就绪（runnable）
线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如：t1.start();
运行（running）
线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。
死亡（dead）
当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。
自然终止：正常运行run()方法后终止
异常终止：调用stop()方法让一个线程终止运行
堵塞（blocked）
由于某种原因导致正在运行的线程让出CPU并暂停自己的执行，即进入堵塞状态。
正在睡眠：用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。
正在等待：调用wait()方法。（调用motify()方法回到就绪状态）
被另一个线程所阻塞：调用suspend()方法。（调用resume()方法恢复）

9在Java多线程中，请用下面哪种方式不会使线程进入阻塞状态（）

选项	内容
A	sleep()
B	Suspend()
C	wait()
D	yield()

答案：D
分析：yield会是线程进入就绪状态