Java面试题五

一、谈谈你对Java内存模型（JVM Memory Model）的理解。

Java内存模型（Java Memory Model，简称JMM）是Java虚拟机（JVM）规范中定义的一种关于内存访问、共享变量在多线程之间的可见性、以及原子性、顺序性的规则。以下是对Java内存模型的详细理解：

一、内存模型概述

Java内存模型描述的是一组规则或规范，这组规范定义了程序中各个变量（包括实例字段、静态字段和构成数组对象的元素）的访问方式。由于JVM运行程序的实体是线程，每个线程在创建时JVM都会为其创建一个工作内存（也称为本地内存或线程栈），用于存储线程私有的数据。而Java内存模型中规定所有变量都存储在主内存中，主内存是共享内存区域，所有线程都可以访问。但线程对变量的操作（读取、赋值等）必须在工作内存中进行，不能直接操作主内存中的变量。

二、主内存与工作内存

• 主内存：所有线程共享的内存区域，包含了对象的字段、方法和运行时常量池等数据。这是Java堆的一部分，用于存储Java实例对象。
• 工作内存：每个线程拥有自己的工作内存，工作内存中保存了主内存中变量的副本，线程对变量的所有操作（读取、写入）都在工作内存中进行。工作内存是线程私有的数据区域，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成。

三、三大特性

Java内存模型围绕三大特性展开，即原子性、可见性和有序性。

• 原子性：一个或多个操作，要么全部执行，要么全部不执行（执行的过程中是不会被任何因素打断的）。Java内存模型通过lock和unlock操作来保证原子性，同时提供了synchronized关键字和Lock接口等机制来实现。
• 可见性：一个线程对共享变量的修改，能够被其他线程看到。Java内存模型通过volatile关键字和synchronized来保证可见性。当一个线程修改了volatile变量的值，新值对于其他线程来说是立即可见的。同时，synchronized也可以确保线程在进入同步块或同步方法时，能够看到最新的变量值。
• 有序性：程序的执行顺序按照代码的先后顺序执行。然而，由于编译器的优化和指令集的重排序，Java程序在并发执行时可能会出现乱序执行的情况。Java内存模型通过Happens-Before规则来定义操作之间的偏序关系，从而允许编译器和处理器对指令进行重排序，但同时又保证程序最终执行的结果与按照Happens-Before关系规定的顺序执行的结果一致。

四、Happens-Before规则

Happens-Before是Java内存模型中最核心的概念之一，它定义了一组偏序关系，用于判断两个操作之间的内存可见性和有序性。主要包括以下规则：

• 程序次序规则：一个线程中的每个操作，Happens-Before于该线程中的任意后续操作。
• 监视器锁规则：对一个锁的解锁，Happens-Before于随后对这个锁的加锁。
• volatile变量规则：对一个volatile变量的写，Happens-Before于任意后续对这个volatile变量的读。
• 传递性：如果A Happens-Before B，且B Happens-Before C，那么A Happens-Before C。
• 线程启动规则：Thread对象的start()方法调用Happens-Before于该线程的每一个动作。
• 线程终止规则：线程的所有操作都Happens-Before于其他线程检测到这个线程已经终止、或者从该线程的join()方法调用返回、或者从该线程的Thread.isAlive()方法的返回值为false。
• 线程中断规则：对线程interrupt()方法的调用Happens-Before于被中断线程的代码检测到中断事件的发生。
• 最终结束规则：对象的构造函数执行、结束Happens-Before于它的finalize()方法的开始。

五、总结

Java内存模型是一种抽象的规范，它定义了线程和主内存之间的抽象关系，以及共享变量的访问规则。通过保证原子性、可见性和有序性，Java内存模型为程序员提供了一致的内存访问语义，使得多线程程序的行为可预测、可理解。同时，Java内存模型还提供了一系列的同步机制（如volatile关键字、synchronized关键字、Lock接口等），以帮助开发者编写正确和高效的多线程代码。

综上所述，Java内存模型是Java并发编程中的重要概念，理解并掌握它对于编写高效、正确的多线程程序至关重要。

二、Java中如何创建一个线程？有哪些实现方式？

在Java中，线程的创建有多种实现方式，以下是四种主要的方法：

一、继承Thread类

1. 步骤：

   • 定义一个Thread类的子类，并重写其run()方法。run()方法包含线程要执行的业务逻辑。
   • 创建Thread子类的实例。
   • 调用该实例的start()方法来启动线程。

2. 示例代码：

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " from MyThread");
    }
}

public class MyThreadTest {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

二、实现Runnable接口

1. 步骤：

   • 定义一个Runnable接口的实现类，并重写其run()方法。
   • 创建Runnable实现类的实例。
   • 使用该实例作为target创建Thread对象。
   • 调用Thread对象的start()方法来启动线程。

2. 示例代码：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " from MyRunnable");
    }
}

public class MyRunnableTest {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

三、使用Callable和Future

1. 步骤：

   • 创建一个实现Callable接口的类，并实现其call()方法。call()方法可以有返回值，并且可以声明抛出异常。
   • 使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值。
   • 使用FutureTask对象作为Thread对象的target创建并启动线程。
   • 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

2. 示例代码：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " from MyCallable");
        return 99;
    }
}

public class MyCallableTest {
    public static void main(String[] args) {
        FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(futureTask);
        thread.start();
        
        try {
            Thread.sleep(1000); // 等待线程执行完成
            System.out.println("返回的结果是: " + futureTask.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

四、使用线程池

1. 步骤：

   • 使用Executors工厂类创建线程池，返回的线程池实现了ExecutorService接口。
   • 提交Runnable或Callable任务给线程池执行。
   • 关闭线程池（通常使用shutdown()方法）。

2. 示例代码（使用newSingleThreadExecutor创建一个单线程执行器）：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " from MyRunnable");
    }
}

public class SingleThreadExecutorTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        MyRunnable myRunnable = new MyRunnable();
        
        for (int i = 0; i < 10; i++) {
            executorService.execute(myRunnable);
        }
        
        System.out.println("=======任务开始=======");
        executorService.shutdown();
    }
}

五、方法对比与选择

• 继承Thread类：简单直观，但Java只支持单继承，如果类已经继承了其他类，则无法再继承Thread。
• 实现Runnable接口：避免单继承的限制，更加灵活。Runnable接口还可以被共享，即多个线程可以共享一个Runnable实现类的实例。
• 使用Callable和Future：比Runnable接口更强大，因为call()方法有返回值并且可以抛出异常。适用于需要返回结果的任务。
• 使用线程池：提高性能，减少线程创建和销毁的开销。线程池还可以管理线程的并发数量和生命周期。

在选择线程创建方式时，应根据具体的应用场景和需求来决定。例如，对于简单的任务，可以直接继承Thread类或实现Runnable接口；对于需要返回结果的任务，可以使用Callable和Future；对于需要高性能和线程管理的场景，则应该使用线程池。