# 概念

进程进程(Process)计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。在早期面向进程设计的计算机结构中,进程是程序的基本执行实体;在当代面向线程设计的计算机结构中,进程是线程的容器。程序是指令、数据及其组织形式的描述,进程是程序的实体


线程:线程是进程中的一个执行单元,负责当前进程中程序的执行,线程是 cpu 调度和执行的单位,每个线程拥有独立的运行栈和程序计数器(pc)

线程的生命周期:

说明
  • 新建状态:

    使用 new 关键字和 Thread 类或其子类建立一个线程对象后,该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。

  • 就绪状态:

    当线程对象调用了 start () 方法之后,该线程就进入就绪状态。就绪状态的线程处于就绪队列中,要等待 JVM 里线程调度器的调度。

  • 运行状态:

    如果就绪状态的线程获取 CPU 资源,就可以执行 run(),此时线程便处于运行状态。处于运行状态的线程最为复杂,它可以变为阻塞状态、就绪状态和死亡状态。

  • 阻塞状态:

    如果一个线程执行了 sleep(睡眠)、suspend(挂起)等方法,失去所占用资源之后,该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种:

    • 等待阻塞:运行状态中的线程执行 wait () 方法,使线程进入到等待阻塞状态。
    • 同步阻塞:线程在获取 synchronized 同步锁失败 (因为同步锁被其他线程占用)。
    • 其他阻塞:通过调用线程的 sleep () 或 join () 发出了 I/O 请求时,线程就会进入到阻塞状态。当 sleep () 状态超时,join () 等待线程终止或超时,或者 I/O 处理完毕,线程重新转入就绪状态。
  • 死亡状态:

    一个运行状态的线程完成任务或者其他终止条件发生时,该线程就切换到终止状态。

图片和文字说明来自菜鸟教程


Java 线程分类:用户线程和守护线程

  • Java 的垃圾回收线程就是一个守护线程
  • 守护线程是用来服务用户线程的,在 start()前调用 thread.setDarmon (true) 可以把一个用户线程变成一个守护线程
说明

守护进程(Daemon)是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件,也就是说守护线程不依赖于终端,但是依赖于系统,与系统 “同生共死”。

用户线程可以理解为是系统的工作线程,它会完成这个程序需要完成的业务操作。如果用户线程全部结束了,意味着程序需要完成的业务操作已经结束了,系统可以退出了。所以当系统只剩下守护进程的时候,java 虚拟机会自动退出

线程的 daemon 属性为 true 表示是守护线程,false 表示是用户线程。


并行和并发

  • 并行:多个 CPU 同时执行多个任务
  • 并发:一个 CPU 同时执行多个任务(使用时间片运行)

当程序需要同时执行两个或者多个任务的、需要实现一些等待的任务、需要运行后台任务的时候就需要多线程。

有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如:程序中有两个子系统需要并发执行,这时候就需要利用多线程编程。

通过对多线程的使用,可以编写出非常高效的程序。不过请注意,如果你创建太多的线程,程序执行的效率实际上是降低了,而不是提升了。上下文的切换开销也很重要,如果创建了太多的线程,CPU 花费在上下文的切换的时间将多于执行程序的时间!


# 多线程的创建

# 方法一:继承 Thread

  1. 先创建一个继承 Thread 类的子类。
  2. 重写 Thread 类的 run () 方法。
  3. 创建 Thread 类的子类对象。
  4. 调用对象的 start () 方法来启动一个线程。
Thread
public class extends_thread extends Thread {
    @Override
    // 线程体,启动线程时会运行 run () 方法中的代码
    public void run() {
        System.out.println("hello wold");
    }
    public static void main(String[] args) {
        // 创建一个 Thread 类对象 (extends_thread 继承了 Thread 类,向上转型)
        Thread t1 = new extends_thread();
        // 通过此对象调用 start () 启动一个线程
        t1.start();
        // 注意:已经启动过一次的线程无法再次启动
        // 再创建一个线程
        extends_thread t2 = new extends_thread();
        t2.start();
        // 另一种调用方法,此方法并没有给对象命名
        new extends_thread().start();
        System.out.println("主线程");
        new Thread1().start();
        new Thread2().start();
        // 也可以通过匿名对象来实现创建
        new Thread(){
            @Override
            public void run() {
                System.out.println("Hi");
            }
        }.start();
    }
}
class Thread1 extends Thread {
    @Override
    public void run() {
        System.out.println("Thread1");
    }
}
class Thread2 extends Thread {
    @Override
    public void run() {
        System.out.println("Thread2");
    }
}

# 方法二:使用实现 Runnable 接口来创建

  1. 创建一个实现 Runnable 接口的类。
  2. 实现抽象方法 run ()。
  3. 创建实现类对象。
  4. 将实现类对象作为参数传入 Thread 类构造器中。
  5. 调用 Thread 类的 start () 方法。
实现Runnable
class realization_Runnable{
    public static void main(String[] args) {
        // 创建实现类的对象
        ImplementsRunnable implementsRunnable = new ImplementsRunnable();
        // 创建 Thread 类的对象,并将实现类对象作为参数传入
        Thread t1 = new Thread(implementsRunnable);
        // 使用 Thread 类的对象去调用 start () 方法
        // 启动线程 Thread 的 run () 调用 Runnable 的 run ()
        t1.start();
        // 使用匿名类来创建线程
        new Thread(new ImplementsRunnable()).start();
    }
}
// 此类实现 Runnable 接口
class ImplementsRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("实现Runnable来创建线程");
    }
}

# 方法三:实现 Callable 接口

  1. 创建实现 Callable 接口的实现类,并实现 call () 方法,call () 方法将作为线程的执行体,并有返回值。
  2. 创建该实现类的对象,将此对象作为参数传入 FutureTask,FutureTask 对象封装了 call () 方法的返回值。
  3. 使用 FutureTask 对象作为参数传入 Thread 并启动线程。
  4. 调用 FutureTask 的 get () 方法来获得子线程执行结束后的返回值。
实现Callable接口
public class realization_Callable implements Callable {
    @Override
    public Object call() throws Exception {
        int i = 0;
        for (; i < 10; i++) {
            System.out.print(i + "  ");
        }
        return i;
    }
    public static void main(String[] args) {
        realization_Callable cll = new realization_Callable();
        FutureTask<Integer> ft = new FutureTask<>(cll);
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " 的循环变量i的值" + i);
            if (i == 20) {
                // (FutureTask 对象,名称)
                new Thread(ft, "有返回值的线程").start();
            }
        }
        try {
            System.out.println("子线程的返回值:" + ft.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch(ExecutionException e){
			e.printStackTrace();
        }
    }
}

# 以上三种创建线程的方法对比

  1. 采用实现 Runnable、Callable 接口的方式来创建多线程时,线程类只是实现了 Runnable 或者 Callable 接口,还可以继承其他类
继承其他类
class A{}
class B extends A implements Callable{
    public Object call throws Exception{
        .....
    }
    ....
}
// 同理 Runnable 接口也是
  1. 使用继承 Thread 类来创建多线程,编程简单,但是需要写多线程的类本身有父类时,就不可以继承 Thread 类来实现多线程了,但是一个类可以实现多个接口,因此实现用实现接口的方式来实现多线程更加实用。
  2. 实现接口的方式具有共享数据的特性 (不使用 static)。继承的实现方法需要创建多个子类对象来实现多进程,假设子类中有变量 A,如果不使用 static 约束,那么每个子类对象都会有自己的 A 变量,只有使用 static 约束,所有的子类对象才共享变量 A,而接口方式,只需要创建一个实现类对象,将实现类对象作为参数传入 Thread,创建多个线程实际上只是调用了一个实现类对象所以实现接口的方式更加适合处理多个线程有共享数据的情况
  3. 两种接口实现多线程,Callable 功能更丰富,它的 call () 可以有返回值,方法可以抛出异常,也支持泛型的返回值,但是需要借助 FutureTask 类。

# 方法四:线程池

Java 线程池 | YH's Blog (liyhil.com)

# 收藏的线程面试题

收藏
  1. 什么是线程?

    线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位。程序员可以通过它进行多处理器编程,你可以使用多线程对运算密集型任务提速。比如,如果一个线程完成一个任务要 100 毫秒,那么用十个线程完成该任务只需 10 毫秒。

  1. 线程和进程有什么区别?

    一个进程是一个独立 (self contained) 的运行环境,它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。线程是进程的子集,一个进程可以有很多线程,每条线程并行执行不同的任务。不同的进程使用不同的内存空间,而所有的线程共享一片相同的内存空间。别把它和栈内存搞混,每个线程都拥有单独的栈内存用来存储本地数据。

  2. 如何在 Java 中实现线程?

    有两种创建线程的方法:一是实现 Runnable 接口,然后将它传递给 Thread 的构造函数,创建一个 Thread 对象;二是直接继承 Thread 类。

  3. 用 Runnable 还是 Thread?

    这个问题是上题的后续,大家都知道我们可以通过继承 Thread 类或者调用 Runnable 接口来实现线程,问题是,那个方法更好呢?什么情况下使用它?这个问题很容易回答,如果你知道 Java 不支持类的多重继承,但允许你调用多个接口。所以如果你要继承其他类,当然是调用 Runnable 接口好了。更多详细信息请点击这里。

  4. Thread 类中的 start () 和 run () 方法有什么区别?

    start () 方法被用来启动新创建的线程,使该被创建的线程状态变为可运行状态。当你调用 run () 方法的时候,只会是在原来的线程中调用,没有新的线程启动,start () 方法才会启动新线程。如果我们调用了 Thread 的 run () 方法,它的行为就会和普通的方法一样,直接运行 run()方法。为了在新的线程中执行我们的代码,必须使用 Thread.start () 方法。

  5. Java 中 Runnable 和 Callable 有什么不同?

    Runnable 和 Callable 都代表那些要在不同的线程中执行的任务。Runnable 从 JDK1.0 开始就有了,Callable 是在 JDK1.5 增加的。它们的主要区别是 Callable 的 call () 方法可以返回值和抛出异常,而 Runnable 的 run () 方法没有这些功能。Callable 可以返回装载有计算结果的 Future 对象。

  6. Java 中 CyclicBarrier 和 CountDownLatch 有什么不同?

    CyclicBarrier 和 CountDownLatch 都可以用来让一组线程等待其它线程。与 CyclicBarrier 不同的是,CountdownLatch 不能重新使用。

  7. Java 内存模型是什么?

    Java 内存模型规定和指引 Java 程序在不同的内存架构、CPU 和操作系统间有确定性地行为。它在多线程的情况下尤其重要。Java 内存模型对一个线程所做的变动能被其它线程可见提供了保证,它们之间是先行发生关系。这个关系定义了一些规则让程序员在并发编程时思路更清晰。比如,先行发生关系确保了:

    • 线程内的代码能够按先后顺序执行,这被称为程序次序规则。

    • 对于同一个锁,一个解锁操作一定要发生在时间上后发生的另一个锁定操作之前,也叫做管程锁定规则。

    • 前一个对 volatile 的写操作在后一个 volatile 的读操作之前,也叫 volatile 变量规则。

    • 一个线程内的任何操作必需在这个线程的 start () 调用之后,也叫作线程启动规则。

    • 一个线程的所有操作都会在线程终止之前,线程终止规则。

    • 一个对象的终结操作必需在这个对象构造完成之后,也叫对象终结规则。

    • 可传递性

  8. Java 中的 volatile 变量是什么?

    volatile 是一个特殊的修饰符,只有成员变量才能使用它。在 Java 并发程序缺少同步类的情况下,多线程对成员变量的操作对其它线程是透明的。volatile 变量可以保证下一个读取操作会在前一个写操作之后发生。线程都会直接从内存中读取该变量并且不缓存它。这就确保了线程读取到的变量是同内存中是一致的。

  9. 什么是线程安全?Vector 是一个线程安全类吗?

    如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的。一个线程安全的计数器类的同一个实例对象在被多个线程使用的情况下也不会出现计算失误。很显然你可以将集合类分成两组,线程安全和非线程安全的。Vector 是用同步方法来实现线程安全的,而和它相似的 ArrayList 不是线程安全的。

  10. Java 中什么是竞态条件?

    在大多数实际的多线程应用中,两个或两个以上的线程需要共享对同一数据的存取。如果 i 线程存取相同的对象,并且每一个线程都调用了一个修改该对象状态的方法,将会发生什么呢?可以想象,线程彼此踩了对方的脚。根据线程访问数据的次序,可能会产生讹误的对象。这样的情况通常称为竞争条件。

  11. Java 中如何停止一个线程?

    Java 提供了很丰富的 API 但没有为停止线程提供 API。JDK 1.0 本来有一些像 stop (), suspend () 和 resume () 的控制方法,但是由于潜在的死锁威胁。因此在后续的 JDK 版本中他们被弃用了,之后 Java API 的设计者就没有提供一个兼容且线程安全的方法来停止一个线程。当 run () 或者 call () 方法执行完的时候线程会自动结束,如果要手动结束一个线程,可以用 volatile 布尔变量来退出 run () 方法的循环或者是取消任务来中断线程。

  12. 一个线程运行时发生异常会怎样?

    如果异常没有被捕获该线程将会停止执行。Thread.UncaughtExceptionHandler 是用于处理未捕获异常造成线程突然中断情况的一个内嵌接口。当一个未捕获异常将造成线程中断的时候 JVM 会使用 Thread.getUncaughtExceptionHandler () 来查询线程的 UncaughtExceptionHandler 并将线程和异常作为参数传递给 handler 的 uncaughtException () 方法进行处理。

  1. 如何在两个线程间共享数据?

    你可以通过共享对象来实现这个目的,或者是使用像阻塞队列这样并发的数据结构。这篇教程《Java 线程间通信》(涉及到在两个线程间共享对象) 用 wait 和 notify 方法实现了生产者消费者模型。

  1. Java 中 notify 和 notifyAll 有什么区别?

    这又是一个刁钻的问题,因为多线程可以等待单监控锁,Java API 的设计人员提供了一些方法当等待条件改变的时候通知它们,但是这些方法没有完全实现。notify () 方法不能唤醒某个具体的线程,所以只有一个线程在等待的时候它才有用武之地。而 notifyAll () 唤醒所有线程并允许他们争夺锁确保了至少有一个线程能继续运行。

  2. 为什么 wait, notify 和 notifyAll 这些方法不在 thread 类里面?

    一个很明显的原因是 JAVA 提供的锁是对象级的而不是线程级的,每个对象都有锁,通过线程获得。如果线程需要等待某些锁那么调用对象中的 wait () 方法就有意义了。如果 wait () 方法定义在 Thread 类中,线程正在等待的是哪个锁就不明显了。简单的说,由于 wait,notify 和 notifyAll 都是锁级别的操作,所以把他们定义在 Object 类中因为锁属于对象。

  3. 什么是 ThreadLocal 变量?

    ThreadLocal 是 Java 里一种特殊的变量。每个线程都有一个 ThreadLocal 就是每个线程都拥有了自己独立的一个变量,竞争条件被彻底消除了。如果为每个线程提供一个自己独有的变量拷贝,将大大提高效率。首先,通过复用减少了代价高昂的对象的创建个数。其次,你在没有使用高代价的同步或者不变性的情况下获得了线程安全。

  4. 什么是 FutureTask?

    在 Java 并发程序中 FutureTask 表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回运算结果等方法。只有当运算完成的时候结果才能取回,如果运算尚未完成 get 方法将会阻塞。一个 FutureTask 对象可以对调用了 Callable 和 Runnable 的对象进行包装,由于 FutureTask 也是调用了 Runnable 接口所以它可以提交给 Executor 来执行。

  5. Java 中 interrupted 和 isInterruptedd 方法的区别?

    interrupted () 和 isInterrupted () 的主要区别是前者会将中断状态清除而后者不会。Java 多线程的中断机制是用内部标识来实现的,调用 Thread.interrupt () 来中断一个线程就会设置中断标识为 true。当中断线程调用静态方法 Thread.interrupted () 来检查中断状态时,中断状态会被清零。而非静态方法 isInterrupted () 用来查询其它线程的中断状态且不会改变中断状态标识。简单的说就是任何抛出 InterruptedException 异常的方法都会将中断状态清零。无论如何,一个线程的中断状态有有可能被其它线程调用中断来改变。

  6. 为什么 wait 和 notify 方法要在同步块中调用?

    当一个线程需要调用对象的 wait () 方法的时候,这个线程必须拥有该对象的锁,接着它就会释放这个对象锁并进入等待状态直到其他线程调用这个对象上的 notify () 方法。同样的,当一个线程需要调用对象的 notify () 方法时,它会释放这个对象的锁,以便其他在等待的线程就可以得到这个对象锁。由于所有的这些方法都需要线程持有对象的锁,这样就只能通过同步来实现,所以他们只能在同步方法或者同步块中被调用。如果你不这么做,代码会抛出 IllegalMonitorStateException 异常。

  7. 为什么你应该在循环中检查等待条件?

    处于等待状态的线程可能会收到错误警报和伪唤醒,如果不在循环中检查等待条件,程序就会在没有满足结束条件的情况下退出。因此,当一个等待线程醒来时,不能认为它原来的等待状态仍然是有效的,在 notify () 方法调用之后和等待线程醒来之前这段时间它可能会改变。这就是在循环中使用 wait () 方法效果更好的原因,你可以在 Eclipse 中创建模板调用 wait 和 notify 试一试。如果你想了解更多关于这个问题的内容,推荐你阅读《Effective Java》这本书中的线程和同步章节。

  8. Java 中的同步集合与并发集合有什么区别?

    同步集合与并发集合都为多线程和并发提供了合适的线程安全的集合,不过并发集合的可扩展性更高。在 Java1.5 之前程序员们只有同步集合来用且在多线程并发的时候会导致争用,阻碍了系统的扩展性。Java5 介绍了并发集合像 ConcurrentHashMap,不仅提供线程安全还用锁分离和内部分区等现代技术提高了可扩展性。更多内容详见答案。

  1. Java 中堆和栈有什么不同?

    为什么把这个问题归类在多线程和并发面试题里?因为栈是一块和线程紧密相关的内存区域。每个线程都有自己的栈内存,用于存储本地变量,方法参数和栈调用,一个线程中存储的变量对其它线程是不可见的。而堆是所有线程共享的一片公用内存区域。对象都在堆里创建,为了提升效率线程会从堆中弄一个缓存到自己的栈,如果多个线程使用该变量就可能引发问题,这时 volatile 变量就可以发挥作用了,它要求线程从主存中读取变量的值。

  2. 什么是线程池? 为什么要使用它?

    创建线程要花费昂贵的资源和时间,如果任务来了才创建线程那么响应时间会变长,而且一个进程能创建的线程数有限。为了避免这些问题,在程序启动的时候就创建若干线程来响应处理,它们被称为线程池,里面的线程叫工作线程。从 JDK1.5 开始,Java API 提供了 Executor 框架让你可以创建不同的线程池。比如单线程池,每次处理一个任务;数目固定的线程池或者是缓存线程池(一个适合很多生存期短的任务的程序的可扩展线程池)。

  3. 如何写代码来解决生产者消费者问题?

    在现实中你解决的许多线程问题都属于生产者消费者模型,就是一个线程生产任务供其它线程进行消费,你必须知道怎么进行线程间通信来解决这个问题。比较低级的办法是用 wait 和 notify 来解决这个问题,比较赞的办法是用 Semaphore 或者 BlockingQueue 来实现生产者消费者模型。

  4. 如何避免死锁?

    Java 多线程中的死锁,死锁是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。这是一个严重的问题,因为死锁会让你的程序挂起无法完成任务,死锁的发生必须满足以下四个条件:

    • 互斥条件:一个资源每次只能被一个进程使用。

    • 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。

    • 不剥夺条件:进程已获得的资源,在末使用完之前,不能强行剥夺。

    • 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

避免死锁最简单的方法就是阻止循环等待条件,将系统中所有的资源设置标志位、排序,规定所有的进程申请资源必须以一定的顺序(升序或降序)做操作来避免死锁。

  1. Java 中活锁和死锁有什么区别?

    这是上题的扩展,活锁和死锁类似,不同之处在于处于活锁的线程或进程的状态是不断改变的,活锁可以认为是一种特殊的饥饿。一个现实的活锁例子是两个人在狭小的走廊碰到,两个人都试着避让对方好让彼此通过,但是因为避让的方向都一样导致最后谁都不能通过走廊。简单的说就是,活锁和死锁的主要区别是前者进程的状态可以改变但是却不能继续执行。

  1. 怎么检测一个线程是否拥有锁?

    在 java.lang.Thread 中有一个方法叫 holdsLock (),它返回 true 如果当且仅当当前线程拥有某个具体对象的锁。

  1. 你如何在 Java 中获取线程堆栈?

    对于不同的操作系统,有多种方法来获得 Java 进程的线程堆栈。当你获取线程堆栈时,JVM 会把所有线程的状态存到日志文件或者输出到控制台。在 Windows 你可以使用 Ctrl + Break 组合键来获取线程堆栈,Linux 下用 kill -3 命令。你也可以用 jstack 这个工具来获取,它对线程 id 进行操作,你可以用 jps 这个工具找到 id。

  2. JVM 中哪个参数是用来控制线程的栈堆栈小的

    这个问题很简单, -Xss 参数用来控制线程的堆栈大小。你可以查看 JVM 配置列表来了解这个参数的更多信息。

  1. Java 中 synchronized 和 ReentrantLock 有什么不同?

    Java 在过去很长一段时间只能通过 synchronized 关键字来实现互斥,它有一些缺点。比如你不能扩展锁之外的方法或者块边界,尝试获取锁时不能中途取消等。Java 5 通过 Lock 接口提供了更复杂的控制来解决这些问题。 ReentrantLock 类实现了 Lock,它拥有与 synchronized 相同的并发性和内存语义且它还具有可扩展性。

  2. 有三个线程 T1,T2,T3,怎么确保它们按顺序执行(确保 main () 方法所在的线程是 Java 程序最后结束的线程)?

    在多线程中有多种方法让线程按特定顺序执行,你可以用线程类的 join () 方法在一个线程中启动另一个线程,另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动最后一个 (T3 调用 T2,T2 调用 T1),这样 T1 就会先完成而 T3 最后完成。

  1. Thread 类中的 yield 方法有什么作用?

    yield 方法可以暂停当前正在执行的线程对象,让其它有相同优先级的线程执行。它是一个静态方法而且只保证当前线程放弃 CPU 占用而不能保证使其它线程一定能占用 CPU,执行 yield () 的线程有可能在进入到暂停状态后马上又被执行。点击这里查看更多 yield 方法的相关内容。

  1. Java 中 ConcurrentHashMap 的并发度是什么?

    ConcurrentHashMap 把实际 map 划分成若干部分来实现它的可扩展性和线程安全。这种划分是使用并发度获得的,它是 ConcurrentHashMap 类构造函数的一个可选参数,默认值为 16,这样在多线程情况下就能避免争用。

  2. Java 中 Semaphore 是什么?

    Java 中的 Semaphore 是一种新的同步类,它是一个计数信号。从概念上讲,从概念上讲,信号量维护了一个许可集合。如有必要,在许可可用前会阻塞每一个 acquire (),然后再获取该许可。每个 release () 添加一个许可,从而可能释放一个正在阻塞的获取者。但是,不使用实际的许可对象,Semaphore 只对可用许可的号码进行计数,并采取相应的行动。信号量常常用于多线程的代码中,比如数据库连接池。更多详细信息请点击这里。

  3. 如果你提交任务时,线程池队列已满。会时发会生什么?

    这个问题问得很狡猾,许多程序员会认为该任务会阻塞直到线程池队列有空位。事实上如果一个任务不能被调度执行那么 ThreadPoolExecutor’s submit () 方法将会抛出一个 RejectedExecutionException 异常。

  1. Java 线程池中 submit () 和 execute () 方法有什么区别?

    两个方法都可以向线程池提交任务,execute () 方法的返回类型是 void,它定义在 Executor 接口中,而 submit () 方法可以返回持有计算结果的 Future 对象,它定义在 ExecutorService 接口中,它扩展了 Executor 接口,其它线程池类像 ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 都有这些方法。更多详细信息请点击这里。

  2. 什么是阻塞式方法?

    阻塞式方法是指程序会一直等待该方法完成期间不做其他事情,ServerSocket 的 accept () 方法就是一直等待客户端连接。这里的阻塞是指调用结果返回之前,当前线程会被挂起,直到得到结果之后才会返回。此外,还有异步和非阻塞式方法在任务完成前就返回。更多详细信息请点击这里。

  1. 你对线程优先级的理解是什么?

    每一个线程都是有优先级的,一般来说,高优先级的线程在运行时会具有优先权,但这依赖于线程调度的实现,这个实现是和操作系统相关的 (OS dependent)。我们可以定义线程的优先级,但是这并不能保证高优先级的线程会在低优先级的线程前执行。线程优先级是一个 int 变量 (从 1-10),1 代表最低优先级,10 代表最高优先级。

  2. 什么是线程调度器 (Thread Scheduler) 和时间分片 (Time Slicing)?

    线程调度器是一个操作系统服务,它负责为 Runnable 状态的线程分配 CPU 时间。一旦我们创建一个线程并启动它,它的执行便依赖于线程调度器的实现。时间分片是指将可用的 CPU 时间分配给可用的 Runnable 线程的过程。分配 CPU 时间可以基于线程优先级或者线程等待的时间。线程调度并不受到 Java 虚拟机控制,所以由应用程序来控制它是更好的选择(也就是说不要让你的程序依赖于线程的优先级)。

  3. 在多线程中,什么是上下文切换 (context-switching)?

    上下文切换是存储和恢复 CPU 状态的过程,它使得线程执行能够从中断点恢复执行。上下文切换是多任务操作系统和多线程环境的基本特征。

  1. 如何在 Java 中创建 Immutable 对象?

    Immutable 对象可以在没有同步的情况下共享,降低了对该对象进行并发访问时的同步化开销。要创建不可变类,要实现下面几个步骤:通过构造方法初始化所有成员、对变量不要提供 setter 方法、将所有的成员声明为私有的,这样就不允许直接访问这些成员、在 getter 方法中,不要直接返回对象本身,而是克隆对象,并返回对象的拷贝。

  1. Java 中的 ReadWriteLock 是什么?

    一般而言,读写锁是用来提升并发程序性能的锁分离技术的成果。Java 中的 ReadWriteLock 是 Java 5 中新增的一个接口,一个 ReadWriteLock 维护一对关联的锁,一个用于只读操作一个用于写。在没有写线程的情况下一个读锁可能会同时被多个读线程持有。写锁是独占的,你可以使用 JDK 中的 ReentrantReadWriteLock 来实现这个规则,它最多支持 65535 个写锁和 65535 个读锁。

  1. 多线程中的忙循环是什么?

    忙循环就是程序员用循环让一个线程等待,不像传统方法 wait (), sleep () 或 yield () 它们都放弃了 CPU 控制,而忙循环不会放弃 CPU,它就是在运行一个空循环。这么做的目的是为了保留 CPU 缓存,在多核系统中,一个等待线程醒来的时候可能会在另一个内核运行,这样会重建缓存。为了避免重建缓存和减少等待重建的时间就可以使用它了。

  1. volatile 变量和 atomic 变量有什么不同?

    这是个有趣的问题。首先,volatile 变量和 atomic 变量看起来很像,但功能却不一样。Volatile 变量可以确保先行关系,即写操作会发生在后续的读操作之前,但它并不能保证原子性。例如用 volatile 修饰 count 变量那么 count++ 操作就不是原子性的。而 AtomicInteger 类提供的 atomic 方法可以让这种操作具有原子性如 getAndIncrement () 方法会原子性的进行增量操作把当前值加一,其它数据类型和引用变量也可以进行相似操作。

  1. 如果同步块内的线程抛出异常会发生什么?

    这个问题坑了很多 Java 程序员,若你能想到锁是否释放这条线索来回答还有点希望答对。无论你的同步块是正常还是异常退出的,里面的线程都会释放锁,所以对比锁接口我们更喜欢同步块,因为它不用花费精力去释放锁,该功能可以在 finally block 里释放锁实现。

  1. 单例模式的双检锁是什么?

    这个问题在 Java 面试中经常被问到,但是面试官对回答此问题的满意度仅为 50%。一半的人写不出双检锁还有一半的人说不出它的隐患和 Java1.5 是如何对它修正的。它其实是一个用来创建线程安全的单例的老方法,当单例实例第一次被创建时它试图用单个锁进行性能优化,但是由于太过于复杂在 JDK1.4 中它是失败的。

  2. 如何在 Java 中创建线程安全的 Singleton?

    这是上面那个问题的后续,如果你不喜欢双检锁而面试官问了创建 Singleton 类的替代方法,你可以利用 JVM 的类加载和静态变量初始化特征来创建 Singleton 实例,或者是利用枚举类型来创建 Singleton。

  1. 写出 3 条你遵循的多线程最佳实践

以下三条最佳实践大多数 Java 程序员都应该遵循:

  • 给你的线程起个有意义的名字。

这样可以方便找 bug 或追踪。OrderProcessor, QuoteProcessor or TradeProcessor 这种名字比 Thread-1. Thread-2 and Thread-3 好多了,给线程起一个和它要完成的任务相关的名字,所有的主要框架甚至 JDK 都遵循这个最佳实践。

  • 避免锁定和缩小同步的范围

锁花费的代价高昂且上下文切换更耗费时间空间,试试最低限度的使用同步和锁,缩小临界区。因此相对于同步方法我更喜欢同步块,它给我拥有对锁的绝对控制权。

  • 多用同步类少用 wait 和 notify

首先,CountDownLatch, Semaphore, CyclicBarrier 和 Exchanger 这些同步类简化了编码操作,而用 wait 和 notify 很难实现对复杂控制流的控制。其次,这些类是由最好的企业编写和维护在后续的 JDK 中它们还会不断优化和完善,使用这些更高等级的同步工具你的程序可以不费吹灰之力获得优化。

  • 多用并发集合少用同步集合

这是另外一个容易遵循且受益巨大的最佳实践,并发集合比同步集合的可扩展性更好,所以在并发编程时使用并发集合效果更好。如果下一次你需要用到 map,你应该首先想到用 ConcurrentHashMap。

  1. 如何强制启动一个线程?

    这个问题就像是如何强制进行 Java 垃圾回收,目前还没有觉得方法,虽然你可以使用 System.gc () 来进行垃圾回收,但是不保证能成功。在 Java 里面没有办法强制启动一个线程,它是被线程调度器控制着且 Java 没有公布相关的 API。

  2. Java 中的 fork join 框架是什么?

    fork join 框架是 JDK7 中出现的一款高效的工具,Java 开发人员可以通过它充分利用现代服务器上的多处理器。它是专门为了那些可以递归划分成许多子模块设计的,目的是将所有可用的处理能力用来提升程序的性能。fork join 框架一个巨大的优势是它使用了工作窃取算法,可以完成更多任务的工作线程可以从其它线程中窃取任务来执行。

  1. Java 多线程中调用 wait () 和 sleep () 方法有什么不同?

    Java 程序中 wait 和 sleep 都会造成某种形式的暂停,它们可以满足不同的需要。wait () 方法用于线程间通信,如果等待条件为真且其它线程被唤醒时它会释放锁,而 sleep () 方法仅仅释放 CPU 资源或者让当前线程停止执行一段时间,但不会释放锁。需要注意的是,sleep()并不会让线程终止,一旦从休眠中唤醒线程,线程的状态将会被改变为 Runnable,并且根据线程调度,它将得到执行。

  2. 什么是 Thread Group?为什么不建议使用它?

    ThreadGroup 是一个类,它的目的是提供关于线程组的信息。

    ThreadGroup API 比较薄弱,它并没有比 Thread 提供了更多的功能。它有两个主要的功能:一是获取线程组中处于活跃状态线程的列表;二是设置为线程设置未捕获异常处理器 (ncaught exception handler)。但在 Java 1.5 中 Thread 类也添加了 setUncaughtExceptionHandler (UncaughtExceptionHandler eh) 方法,所以 ThreadGroup 是已经过时的,不建议继续使用。

  1. 什么是 Java 线程转储 (Thread Dump),如何得到它?

    线程转储是一个 JVM 活动线程的列表,它对于分析系统瓶颈和死锁非常有用。有很多方法可以获取线程转储 —— 使用 Profiler,Kill -3 命令,jstack 工具等等。我们更喜欢 jstack 工具,因为它容易使用并且是 JDK 自带的。由于它是一个基于终端的工具,所以我们可以编写一些脚本去定时的产生线程转储以待分析。

  2. 什么是 Java Timer 类?如何创建一个有特定时间间隔的任务?

    java.util.Timer 是一个工具类,可以用于安排一个线程在未来的某个特定时间执行。Timer 类可以用安排一次性任务或者周期任务。

    java.util.TimerTask 是一个实现了 Runnable 接口的抽象类,我们需要去继承这个类来创建我们自己的定时任务并使用 Timer 去安排它的执行。

  3. 什么是原子操作?在 Java Concurrency API 中有哪些原子类 (atomic classes)?

    原子操作是指一个不受其他操作影响的操作任务单元。原子操作是在多线程环境下避免数据不一致必须的手段。

    int++ 并不是一个原子操作,所以当一个线程读取它的值并加 1 时,另外一个线程有可能会读到之前的值,这就会引发错误。

    在 java.util.concurrent.atomic 包中添加原子变量类之后,这种情况才发生了改变。所有原子变量类都公开比较并设置原语(与比较并交换类似),这些原语都是使用平台上可用的最快本机结构(比较并交换、加载链接 / 条件存储,最坏的情况下是旋转锁)来实现的。 java.util.concurrent.atomic 包中提供了原子变量的 9 种风格( AtomicInteger; AtomicLong; AtomicReference; AtomicBoolean;原子整型;长型;引用;及原子标记引用和戳记引用类的数组形式,其原子地更新一对值)。

  1. Java Concurrency API 中的 Lock 接口 (Lock interface) 是什么?对比同步它有什么优势?

    Lock 接口比同步方法和同步块提供了更具扩展性的锁操作。他们允许更灵活的结构,可以具有完全不同的性质,并且可以支持多个相关类的条件对象。

    它的优势有:

    • 可以使锁更公平

    • 可以使线程在等待锁的时候响应中断

    • 可以让线程尝试获取锁,并在无法获取锁的时候立即返回或者等待一段时间

    • 可以在不同的范围,以不同的顺序获取和释放锁

  2. 什么是 Executor 框架?

    Executor 框架同 java.util.concurrent.Executor 接口在 Java 5 中被引入。Executor 框架是一个根据一组执行策略调用,调度,执行和控制的异步任务的框架。

    无限制的创建线程会引起应用程序内存溢出。所以创建一个线程池是个更好的的解决方案,因为可以限制线程的 11 数量并且可以回收再利用这些线程。利用 Executor 框架可以非常方便的创建一个线程池。

  3. Executors 类是什么?

    Executors 为 Executor,ExecutorService,ScheduledExecutorService,ThreadFactory 和 Callable 类提供了一些工具方法。

    Executors 可以用于方便的创建线程池。

  4. 什么是阻塞队列?如何使用阻塞队列来实现生产者 - 消费者模型?

    java.util.concurrent.BlockingQueue 的特性是:当队列是空的时,从队列中获取或删除元素的操作将会被阻塞,或者当队列是满时,往队列里添加元素的操作会被阻塞。

    阻塞队列不接受空值,当你尝试向队列中添加空值的时候,它会抛出 NullPointerException。

    阻塞队列的实现都是线程安全的,所有的查询方法都是原子的并且使用了内部锁或者其他形式的并发控制。

    BlockingQueue 接口是 java collections 框架的一部分,它主要用于实现生产者 - 消费者问题。

  5. 什么是 Callable 和 Future?

    Java 5 在 concurrency 包中引入了 java.util.concurrent.Callable 接口,它和 Runnable 接口很相似,但它可以返回一个对象或者抛出一个异常。

    Callable 接口使用泛型去定义它的返回类型。Executors 类提供了一些有用的方法去在线程池中执行 Callable 内的任务。由于 Callable 任务是并行的,我们必须等待它返回的结果。java.util.concurrent.Future 对象为我们解决了这个问题。在线程池提交 Callable 任务后返回了一个 Future 对象,使用它我们可以知道 Callable 任务的状态和得到 Callable 返回的执行结果。Future 提供了 get () 方法让我们可以等待 Callable 结束并获取它的执行结果。

  6. 什么是 FutureTask?

    FutureTask 包装器是一种非常便利的机制,可将 Callable 转换成 Future 和 Runnable,它同时实现两者的接口。

    FutureTask 类是 Future 的一个实现,并实现了 Runnable,所以可通过 Excutor (线程池) 来执行。也可传递给 Thread 对象执行。如果在主线程中需要执行比较耗时的操作时,但又不想阻塞主线程时,可以把这些作业交给 Future 对象在后台完成,当主线程将来需要时,就可以通过 Future 对象获得后台作业的计算结果或者执行状态。

  7. 什么是并发容器的实现?

    Java 集合类都是快速失败的,这就意味着当集合被改变且一个线程在使用迭代器遍历集合的时候,迭代器的 next () 方法将抛出 ConcurrentModificationException 异常。

    并发容器:并发容器是针对多个线程并发访问设计的,在 jdk5.0 引入了 concurrent 包,其中提供了很多并发容器,如 ConcurrentHashMap,CopyOnWriteArrayList 等。并发容器使用了与同步容器完全不同的加锁策略来提供更高的并发性和伸缩性,例如在 ConcurrentHashMap 中采用了一种粒度更细的加锁机制,可以称为分段锁,在这种锁机制下,允许任意数量的读线程并发地访问 map,并且执行读操作的线程和写操作的线程也可以并发的访问 map,同时允许一定数量的写操作线程并发地修改 map,所以它可以在并发环境下实现更高的吞吐量。

  8. 用户线程和守护线程有什么区别?

    当我们在 Java 程序中创建一个线程,它就被称为用户线程。一个守护线程是在后台执行并且不会阻止 JVM 终止的线程。当没有用户线程在运行的时候,JVM 关闭程序并且退出。一个守护线程创建的子线程依然是守护线程。

  9. 有哪些不同的线程生命周期?

    当我们在 Java 程序中新建一个线程时,它的状态是 New。当我们调用线程的 start () 方法时,状态被改变为 Runnable。线程调度器会为 Runnable 线程池中的线程分配 CPU 时间并且讲它们的状态改变为 Running。其他的线程状态还有 Waiting,Blocked 和 Dead。

  10. 线程之间是如何通信的?

    当线程间是可以共享资源时,线程间通信是协调它们的重要的手段。Object 类中 wait ()\notify ()\notifyAll () 方法可以用于线程间通信关于资源的锁的状态。

  11. 为什么 Thread 类的 sleep () 和 yield () 方法是静态的?

    Thread 类的 sleep () 和 yield () 方法将在当前正在执行的线程上运行。所以在其他处于等待状态的线程上调用这些方法是没有意义的。这就是为什么这些方法是静态的。它们可以在当前正在执行的线程中工作,并避免程序员错误的认为可以在其他非运行线程调用这些方法。

  12. 如何确保线程安全?

    在 Java 中可以有很多方法来保证线程安全 —— 同步,使用原子类 (atomic concurrent classes),实现并发锁,使用 volatile 关键字,使用不变类和线程安全类。

  13. 同步方法和同步块,哪个是更好的选择?

    同步块是更好的选择,因为它不会锁住整个对象(当然你也可以让它锁住整个对象)。同步方法会锁住整个对象,哪怕这个类中有多个不相关联的同步块,这通常会导致他们停止执行并需要等待获得这个对象上的锁。

  14. 如何创建守护线程?

    使用 Thread 类的 setDaemon (true) 方法可以将线程设置为守护线程,需要注意的是,需要在调用 start () 方法前调用这个方法,否则会抛出 IllegalThreadStateException 异常。

  15. 线程调度策略?

  • 抢占式调度策略:Java 运行时系统的线程调度算法是抢占式的 (preemptive)。Java 运行时系统支持一种简单的固定优先级的调度算法。如果一个优先级比其他任何处于可运行状态的线程都高的线程进入就绪状态,那么运行时系统就会选择该线程运行。新的优先级较高的线程抢占 (preempt) 了其他线程。但是 Java 运行时系统并不抢占同优先级的线程。换句话说,Java 运行时系统不是分时的 (time-slice)。然而,基于 Java Thread 类的实现系统可能是支持分时的,因此编写代码时不要依赖分时。当系统中的处于就绪状态的线程都具有相同优先级时,线程调度程序采用一种简单的、非抢占式的轮转的调度顺序。
  • 时间片轮转调度策略:有些系统的线程调度采用时间片轮转 (round-robin) 调度策略。这种调度策略是从所有处于就绪状态的线程中选择优先级最高的线程分配一定的 CPU 时间运行。该时间过后再选择其他线程运行。只有当线程运行结束、放弃 (yield) CPU 或由于某种原因进入阻塞状态,低优先级的线程才有机会执行。如果有两个优先级相同的线程都在等待 CPU,则调度程序以轮转的方式选择运行的线程。
  1. 在线程中你怎么处理不可捕捉异常?

    Thread.UncaughtExceptionHandler 是 java SE5 中的新接口,它允许我们在每一个 Thread 对象上添加一个异常处理器。

收藏自:Tanyboye 的博客 - CSDN 博客