多线程面试题

线程或者说多线程，是我们处理多任务的强大工具。线程和进程是不同的，每个进程都是一个独立运行

的程序，拥有自己的变量，且不同进程间的变量不能共享；而线程是运行在进程内部的，每个正在运行的进程至少有一个线程，而且不同的线程之间可以在进程范围内共享数据。也就是说进程有自己独立的存储

空间，而线程是和它所属的进程内的其他线程共享一个存储空间。线程的使用可以使我们能够并行地处理

一些事情。线程通过并行的处理给用户带来更好的使用体验，比如你使用的邮件系统（outlook、Thunderbird、foxmail等），你当然不希望它们在收取新邮件的时候，导致你连已经收下来的邮件都无法阅读，而只能等待收取邮件操作执行完毕。这正是线程的意义所在。

实现线程的方式

实现线程的方式有两种：

1.继承https://www.sodocs.net/doc/4d7657027.html,ng.Thread，并重写它的run()方法，将线程的执行主体放入其中。

2. 实现https://www.sodocs.net/doc/4d7657027.html,ng.Runnable接口，实现它的run()方法，并将线程的执行主体放入其中。

这是继承Thread类实现线程的示例：

[java]view plaincopyprint?

1.public class ThreadTest extends Thread {
public void run() {
// 在

这里编写线程执行的主体
// do something
}
}

这是实现Runnable接口实现多线程的示例：

[java]view plaincopyprint?

1.public class RunnableTest implements Runnable {
public void run() {

>// 在这里编写线程执行的主体
// do something
}
}

这两种实现方式的区别并不大。继承Thread类的方式实现起来较为简单，但是继承它的类就不能再继承

别的类了，因此也就不能继承别的类的有用的方法了。而使用是想Runnable接口的方式就不存在这个问

题了，而且这种实现方式将线程主体和线程对象本身分离开来，逻辑上也较为清晰，所以推荐大家更多地

采用这种方式。

如何启动线程

我们通过以上两种方式实现了一个线程之后，线程的实例并没有被创建，因此它们也并没有被运行。我们要启动一个线程，必须调用方法来启动它，这个方法就是Thread类的start()方法，而不是run()方法（既不是我们继承Thread类重写的run()方法，也不是实现Runnable接口的run()方法）。run()方法中包含的是线程的主体，也就是这个线程被启动后将要运行的代码，它跟线程的启动没有任何关系。上面两种实现线程的方式在启动时会有所不同。

继承Thread类的启动方式：

[java]view plaincopyprint?

1.public class ThreadStartTest {
public static void main(String[] args)

{
// 创建一个线程实例
ThreadTest tt = new ThreadTest();
// 启动线

程
tt.start();
}
}

实现Runnable接口的启动方式：

[java]view plaincopyprint?

1.public class RunnableStartTest {
public static void main(String[] args

) {
// 创建一个线程实例

Thread t = new Thread(new RunnableTest());
// 启动线程

t.start();
}
}

实际上这两种启动线程的方式原理是一样的。首先都是调用本地方法启动一个线程，其次是在这个线程里执行目标对象的run()方法。那么这个目标对象是什么呢？为了弄明白这个问题，我们来看看Thread类的run()方法的实现：

[java]view plaincopyprint?

1.public void run() {
if (target != null) {
target.run();
}
}

当我们采用实现Runnable接口的方式来实现线程的情况下，在调用new Thread(Runnable target)构造器时，将实现Runnable接口的类的实例设置成了线程要执行的主体所属的目标对象target，当线程启动时，这个实例的run()方法就被执行了。当我们采用继承Thread的方式实现线程时，线程的这个run()方法被重写了，所以当线程启动时，执行的是这个对象自身的run()方法。总结起来就一句话，线程类有一个Runnable 类型的target属性，它是线程启动后要执行的run()方法所属的主体，如果我们采用的是继承Thread类的方式，那么这个target就是线程对象自身，如果我们采用的是实现Runnable接口的方式，那么这个target

就是实现了Runnable接口的类的实例。

线程的状态

在Java 1.4及以下的版本中，每个线程都具有新建、可运行、阻塞、死亡四种状态，但是在Java 5.0及以上版本中，线程的状态被扩充为新建、可运行、阻塞、等待、定时等待、死亡六种。线程的状态完全包含了一个线程从新建到运行，最后到结束的整个生命周期。线程状态的具体信息如下：

1.NEW（新建状态、初始化状态）：线程对象已经被创建，但是还没有被启动时的状态。这段

时间就是在我们调用new命令之后，调用start()方法之前。

2. RUNNABLE（可运行状态、就绪状态）：在我们调用了线程的start()方法之后线程所处的

状态。处于RUNNABLE状态的线程在JAVA虚拟机（JVM）上是运行着的，但是它可能还正

在等待操作系统分配给它相应的运行资源以得以运行。

3. BLOCKED（阻塞状态、被中断运行）：线程正在等待其它的线程释放同步锁，以进入一个

同步块或者同步方法继续运行；或者它已经进入了某个同步块或同步方法，在运行的过程中

它调用了某个对象继承自https://www.sodocs.net/doc/4d7657027.html,ng.Object的wait()方法，正在等待重新返回这个同步块或同

步方法。

4. WAITING（等待状态）：当前线程调用了https://www.sodocs.net/doc/4d7657027.html,ng.Object.wait()、https://www.sodocs.net/doc/4d7657027.html,ng.Thread.join()

或者java.util.concurrent.locks.LockSupport.park()三个中的任意一个方法，正在等待另外一

个线程执行某个操作。比如一个线程调用了某个对象的wait()方法，正在等待其它线程调用这

个对象的notify()或者notifyAll()（这两个方法同样是继承自Object类）方法来唤醒它；或者

一个线程调用了另一个线程的join()（这个方法属于Thread类）方法，正在等待这个方法运

行结束。

5. TIMED_WAITING（定时等待状态）：当前线程调用了https://www.sodocs.net/doc/4d7657027.html,ng.Object.wait(long timeout)、

https://www.sodocs.net/doc/4d7657027.html,ng.Thread.join(long millis)、java.util.concurrent.locks.LockSupport.packNanos(long

nanos)、java.util.concurrent.locks.LockSupport.packUntil(long deadline)四个方法中的任意一

个，进入等待状态，但是与WAITING状态不同的是，它有一个最大等待时间，即使等待的条

件仍然没有满足，只要到了这个时间它就会自动醒来。

6. TERMINATED（死亡状态、终止状态）：线程完成执行后的状态。线程执行完run()方法中

的全部代码，从该方法中退出，进入TERMINATED状态。还有一种情况是run()在运行过程

中抛出了一个异常，而这个异常没有被程序捕获，导致这个线程异常终止进入TERMINATED

状态。

在Java5.0及以上版本中，线程的全部六种状态都以枚举类型的形式定义在https://www.sodocs.net/doc/4d7657027.html,ng.Thread类中了，代码如下：

[java]view plaincopyprint?

1.public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED

_WAITING,
TERMINATED;
}

sleep()和wait()的区别

sleep()方法和wait()方法都成产生让当前运行的线程停止运行的效果，这是它们的共同点。下面我们来详细说说它们的不同之处。

sleep()方法是本地方法，属于Thread类，它有两种定义：

[java]view plaincopyprint?

1.public static native void sleep(long millis) throws InterruptedException;

public static void sleep(long millis, int nanos) throws InterruptedEx

ception {
//other code
}

其中的参数millis代表毫秒数（千分之一秒），nanos代表纳秒数（十亿分之一秒）。这两个方法都可以让调用它的线程沉睡（停止运行）指定的时间，到了这个时间，线程就会自动醒来，变为可运行状态（RUNNABLE），但这并不表示它马上就会被运行，因为线程调度机制恢复线程的运行也需要时间。调用sleep()方法并不会让线程释放它所持有的同步锁；而且在这期间它也不会阻碍其它线程的运行。上面的连个方法都声明抛出一个InterruptedException类型的异常，这是因为线程在sleep()期间，有可能被持有它的引用的其它线程调用它的interrupt()方法而中断。中断一个线程会导致一个InterruptedException异常的产生，如果你的程序不捕获这个异常，线程就会异常终止，进入TERMINATED状态，如果你的程序捕获了这个异常，那么程序就会继续执行catch语句块（可能还有finally语句块）以及以后的代码。

为了更好地理解interrupt()效果，我们来看一下下面这个例子：

[java]view plaincopyprint?

1.public class InterruptTest {
public static void main(String[] args) {<

BR>Thread t = new Thread() {
public void run() {
try {
System.ou

t.println("我被执行了-在sleep()方法前");
// 停止运行10分钟

Thread.sleep(1000 * 60 * 60 * 10);
System.out.println("我被执行了-

在sleep()方法后

");
} catch (InterruptedException e) {
System.out.println("我被执行

了-在catch语句块中");
}
System.out.println("我被执行了-在try{}语句块

后");
}
};
// 启动线程
t.start();
// 在sleep()结束前中断它

t.interrupt();
}
}

运行结果：

1.我被执行了-在sleep()方法前

2. 我被执行了-在catch语句块中

3. 我被执行了-在try{}语句块后

wait()方法也是本地方法，属于Object类，有三个定义：

[java]view plaincopyprint?

1.public final void wait() throws InterruptedException {
//do something<

BR>}
public final native void wait(long timeout) throws InterruptedExc

eption;
public final void wait(long timeout, int nanos) throws Interru

ptedException {
//do something
}

wari()和wait(long timeout,int nanos)方法都是基于wait(long timeout)方法实现的。同样地，timeout代表毫秒数，nanos代表纳秒数。当调用了某个对象的wait()方法时，当前运行的线程就会转入等待状态（WAITING），等待别的线程再次调用这个对象的notify()或者notifyAll()方法（这两个方法也是本地方法）唤醒它，或者到了指定的最大等待时间，线程自动醒来。如果线程拥有某个或某些对象的同步锁，那么在调用了wait()后，这个线程就会释放它持有的所有同步资源，而不限于这个被调用了wait()方法的对象。wait()方法同样会被Thread类的interrupt()方法中断，并产生一个InterruptedException异常，效果同sleep()方法被中断一样。

实现同步的方式

同步是多线程中的重要概念。同步的使用可以保证在多线程运行的环境中，程序不会产生设计之外的错误结果。同步的实现方式有两种，同步方法和同步块，这两种方式都要用到synchronized关键字。

给一个方法增加synchronized修饰符之后就可以使它成为同步方法，这个方法可以是静态方法和非静态方法，但是不能是抽象类的抽象方法，也不能是接口中的接口方法。下面代码是一个同步方法的示例：[java]view plaincopyprint?

1.public synchronized void aMethod() {
// do something
}
public st

atic synchronized void anotherMethod() {
// do something
}

线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线程是可以访问这个对象的所有非同步方法的。

同步块的形式虽然与同步方法不同，但是原理和效果是一致的。同步块是通过锁定一个指定的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行同步，而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢？那么线程锁定的就不是这个类的对象了，也不是这个类自身，而是这个类对应的https://www.sodocs.net/doc/4d7657027.html,ng.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例（对象）没有关系。

下面这段代码演示了同步块的实现方式：

[java]view plaincopyprint?

1.public void test() {
// 同步锁
String lock = "LOCK";
// 同步块

synchronized (lock) {
// do something
}
int i = 0;
// ...

}

对于作为同步锁的对象并没有什么特别要求，任意一个对象都可以。如果一个对象既有同步方法，又有同步块，那么当其中任意一个同步方法或者同步块被某个线程执行时，这个对象就被锁定了，其他线程无法在此时访问这个对象的同步方法，也不能执行同步块。

synchronized和Lock

Lock是一个接口，它位于Java 5.0新增的java.utils.concurrent包的子包locks中。concurrent包及其子包中的类都是用来处理多线程编程的。实现Lock接口的类具有与synchronized关键字同样的功能，但是它更加强大一些。java.utils.concurrent.locks.ReentrantLock是较常用的实现了Lock接口的类。下面是ReentrantLock类的一个应用实例：

[java]view plaincopyprint?

1.private Lock lock = new ReentrantLock();
public void testLock() {
/

/ 锁定对象

lock.lock();
try {
// do something
} finally {
// 释放对对

象的锁定
lock.unlock();
}
}

lock()方法用于锁定对象，unlock()方法用于释放对对象的锁定，他们都是在Lock接口中定义的方法。位于这两个方法之间的代码在被执行时，效果等同于被放在synchronized同步块中。一般用法是将需要在lock()和unlock()方法之间执行的代码放在try{}块中，并且在finally{}块中调用unlock()方法，这样就可以保证即使在执行代码抛出异常的情况下，对象的锁也总是会被释放，否则的话就会为死锁的产生增加可能。

使用synchronized关键字实现的同步，会把一个对象的所有同步方法和同步块看做一个整体，只要有一个被某个线程调用了，其他的就无法被别的线程执行，即使这些方法或同步块与被调用的代码之间没有任何逻辑关系，这显然降低了程序的运行效率。而使用Lock就能够很好地解决这个问题。我们可以把一个对象中按照逻辑关系把需要同步的方法或代码进行分组，为每个组创建一个Lock类型的对象，对实现同步。那么，当一个同步块被执行时，这个线程只会锁定与当前运行代码相关的其他代码最小集合，而并不影响其他线程对其余同步代码的调用执行。

关于死锁

死锁就是一个进程中的每个线程都在等待这个进程中的其他线程释放所占用的资源，从而导致所有线程都无法继续执行的情况。死锁是多线程编程中一个隐藏的陷阱，它经常发生在多个线程共用资源的时候。在实际开发中，死锁一般隐藏的较深，不容易被发现，一旦死锁现象发生，就必然会导致程序的瘫痪。因此必须避免它的发生。

程序中必须同时满足以下四个条件才会引发死锁：

1.互斥（Mutual exclusion）：线程所使用的资源中至少有一个是不能共享的，它在同一时刻

只能由一个线程使用。

2. 持有与等待（Hold and wait）：至少有一个线程已经持有了资源，并且正在等待获取其他

的线程所持有的资源。

3. 非抢占式（No pre-emption）：如果一个线程已经持有了某个资源，那么在这个线程释放这

个资源之前，别的线程不能把它抢夺过去使用。

4. 循环等待（Circular wait）：假设有N个线程在运行，第一个线程持有了一个资源，并且正

在等待获取第二个线程持有的资源，而第二个线程正在等待获取第三个线程持有的资源，依

此类推……第N个线程正在等待获取第一个线程持有的资源，由此形成一个循环等待。

线程池

线程池就像数据库连接池一样，是一个对象池。所有的对象池都有一个共同的目的，那就是为了提高对象的使用率，从而达到提高程序效率的目的。比如对于Servlet，它被设计为多线程的（如果它是单线程的，你就可以想象，当1000个人同时请求一个网页时，在第一个人获得请求结果之前，其它999个人都在郁闷地等待），如果为每个用户的每一次请求都创建一个新的线程对象来运行的话，系统就会在创建线程和销毁线程上耗费很大的开销，大大降低系统的效率。因此，Servlet多线程机制背后有一个线程池在支持，线程池在初始化初期就创建了一定数量的线程对象，通过提高对这些对象的利用率，避免高频率地创建对象，从而达到提高程序的效率的目的。

下面实现一个最简单的线程池，从中理解它的实现原理。为此我们定义了四个类，它们的用途及具体实现如下：

1.Task（任务）：这是个代表任务的抽象类，其中定义了一个deal()方法，继承Task抽象类

的子类需要实现这个方法，并把这个任务需要完成的具体工作在deal()方法编码实现。线程池

中的线程之所以被创建，就是为了执行各种各样数量繁多的任务的，为了方便线程对任务的

处理，我们需要用Task抽象类来保证任务的具体工作统一放在deal()方法里来完成，这样也

使代码更加规范。

Task的定义如下：

[java]view plaincopyprint?

1.public abstract class Task {
public enum State {
/* 新

建 */NEW, /* 执行中 */RUNNING, /* 已完成 */FINISHED
}
// 任务

状态

private State state = State.NEW;
public void setState(State

state) {
this.state = state;
}
public State getState() {

return state;
}
public abstract void deal();
}

2. TaskQueue（任务队列）：在同一时刻，可能有很多任务需要执行，而程序在同一时刻只能

执行一定数量的任务，当需要执行的任务数超过了程序所能承受的任务数时怎么办呢？这就

有了先执行哪些任务，后执行哪些任务的规则。TaskQueue类就定义了这些规则中的一种，

它采用的是FIFO（先进先出，英文名是First In First Out）的方式，也就是按照任务到达的先

后顺序执行。

TaskQueue类的定义如下：

[java]view plaincopyprint?

1.import java.util.Iterator;
import java.util.LinkedList;
impo

rt java.util.List;
public class TaskQueue {
private List

k> queue = new LinkedList();
// 添加一项任务

public synchronized void addTask(Task task) {
if (task != n

ull) {
queue.add(task);
}
}
// 完成任务后将它从任务队列

中删除

public synchronized void finishTask(Task task) {
if (task !

= null) {
task.setState(Task.State.FINISHED);
queue.remove(t

ask);
}
}
// 取得一项待执行任务

public synchronized Task getTask() {
Iterator it = qu

eue.iterator();
Task task;
while (it.hasNext()) {
task =

it.next();
// 寻找一个新建的任务

if (Task.State.NEW.equals(task.getState())) {
// 把任务状态

置为运行中

task.setState(Task.State.RUNNING);
return task;
}
}

R>return null;
}
}

addTask(Task task)方法用于当一个新的任务到达时，将它添加到任务队列中。这里使用了LinkedList类来保存任务到达的先后顺序。finishTask(Task task)方法用于任务被执行完毕时，将它从任务队列中清除出去。getTask()方法用于取得当前要执行的任务。

3. TaskThread（执行任务的线程）：它继承自Thread类，专门用于执行任务队列中的待执行

任务。

[java]view plaincopyprint?

1.public class TaskThread extends Thread {
// 该线程所属的线程池

private ThreadPoolService service;
public TaskThread(Thread

PoolService tps) {
service = tps;
}
public void run() {

R>// 在线程池运行的状态下执行任务队列中的任务

while (service.isRunning()) {
TaskQueue queue = service.get

TaskQueue();
Task task = queue.getTask();
if (task != null)

{
task.deal();
}
queue.finishTask(task);
}
}
}

4. ThreadPoolService（线程池服务类）：这是线程池最核心的一个类。它在被创建了时候

就创建了几个线程对象，但是这些线程并没有启动运行，但调用了start()方法启动线程池服务

时，它们才真正运行。stop()方法可以停止线程池服务，同时停止池中所有线程的运行。而

runTask(Task task)方法是将一个新的待执行任务交与线程池来运行。

ThreadPoolService类的定义如下：

[java]view plaincopyprint?

1.import java.util.ArrayList;
import java.util.List;
public cl

ass ThreadPoolService {
// 线程数

public static final int THREAD_COUNT = 5;
// 线程池状态

private Status status = Status.NEW;
private TaskQueue queue

= new TaskQueue();
public enum Status {
/* 新

建 */NEW, /* 提供服务中 */RUNNING, /* 停止服

务 */TERMINATED,
}
private List threads = new ArrayL

ist();
public ThreadPoolService() {
for (int i = 0;

i < THREAD_COUNT; i++) {
Thread t = new TaskThread(this);
th

reads.add(t);
}
}
// 启动服务

public void start() {
this.status = Status.RUNNING;
for

(int i = 0; i < THREAD_COUNT; i++) {
threads.get(i).start();

>}
}
// 停止服务

public void stop() {
this.status = Status.TERMINATED;
}<

BR>// 是否正在运行

public boolean isRunning() {
return status == Status.RUNNIN

G;
}
// 执行任务

public void runTask(Task task) {
queue.addTask(task);
}<

BR>protected TaskQueue getTaskQueue() {
return queue;
}
}

完成了上面四个类，我们就实现了一个简单的线程池。现在我们就可以使用它了，下面的代码做了一个简单的示例：

[java]view plaincopyprint?

1.public class SimpleTaskTest extends Task {
@Override
public void de

al() {
// do something
}
public static void main(String[] args)

throws InterruptedException {
ThreadPoolService service = new ThreadPo

olService();
service.start();
// 执行十次任务

for (int i = 0; i < 10; i++) {
service.runTask(new SimpleTaskTest(

));
}
// 睡眠1秒钟，等待所有任务执行完毕

Thread.sleep(1000);
service.stop();
}
}

当然，我们实现的是最简单的，这里只是为了演示线程池的实现原理。在实际应用中，根据情况的不同，可以做很多优化。比如：

?调整任务队列的规则，给任务设置优先级，级别高的任务优先执行。

?动态维护线程池，当待执行任务数量较多时，增加线程的数量，加快任务的执行速度；当任务较少时，回收一部分长期闲置的线程，减少对系统资源的消耗。

事实上Java5.0及以上版本已经为我们提供了线程池功能，无需再重新实现。这些类位于

java.util.concurrent包中。

Executors类提供了一组创建线程池对象的方法，常用的有一下几个：

[java]view plaincopyprint?

1.public static ExecutorService newCachedThreadPool() {
// other code

>}
public static ExecutorService newFixedThreadPool(int nThreads) {

>// other code
}
public static ExecutorService newSingleThreadExecu

tor() {
// other code
}

newCachedThreadPool()方法创建一个动态的线程池，其中线程的数量会根据实际需要来创建和回收，适合于执行大量短期任务的情况；newFixedThreadPool(int nThreads)方法创建一个包含固定数量线程对象的线程池，nThreads代表要创建的线程数，如果某个线程在运行的过程中因为异常而终止了，那么一个新的线程会被创建和启动来代替它；而newSingleThreadExecutor()方法则只在线程池中创建一个线程，来执行所有的任务。

这三个方法都返回了一个ExecutorService类型的对象。实际上，ExecutorService是一个接口，它的submit()方法负责接收任务并交与线程池中的线程去运行。submit()方法能够接受Callable和Runnable两种类型的对象。它们的用法和区别如下：

1.Runnable接口：继承Runnable接口的类要实现它的run()方法，并将执行任务的代码放入

其中，run()方法没有返回值。适合于只做某种操作，不关心运行结果的情况。

2. Callable接口：继承Callable接口的类要实现它的call()方法，并将执行任务的代码放入其

中，call()将任务的执行结果作为返回值。适合于执行某种操作后，需要知道执行结果的情况。

无论是接收Runnable型参数，还是接收Callable型参数的submit()方法，都会返回一个Future（也是一个接口）类型的对象。该对象中包含了任务的执行情况以及结果。调用Future的boolean isDone()方法可以获知任务是否执行完毕；调用Object get()方法可以获得任务执行后的返回结果，如果此时任务还没有执行完，get()方法会保持等待，直到相应的任务执行完毕后，才会将结果返回。

我们用下面的一个例子来演示Java5.0中线程池的使用：

[java]view plaincopyprint?

1.import java.util.concurrent.*;
public class ExecutorTest {
public s

tatic void main(String[] args) throws InterruptedException,
ExecutionE

xception {
ExecutorService es = Executors.newSingleThreadExecutor();

R>Future fr = es.submit(new RunnableTest());// 提交任务

Future fc = es.submit(new CallableTest());// 提交任务
// 取得返回值

并输出
System.out.println((String) fc.get());
// 检查任务是否执行完毕

if (fr.isDone()) {
System.out.println("执行完毕

-RunnableTest.run()");
} else {
System.out.println("未执行完

-RunnableTest.run()");
}
// 检查任务是否执行完毕

if (fc.isDone()) {
System.out.println("执行完毕

-CallableTest.run()");
} else {
System.out.println("未执行完

-CallableTest.run()");
}
// 停止线程池服务

es.shutdown();
}
}
class RunnableTest implements Runnable {<

BR>public void run() {
System.out.println("已经执行

-RunnableTest.run()");
}
}
class CallableTest implements Callabl

e {
public Object call() {
System.out.println("已经执行

-CallableTest.call()");
return "返回值

-CallableTest.call()";
}
}

运行结果：

1.已经执行-RunnableTest.run()

2. 已经执行-CallableTest.call()

3. 返回值-CallableTest.call()

4. 执行完毕-RunnableTest.run()

5. 执行完毕-CallableTest.run()

使用完线程池之后，需要调用它的shutdown()方法停止服务，否则其中的所有线程都会保持运行，程序不会退出。

java多线程面试题

java多线程面试题 1.什么是多线程编程？什么时候使用？ 多线程一般用于当一个程序需要同时做一个以上的任务。多线程通常用于GUI交互程序。一个新的线程被创建做一些耗时的工作，当主线程保持界面与用户的交互。 2.为什么wait(),notify()和notifyall()函数定义在Object类里面? 因为所有类都是继承于Object类，这样所有类就可以简单的进行多线程编程了。 3.wait()方法和sleep()方法有什么不同？ sleep()方法执行后仍然拥有线程，只是延时。而wait方法放弃了线程控制，其它线程可以运行，想要再次运行是要重新开始。 4.Thread和Runnable有什么不同？ JA V A线程控制着程序执行的主路径。当你用java命令调用JVM时，JVM创建了一个隐式线程来执行main方法。Thread类提供了主线程调用其它线程并行运行的机制。 Runnable接口定义了一个能被Thread运行的类。实现Runnable的类只需要实行run方法。可以很灵活的扩展现在的已经继承自其它父类的类。而thread则不可以，因为java 只允许继承一个父类。 Runnable可以共享数据，Thread是一个类，而Runnable是一个接口 5.我可以重载start()方法么？ 可以重载，重载后还要重载run（）方法， 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()

JAVA 面试题总览(书签完整版)

JAVA面试题总览 JAVA基础 1.JAVA中的几种基本数据类型是什么，各自占用多少字节。 2.String类能被继承吗，为什么。 3.String，Stringbuffer，StringBuilder的区别。 4.ArrayList和LinkedList有什么区别。 5.讲讲类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数， 字段，当new的时候，他们的执行顺序。 6.用过哪些Map类，都有什么区别，HashMap是线程安全的吗,并发下使用的Map是什么， 他们内部原理分别是什么，比如存储方式，hashcode，扩容，默认容量等。 7.JAVA8的ConcurrentHashMap为什么放弃了分段锁，有什么问题吗，如果你来设计， 你如何设计。 8.有没有有顺序的Map实现类，如果有，他们是怎么保证有序的。 9.抽象类和接口的区别，类可以继承多个类么，接口可以继承多个接口么,类可以实现多个接 口么。 10.继承和聚合的区别在哪。 11.IO模型有哪些，讲讲你理解的nio，他和bio，aio的区别是啥，谈谈reactor模型。 12.反射的原理，反射创建类实例的三种方式是什么。 13.反射中，Class.forName和ClassLoader区别。 14.描述动态代理的几种实现方式，分别说出相应的优缺点。 15.动态代理与cglib实现的区别。 16.为什么CGlib方式可以对接口实现代理。 17.final的用途。 18.写出三种单例模式实现。 19.如何在父类中为子类自动完成所有的hashcode和equals实现？这么做有何优劣。 20.请结合OO设计理念，谈谈访问修饰符public、private、protected、default在应 用设计中的作用。 21.深拷贝和浅拷贝区别。 22.数组和链表数据结构描述，各自的时间复杂度。 23.error和exception的区别，CheckedException，RuntimeException的区别。 24.请列出5个运行时异常。 25.在自己的代码中，如果创建一个https://www.sodocs.net/doc/4d7657027.html,ng.String类，这个类是否可以被类加载器加 载？为什么。

多线程常见面试题

1)现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完 后执行？ T1.start(); T1.join(); T2.start(); T2.join(); T3.start() 2)11) 为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run() 方法？ start()方法最本质的功能是从CPU中申请另一个线程空间来执行run()方法中的代码,它和当前的线程是两条线,在相对独立的线程空间运行 ,也就是说,如果你直接调用线程对象的run()方法,当然也会执行,但那是在当前线程中执行,run()方法执行完成后继续执行下面的代码.而调用start()方法后,run()方法的代码会和当前线程并发(单CPU)或并行(多CPU)执行。 调用线程对象的run方法不会产生一个新的线程 3)在java中wait和sleep方法的不同？ sleep()睡眠时，保持对象锁，仍然占有该锁； 而wait()睡眠时，释放对象锁。 sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会; sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并木有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。 在sleep()休眠时间期满后，该线程不一定会立即执行，这是因为其它线程可能正在运行而且没有被调度为放弃执行，除非此线程具有更高的优先级。 wait()方法是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问； wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。 wiat()必须放在synchronized block中，否则会在program runtime时扔出”https://www.sodocs.net/doc/4d7657027.html,ng.IllegalMonitorStateException“异常。 4)为什么wait, notify 和notifyAll这些方法不在thread类里面？ 因为这些是关于锁的 而锁是针对对象的 锁用于线程的同步应用 决定当前对象的锁的方法就应该在对象中吧 我是这么理解的希望对你有帮助

精选大厂java多线程面试题50题

Java多线程50题 1)什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。 2)线程和进程有什么区别？ 线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。更多详细信息请点击这里。 3)如何在Java中实现线程？ https://www.sodocs.net/doc/4d7657027.html,ng.Thread类的实例就是一个线程但是它需要调用https://www.sodocs.net/doc/4d7657027.html,ng.Runnable接口来执行，由于线程类本身就是调用的 Runnable接口所以你可以继承https://www.sodocs.net/doc/4d7657027.html,ng.Thread类或者直接调用Runnable接口来重写run()方法实现线程。 4)Thread类中的start()和run()方法有什么区别？ 这个问题经常被问到，但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果不一样。当你

调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，start()方法才会启动新线程。 5)Java中Runnable和Callable有什么不同？ Runnable和Callable都代表那些要在不同的线程中执行的任务。Runnable从JDK1.0开始就有了，Callable是在JDK1.5增加的。它们的主要区别是Callable的call()方法可以返回值和抛出异常，而Runnable的run()方法没有这些功能。Callable可以返回装载有计算结果的Future对象。 6)Java内存模型是什么？ Java内存模型规定和指引Java程序在不同的内存架构、CPU 和操作系统间有确定性地行为。它在多线程的情况下尤其重要。 Java内存模型对一个线程所做的变动能被其它线程可见提供了保证，它们之间是先行发生关系。 ●线程内的代码能够按先后顺序执行，这被称为程序次序 规则。 ●对于同一个锁，一个解锁操作一定要发生在时间上后发 生的另一个锁定操作之前，也叫做管程锁定规则。 ●前一个对Volatile的写操作在后一个volatile的读操作之 前，也叫volatile变量规则。 ●一个线程内的任何操作必需在这个线程的start()调用之 后，也叫作线程启动规则。 ●一个线程的所有操作都会在线程终止之前，线程终止规

15个Java多线程面试题及答案

15个Java多线程面试题及答案 1)现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行? 这个线程问题通常会在第一轮或电话面试阶段被问到，目的是检测你对”join”方法是否熟悉。这个多线程问题比较简单，可以用join方法实现。 2)在Java中Lock接口比synchronized块的优势是什么?你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它? lock接口在多线程和并发编程中最大的优势是它们为读和写分别提 供了锁，它能满足你写像ConcurrentHashMap这样的高性能数据结构和有条件的阻塞。Java线程面试的问题越来越会根据面试者的回答来提问。芯学苑老师强烈建议在你在面试之前认真读一下Locks，因为当前其大量用于构建电子交易终统的客户端缓存和交易连接空间。 3)在java中wait和sleep方法的不同?

通常会在电话面试中经常被问到的Java线程面试问题。最大的不同是在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。 4)用Java实现阻塞队列。 这是一个相对艰难的多线程面试问题，它能达到很多的目的。第一，它可以检测侯选者是否能实际的用Java线程写程序;第二，可以检测侯选者对并发场景的理解，并且你可以根据这个问很多问题。如果他用wait()和notify()方法来实现阻塞队列，你可以要求他用最新的Java 5中的并发类来再写一次。 5)用Java写代码来解决生产者——消费者问题。 与上面的问题很类似，但这个问题更经典，有些时候面试都会问下面的问题。在Java中怎么解决生产者——消费者问题，当然有很多解决方法，我已经分享了一种用阻塞队列实现的方法。有些时候他们甚至会问怎么实现哲学家进餐问题。 6)用Java编程一个会导致死锁的程序，你将怎么解决?

多线程与并发面试题

多线程与并发面试题

JAVA多线程和并发基础面试问答 原文链接译文连接作者：Pankaj 译者：郑旭东校对：方腾飞 多线程和并发问题是Java技术面试中面试官比较喜欢问的问题之一。在这里，从面试的角度列出了大部分重要的问题，可是你依然应该牢固的掌握Java多线程基础知识来对应日后碰到的问题。（校对注：非常赞同这个观点） Java多线程面试问题 1. 进程和线程之间有什么不同？ 一个进程是一个独立(self contained)的运行环境，它能够被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程能够被称为轻量级进程。线程需要较少的资源来创立和驻留在进程中，而且能够共享进程中的资源。 2. 多线程编程的好处是什么？

在多线程程序中，多个线程被并发的执行以提高程序的效率，CPU不会因为某个线程需要等待资源而进入空闲状态。多个线程共享堆内存(heap memory)，因此创立多个线程去执行一些任务会比创立多个进程更好。举个例子，Servlets比CGI更好，是因为Servlets支持多线程而CGI不支持。 3. 用户线程和守护线程有什么区别？ 当我们在Java程序中创立一个线程，它就被称为用户线程。一个守护线程是在后台执行而且不会阻止JVM终止的线程。当没有用户线程在运行的时候，JVM关闭程序而且退出。一个守护线程创立的子线程依然是守护线程。 4. 我们如何创立一个线程？ 有两种创立线程的方法：一是实现Runnable接口，然后将它传递给Thread的构造函数，创立一个Thread对象；二是直接继承Thread类。若想了解更多能够阅读这篇关于如何在Java中创立线程的文章。 5. 有哪些不同的线程生命周期？

2019最新Java面试题,常见面试题及答案汇总

ava最新常见面试题+ 答案汇总 1、面试题模块汇总 面试题包括以下十九个模块：Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 。如下图所示： 可能对于初学者不需要后面的框架和JVM 模块的知识，读者朋友们可根据自己的情况，选择对应的模块进行阅读。 适宜阅读人群 需要面试的初/中/高级java 程序员 想要查漏补缺的人 想要不断完善和扩充自己java 技术栈的人 java 面试官 具体面试题 下面一起来看208 道面试题，具体的内容。 一、Java 基础 1.JDK 和JRE 有什么区别？ 2.== 和equals 的区别是什么？ 3.两个对象的hashCode()相同，则equals()也一定为true，对吗？ 4.final 在java 中有什么作用？ 5.java 中的Math.round(-1.5) 等于多少？ 6.String 属于基础的数据类型吗？ 7.java 中操作字符串都有哪些类？它们之间有什么区别？ 8.String str="i"与String str=new String(“i”)一样吗？ 9.如何将字符串反转？ 10.String 类的常用方法都有那些？ 11.抽象类必须要有抽象方法吗？ 12.普通类和抽象类有哪些区别？ 13.抽象类能使用final 修饰吗？

14.接口和抽象类有什么区别？ 15.java 中IO 流分为几种？ 16.BIO、NIO、AIO 有什么区别？ 17.Files的常用方法都有哪些？ 二、容器 18.java 容器都有哪些？ 19.Collection 和Collections 有什么区别？ 20.List、Set、Map 之间的区别是什么？ 21.HashMap 和Hashtable 有什么区别？ 22.如何决定使用HashMap 还是TreeMap？ 23.说一下HashMap 的实现原理？ 24.说一下HashSet 的实现原理？ 25.ArrayList 和LinkedList 的区别是什么？ 26.如何实现数组和List 之间的转换？ 27.ArrayList 和Vector 的区别是什么？ 28.Array 和ArrayList 有何区别？ 29.在Queue 中poll()和remove()有什么区别？ 30.哪些集合类是线程安全的？ 31.迭代器Iterator 是什么？ 32.Iterator 怎么使用？有什么特点？ 33.Iterator 和ListIterator 有什么区别？ 34.怎么确保一个集合不能被修改？

Java并发编程面试题整理与答案

2019年Java并发面试题整理（答案） 1、多线程的价值？ （1）发挥多核CPU 的优势 多线程，可以真正发挥出多核CPU 的优势来，达到充分利用CPU 的目的，采用多线程的方式去同时完成几件事情而不互相干扰。 （2）防止阻塞 从程序运行效率的角度来看，单核CPU 不但不会发挥出多线程的优势，反而会因为在单核CPU 上运行多线程导致线程上下文的切换，而降低程序整体的效率。但是单核CPU 我们还是要应用多线程，就是为了防止阻塞。试想，如果单核CPU 使用单线程，那么只要这个线程阻塞了，比方说远程读取某个数据吧，对端迟迟未返回又没有设置超时时间，那么你的整个程序在数据返回回来之前就停止运行了。多线程可以防止这个问题，多条线程同时运行，哪怕一条线程的代码执行读取数据阻塞，也不会影响其它任务的执行。 （3）便于建模 这是另外一个没有这么明显的优点了。假设有一个大的任务A，单线程编程，那么就要考虑很多，建立整个程序模型比较麻烦。但是如果把这个大的任务A 分解成几个小任务，任务B、任务C、任务D，分别建立程序模型，并通过多线程分别运行这几个任务，那就简单很多了。 2、实现可见性的方法有哪些？ synchronized 或者Lock：保证同一个时刻只有一个线程获取锁执行代码，锁释放之前把最新的值刷新到主内存，实现可见性。 3、并发编程三要素？ （1）原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。 （2）可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。 （3）有序性 有序性，即程序的执行顺序按照代码的先后顺序来执行。

26. 多线程(04)-生产者和消费者问题、Object类中对线程的支持,以及面试题目

26. 多线程（04） 本季讲解了线程通讯的经典案例，之后又讲解了Object类中对线程的支持，以及面试题目。 blog:[零基础学JAVA]Java SE应用部分-26.多线程（04） 2009-02-19 生产者和消费者问题（1） 生产者和消费者问题（2） class Person{ String name = "张三"; String sex = "男"; // 张三--> 男 // 李四--> 女 } class Pro implements Runnable{ //声明一个共享区域 Person per = null; public Pro(Person p){ this.per = p; } public void run(){ int i = 0; while(true){ if (i==0){

https://www.sodocs.net/doc/4d7657027.html, = "李四"; per.sex = "女"; i=1; }else{ https://www.sodocs.net/doc/4d7657027.html, = "张三"; per.sex = "男"; i =0; } } } } class Cus implements Runnable{ Person per = null; public Cus(Person p){ this.per = p; } public void run(){ while(true){ System.out.println(https://www.sodocs.net/doc/4d7657027.html,+" -->"+per.sex); } } } public class ThreadDemo01{ public static void main(String args[]){ Person per = new Person(); Pro p = new Pro(per); Cus c = new Cus(per); new Thread(p).start(); new Thread(c).start(); } } 看下效果：

多线程面试题

线程或者说多线程，是我们处理多任务的强大工具。线程和进程是不同的，每个进程都是一个独立运行 的程序，拥有自己的变量，且不同进程间的变量不能共享；而线程是运行在进程内部的，每个正在运行的进程至少有一个线程，而且不同的线程之间可以在进程范围内共享数据。也就是说进程有自己独立的存储 空间，而线程是和它所属的进程内的其他线程共享一个存储空间。线程的使用可以使我们能够并行地处理 一些事情。线程通过并行的处理给用户带来更好的使用体验，比如你使用的邮件系统（outlook、Thunderbird、foxmail等），你当然不希望它们在收取新邮件的时候，导致你连已经收下来的邮件都无法阅读，而只能等待收取邮件操作执行完毕。这正是线程的意义所在。 实现线程的方式 实现线程的方式有两种： 1.继承https://www.sodocs.net/doc/4d7657027.html,ng.Thread，并重写它的run()方法，将线程的执行主体放入其中。 2. 实现https://www.sodocs.net/doc/4d7657027.html,ng.Runnable接口，实现它的run()方法，并将线程的执行主体放入其中。 这是继承Thread类实现线程的示例： [java]view plaincopyprint? 1.public class ThreadTest extends Thread {
public void run() {
// 在 这里编写线程执行的主体
// do something
}
} 这是实现Runnable接口实现多线程的示例： [java]view plaincopyprint? 1.public class RunnableTest implements Runnable {
public void run() {
// 在这里编写线程执行的主体
// do something
}
} 这两种实现方式的区别并不大。继承Thread类的方式实现起来较为简单，但是继承它的类就不能再继承 别的类了，因此也就不能继承别的类的有用的方法了。而使用是想Runnable接口的方式就不存在这个问 题了，而且这种实现方式将线程主体和线程对象本身分离开来，逻辑上也较为清晰，所以推荐大家更多地 采用这种方式。 如何启动线程

线程编程方面笔试题

线程编程方面java笔试题 60、java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？ 答：有两种实现方法，分别是继承Thread类与实现Runnable接口 用synchronized关键字修饰同步方法 反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。 61、sleep() 和 wait() 有什么区别? 答：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。 wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。 62、同步和异步有何异同，在什么情况下分别使用他们？举例说明。 答：如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。 当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。 63、启动一个线程是用run()还是start()? 答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。 64、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法? 答：不能，一个对象的一个synchronized方法只能由一个线程访问。 65、请说出你所知道的线程同步的方法。 答：wait():使一个线程处于等待状态，并且释放所持有的对象的lock。 sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉Interrupt edException异常。 notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。 Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。 66、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么? 答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口 同步的实现方面有两种，分别是synchronized,wait与notify

java多线程并发面试题【java多线程和并发基础面试题】

java多线程并发面试题【java多线程和并 发基础面试题】 多线程和并发问题是Java技术面试中面试官比较喜欢问的问题之一。下面就由小编为大家介绍一下java多线程和并发基础面试题的文章，欢迎阅读。 java多线程和并发基础面试题篇1 1. 进程和线程之间有什么不同? 一个进程是一个独立(self contained)的运行环境，它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的来创建和驻留在进程中，并且可以共享进程中的。 2. 多线程编程的好处是什么? 在多线程程序中，多个线程被并发的执行以提高程序的效率，CPU不会因为某个线程需要等待而进入空闲状态。多个线程共享堆内存(heap memory)，因此创建多个线程去执行一些任务会比创建多个进程更好。举个例子，Servlets比CGI更好，是因为Servlets支持多线程而CGI不支持。 3. 用户线程和守护线程有什么区别? 当我们在Java程序中创建一个线程，它就被称为用户线程。一个守护线程是在后台执行并且不会阻止JVM终止的

线程。当没有用户线程在运行的时候，JVM关闭程序并且退出。一个守护线程创建的子线程依然是守护线程。 4. 我们如何创建一个线程? 有两种创建线程的方法：一是实现Runnable接口，然后将它传递给Thread的构造函数，创建一个Thread对象;二是直接继承Thread类。 java多线程和并发基础面试题篇2 1. 有哪些不同的线程生命周期? 当我们在Java程序中新建一个线程时，它的状态是New。当我们调用线程的start()方法时，状态被改变为Runnable。线程调度器会为Runnable线程池中的线程分配CPU时间并且讲它们的状态改变为Running。其他的线程状态还有Waiting，Blocked 和Dead。 2. 可以直接调用Thread类的run()方法么? 当然可以，但是如果我们调用了Thread的run()方法，它的行为就会和普通的方法一样，为了在新的线程中执行我们的代码，必须使用Thread.start()方法。 3. 如何让正在运行的线程暂停一段时间? 我们可以使用Thread类的Sleep()方法让线程暂停一段时间。需要注意的是，这并不会让线程终止，一旦从休眠中唤醒线程，线程的状态将会被改变为Runnable，并且根据线程调度，它将得到执行。

软件工程师面试题 含答案

一、你对MVC的理解，MVC有什么优缺点？结合Struts，说明在一个Web应用如何去使用？ 答： MVC设计模式（应用观察者模式的框架模式） M: Model(Business process layer)，模型，操作数据的业务处理层,并独立于表现层(Independent of presentation)。 V: View(Presentation layer)，视图，通过客户端数据类型显示数据,并回显模型层的执行结果。 C: Controller(Control layer)，控制器，也就是视图层和模型层桥梁，控制数据的流向，接受视图层发出的事件，并重绘视图 MVC框架的一种实现模型 模型二(Servlet-centric)： JSP+Servlet+JavaBean，以控制为核心，JSP只负责显示和收集数据，Sevlet，连接视图和模型，将视图层数据，发送给模型层，JavaBean，分为业务类和数据实体，业务类处理业务数据，数据实体，承载数据，基本上大多数的项目都是使用这种MVC的实现模式。 StrutsMVC框架(Web application frameworks) Struts是使用MVC的实现模式二来实现的，也就是以控制器为核心。 Struts提供了一些组件使用MVC开发应用程序： Model：Struts没有提供model类。这个商业逻辑必须由Web应用程序的开发者以JavaBean或EJB的形式提供 View：Struts提供了action form创建form bean, 用于在controller和view

间传输数据。此外，Struts提供了自定义JSP标签库，辅助开发者用JSP创建交互式的以表单为基础的应用程序，应用程序资源文件保留了一些文本常量和错误消息，可转变为其它语言，可用于JSP中。 Controller：Struts提供了一个核心的控制器ActionServlet，通过这个核心的控制器来调用其他用户注册了的自定义的控制器Action，自定义Action需要符合Struts的自定义Action规范，还需要在struts-config.xml的特定配置文件中进行配置，接收JSP输入字段形成Action form，然后调用一个Action控制器。Action 控制器中提供了model的逻辑接口。 二、什么是WebService？ 答： WebService是一个SOA（面向服务的编程）的架构，它是不依赖于语言，不依赖于平台，可以实现不同的语言间的相互调用，通过Internet进行基于Http协议的网络应用间的交互。 WebService实现不同语言间的调用，是依托于一个标准，webservice是需要遵守WSDL（web服务定义语言）/SOAP（简单请求协议）规范的。 WebService=WSDL+SOAP+UDDI（webservice的注册） Soap是由Soap的part和0个或多个附件组成，一般只有part，在part中有Envelope和Body。 Web Service是通过提供标准的协议和接口，可以让不同的程序集成的一种SOA 架构。 Web Service的优点 (1) 可以让异构的程序相互访问（跨平台）

多线程面试题

或者说多线程，是我们处理多任务的强大。线程和进程是不同的，每个进程都是一个独立运行的，拥有自己的变量，且不同进程间的变量不能共享；而线程是运行在进程内部的，每个正在运行的进程至少有一个线程，而且不同的线程之间可以在进程范围内共享数据。也就是说进程有自己独立的存储空间，而线程是和它所属的进程内的其他线程共享一个存储空间。线程的使用可以使我们能够并行地处理一些事情。线程通过并行的处理给用户带来更好的使用体验，比如你使用的邮件（、、等），你当然不希望它们在收取新邮件的时候，导致你连已经收下来的邮件都无法阅读，而只能等待收取邮件操作执行完毕。这正是线程的意义所在。 实现线程的方式 实现线程的方式有两种： 1.继承，并重写它的()方法，将线程的执行主体放入其中。 2. 实现接口，实现它的()方法，并将线程的执行主体放入其中。 这是继承类实现线程的示例： [] 1.{<> () {<> 在这里编写线程执行的主体 <> <>}<>}

{ () { 在这里编写线程执行的主体 } } 这是实现接口实现多线程的示例： [] 1.{<> () {<> 在这里编写线程执行的主体 <> <>}<>} { () { 在这里编写线程执行的主体 } } 这两种实现方式的区别并不大。继承类的方式实现起来较为简单，但是继承它的类就不能再继承别的类了，因此也就不能继承别的类的有用的方法了。而使用是想接口的方式就不存在这个问题了，而且这种实现方式将线程主体和线程对象本身分离开来，逻辑上也较为清晰，所以推荐大家更多地采用这种方式。

如何启动线程 我们通过以上两种方式实现了一个线程之后，线程的实例并没有被创建，因此它们也并没有被运行。我们要启动一个线程，必须调用方法来启动它，这个方法就是类的()方法，而不是()方法（既不是我们继承类重写的()方法，也不是实现接口的()方法）。()方法中包含的是线程的主体，也就是这个线程被启动后将要运行的代码，它跟线程的启动没有任何关系。上面两种实现线程的方式在启动时会有所不同。 继承类的启动方式： [] 1.{<> ([] ) {<> 创建一个线程实例 <> = ();<> 启动线程<>();<>}<>} { ([] ) { 创建一个线程实例 = (); 启动线程 (); }

JAVA多线程(面试)

JAVA多线程，面试者的最爱 多线程 线程：是指进程中的一个执行流程。 线程与进程的区别：每个进程都需要操作系统为其分配独立的内存地址空间，而同一进程中的所有线程在同一块地址空间中工作，这些线程可以共享同一块内存和系统资源。 如何创建一个线程？ 创建线程有两种方式，如下： 1、扩展https://www.sodocs.net/doc/4d7657027.html,ng.Thread类 2、实现Runnable接口 Thread类代表线程类，它的两个最主要的方法是： run()——包含线程运行时所执行的代码 Start()——用于启动线程 一个线程只能被启动一次。第二次启动时将会抛出https://www.sodocs.net/doc/4d7657027.html,ng.IllegalThreadExcetpion异常 线程间状态的转换（如图示） 新建状态：用new语句创建的线程对象处于新建状态，此时它和其它的java对象一样，仅仅在堆中被分配了内存 就绪状态：当一个线程创建了以后，其他的线程调用了它的start()方法，该线程就进入了就绪状态。处于这个状态的线程位于可运行池中，等待获得CPU的使用权 运行状态：处于这个状态的线程占用CPU,执行程序的代码 阻塞状态：当线程处于阻塞状态时，java虚拟机不会给线程分配CPU，直到线程重新进入就绪状态，它才有机会转到运行状态。 阻塞状态分为三种情况： 1、位于对象等待池中的阻塞状态：当线程运行时，如果执行了某个对象的wait()方法，java 虚拟机就回把线程放到这个对象的等待池中 2、位于对象锁中的阻塞状态，当线程处于运行状态时，试图获得某个对象的同步锁时，如果该对象的同步锁已经被其他的线程占用，JVM就会把这个线程放到这个对象的琐池中。 3、其它的阻塞状态：当前线程执行了sleep()方法，或者调用了其它线程的join()方法，或者发出了I/O请求时，就会进入这个状态中。 死亡状态：当线程退出了run()方法，就进入了死亡状态，该线程结束了生命周期。 或者正常退出 或者遇到异常退出 Thread类的isAlive()方法判断一个线程是否活着，当线程处于死亡状态或者新建状态时，该方法返回false,在其余的状态下，该方法返回true.

关于多线程的相关面试题

1.线程与进程的区别 线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。 2.多线程的实现方式？有什么区别 3种实现方式，JDK1.5之后，第三种不常用。这里介绍两种。 启动线程的唯一方法就是通过Thread类的start()方法启动一个新线程，并执行run()方法。 方式1：继承Thread类 public class MyThread extends Thread { public void run() { System.out.println("MyThread.run()"); } } 然后在合适的地方启动线程： MyThread myThread1 = new MyThread(); MyThread myThread2 = new MyThread(); //实例化2次 myThread1.start(); myThread2.start(); 方法2：实现Runnable接口 如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口。 public class MyThread extends OtherClass implements Runnable { public void run() { System.out.println("MyThread.run()"); } } 为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：MyThread myThread = new MyThread(); //只实例化1次 Thread thread1 = new Thread(myThread); Thread thread 2= new Thread(myThread); thread1.start(); thread2.start(); 两者区别： a.Thread是Runnable接口的子类，实现Runnable接口的方式解决了Java单继承的局 限。因为一个类只能继承1个，如果已经继承了1个，就无法extends Thread。而可以实现多个接口，这时候可以用Runnable来完成多线程。 b.Runnable接口实现多线程比继承Thread类更加能描述数据共享的概念。 继承Thread类必须如果产生Runnable实例对象，就必须产生多个Runnable实例对象，然后再用Thread产生多个线程；而实现Runnable接口，只需要建立一个实现这个类的实例，然后用这一个实例对象产生多个线程。即实现了资源的共享性。 比如： 类1： public class Thread_1 implements Runnable {

秒杀多线程系列

秒杀多线程 系列

目录 系列前言 (2) 秒杀多线程第一篇多线程笔试面试题汇总 (2) 一．概念性问答题 (2) 二．选择题 (3) 三．综合题 (3) 秒杀多线程第二篇多线程第一次亲密接触 CreateThread与_beginthreadex本质区别 (4) 秒杀多线程第三篇原子操作 Interlocked系列函数 (12) 秒杀多线程第四篇一个经典的多线程同步问题 (17) 秒杀多线程第五篇经典线程同步关键段CS (20) 秒杀多线程第六篇经典线程同步事件Event (25) 秒杀多线程第七篇经典线程同步互斥量Mutex (32) 秒杀多线程第八篇经典线程同步信号量Semaphore (38) 秒杀多线程第九篇经典线程同步总结关键段事件互斥量信号量 (42) 秒杀多线程第十篇生产者消费者问题 (44) 秒杀多线程第十一篇读者写者问题 (52) 秒杀多线程第十二篇多线程同步内功心法——PV操作上 (58) 秒杀多线程第十四篇读者写者问题继读写锁SRWLock (61)

本系列是本人参加微软亚洲研究院，腾讯研究院，迅雷面试时整理的，另外也加入一些其它IT公司如百度，阿里巴巴的笔试面试题目，因此具有很强的针对性。系列中不但会详细讲解多线程同步互斥的各种“招式”，而且会进一步的讲解多线程同步互斥的“内功心法”。有了“招式”和“内功心法”，相信你也能对多线程挥洒自如，在笔试面试中顺 利的秒杀多线程试题。 秒杀多线程第一篇多线程笔试面试题汇总 多线程在笔试面试中经常出现，下面列出一些公司的多线程笔试面试题。首先是一些概念性的问答题，这些是多线程的基础知识，经常出现在面试中的第一轮面试（我参加2011年腾讯研究院实习生招聘时就被问到了几个概念性题目）。然后是一些选择题，这些一般在笔试时出现，虽然不是太难，但如果在选择题上花费大多时间无疑会对后面的编程题造成影响，因此必须迅速的解决掉。最后是综合题即难一些的问答题或是编程题。这种题目当然是最难解决了，要么会引来面试官的追问，要么就很容易考虑不周全，因此解决这类题目时一定要考虑全面和细致。 下面就来看看这三类题目吧。 一．概念性问答题 第一题：线程的基本概念、线程的基本状态及状态之间的关系？ 第二题：线程与进程的区别？ 这个题目问到的概率相当大，计算机专业考研中也常常考到。要想全部答出比较难。第三题：多线程有几种实现方法，都是什么？ 第四题：多线程同步和互斥有几种实现方法，都是什么？ 我在参加2011年迅雷校园招聘时的一面和二面都被问到这个题目，回答的好将会给面试成绩加不少分。 第五题：多线程同步和互斥有何异同，在什么情况下分别使用他们？举例说明。

JAVA基础面试题(经典)

基础知识部分： 1. JDK是什么？JRE是什么？ a) 答：JDK：java开发工具包。JRE：java运行时环境。 2. 什么是java的平台无关性？ a) 答：Java源文件被编译成字节码的形式，无论在什么系统环境下，只要有java虚拟机就能运行这个字节码文件。也就是一处编写，处处运行。这就是java的跨平台性。 3. 在一台电脑上配置java环境，path起什么作用？如何配置？ a) 答：path的作用是在DOS环境下，能在任意位置使用JD K目录中bin文件夹中的可执行程序，来编译执行java程序。 b) 在环境变量中找到path变量，把bin文件夹的绝对路径加上即可。

4. 什么样的标识符是合法的？ a) 由字母、数字、_和$组成，长度不限。其中字母可以是大写或小写的英文字母，数字为0到9。 b) 标识符的第一个字符不能是数字。 c) 标识符区分大小写。 d) 标识符不能包含空格。 5. Java有几种基本数据类型？ a) byte，short，int，long，float，double，char，bool ean 6. 什么是隐式类型转换？什么是显示类型转换？ a) 当将占位数少的类型赋值给占位数多的类型时，Java自动使用隐式类型转换。

b) 当把在级别高的变量的值赋给级别底变量时，必须使用显示类型转换运算。 7. &&和&区别，||和|区别？ a) &&和||是短路与，短路或，当左边的表达式能判断当前结果，则不判断右边的表达式。 b) 而& 和|则将两边的表达式都运算完毕后，再算结果。 8. break，continue区别？ a) break结束所有循环，continue结束当次循环，进入下次循环。 9. 类的命名规则是什么？ a) 如果类名使用拉丁字母，那么名字的首写字母使用大写字母。