当前位置：首页 > news >正文

Java知识总结（持续更新）

news 文章来源：https://blog.csdn.net/qq_33371766/article/details/132787688 2024/11/26 5:30:42

一、JDK、JRE、JVM三者之间的关系？

1. **JDK (Java Development Kit)**：
JDK 是 Java 开发工具包，它包含了用于开发 Java 应用程序的所有必要工具和库。这包括 Java 编译器（javac）、Java 核心类库、开发工具（如调试器和监视器工具）以及其他一些实用工具。如果您希望编写、编译和运行 Java 程序，您需要安装 JDK。
2. **JRE (Java Runtime Environment)**：
JRE 是 Java 运行时环境，它包括 Java 虚拟机（JVM）和 Java 核心类库。JRE 的主要作用是使您能够运行已经编译好的 Java 应用程序。如果您只想运行 Java 应用程序而不进行开发，那么安装 JRE 就足够了。
3. **JVM (Java Virtual Machine)**：
JVM 是 Java 虚拟机，它是 Java 应用程序的运行环境。JVM 负责将 Java 字节码翻译成特定计算机架构的机器代码，并执行 Java 程序。每个 Java 应用程序在 JVM 中运行，它提供了跨平台的能力，使得相同的 Java 应用程序可以在不同操作系统上运行。
简而言之，JDK 包含了开发 Java 应用程序所需的工具，JRE 包含了运行 Java 应用程序所需的环境，而 JVM 是 Java 应用程序的执行引擎。这三者之间的关系是 JDK 包含 JRE，而 JRE 包含 JVM。

二、Java中创建对象的几种方式？

1. **使用 `new` 关键字**：
这是最常见的创建对象的方式。使用new关键字后跟构造函数来创建一个新的对象实例。例如：

 MyClass obj = new MyClass();

2. **使用工厂方法**：
某些类提供了静态工厂方法，用于创建对象。这种方法可以隐藏对象的创建细节。例如：

 Calendar cal = Calendar.getInstance(); // 使用工厂方法创建 Calendar 对象

3. **使用反射**：
Java 反射允许在运行时动态地创建对象，即使您不知道对象的确切类型。您可以使用 `Class` 类的 `newInstance` 方法来创建对象。但请注意，反射可能会导致性能下降和安全性问题，因此应谨慎使用。

Class<?> myClass = Class.forName("com.example.MyClass");Object obj = myClass.newInstance();

4. **使用克隆**：
如果一个类实现了 `Cloneable` 接口，您可以使用 `clone` 方法创建对象的副本。这被称为浅拷贝，因为它只复制对象的字段，而不会复制字段引用的对象。

 MyClass originalObj = new MyClass();MyClass clonedObj = (MyClass) originalObj.clone();

5. **使用序列化和反序列化**：
您可以通过将对象序列化为字节流，然后反序列化来创建对象的副本。这种方法允许在不同的 Java 虚拟机之间传输对象，或者将对象保存到文件中并从文件中还原。

// 序列化对象ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.ser"));oos.writeObject(originalObj);oos.close();// 反序列化对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.ser"));MyClass newObj = (MyClass) ois.readObject();ois.close();

三、 final、finally、finalize的区别

1. **final**关键字：用于修饰类、方法、变量、入参和对象

应用于类时，表示该类是最终类，不能被其他类继承。
应用于方法时，表示该方法时最终方法，不能被其他类继承。
应用于变量时，表示该变量时一个常量，只能赋值一次。
应用于入参时，表示该入参在方法内无法被修改。
应用于对象时，该对象的引用不能被修改，但对象本身的状态是可以改变的。

示例：

final class FinalClass {// ...}class SubClass extends FinalClass { // 这是非法的，无法继承 final 类// ...}public void exampleMethod(final int value) {// value 是一个常量，不能在方法内部修改}

2. **finally**关键字：异常处理机制中的一部分，用于定义在try-catch-finally块中的finally块
- 无论是否发生异常，`finally` 块中的代码都会被执行，通常用于释放资源或执行清理操作。

示例：

 try {// 可能会引发异常的代码} catch (Exception e) {// 处理异常} finally {// 无论是否发生异常，都会执行这里的代码// 通常用于关闭文件、释放资源等操作}

3. **finalize**：是一个方法，它是 `java.lang.Object` 类中定义的一个方法。

在垃圾回收器将对象回首之前调用。
可以重写finalize方法，在其中编写对象在被回收钱需要进行的清理操作，如释放资源等。
请注意，不推荐使用finalize方法进行内存资源的释放，它没有被及时执行的保证，也可能导致性能问题。

总结：
- `final` 用于声明不可变的类、方法或变量。
- `finally` 用于与异常处理 (`try-catch`) 结构一起，确保代码块中的代码无论是否发生异常都会被执行。
- `finalize` 是一个过时的方法，用于在垃圾回收前执行对象的清理操作，不建议使用，现代 Java 有更好的垃圾回收方式。

四、==和equals的区别？

在 Java 中，`==` 和 `equals` 是两个用于比较对象的操作符，它们具有不同的作用和用途：

1. **`==` 操作符**：

`==` 用于比较两个对象的引用是否相同，即它们是否指向内存中的同一对象。
当使用 `==` 来比较基本数据类型（如 `int`、`double`）时，它比较的是值是否相等。
对于引用类型（对象），`==` 比较的是两个引用变量是否指向同一个对象，而不考虑对象的内容。

示例：

String str1 = new String("Hello");String str2 = new String("Hello");System.out.println(str1 == str2); // false，因为它们是不同的对象

2. **`equals` 方法**：比较是否是同一个对象，equals方法存在于object类中，而object类时所有类直接或者间接的父类，在没有重写equals方法的类中，和==一样比较引用类型所只想的对象地址是否相等。重写equals方法就看各个类重写后的逻辑，比如String类，虽然是引用类型，但是String类重写了equals方法，方法内部比较的是字符串中的各个字符是否去哪不相等。

`equals` 是一个方法，通常需要被重写以实现自定义的对象比较逻辑。在 `java.lang.Object` 类中，`equals` 方法默认行为与 `==` 相同，即比较对象的引用。
通常，您应该在自定义类中重写 `equals` 方法，以根据对象的内容（属性值）来比较它们是否相等。

示例：

 class Person {private String name;private int age;// 自定义 equals 方法，比较对象的属性值@Overridepublic boolean equals(Object obj) {if (this == obj) {return true; // 同一对象}if (obj == null || getClass() != obj.getClass()) {return false; // 类型不同}Person person = (Person) obj;return age == person.age && Objects.equals(name, person.name);}}Person person1 = new Person("Alice", 30);Person person2 = new Person("Alice", 30);System.out.println(person1.equals(person2)); // true，因为属性值相同

总结：

`==` 操作符用于比较对象的引用，检查它们是否指向同一个内存位置。
`equals` 方法用于比较对象的内容，通常需要在自定义类中重写以实现属性值的比较。默认情况下，`equals` 方法在 `java.lang.Object` 中的行为与 `==` 相同。

五、两个对象的hashCode相同，则equals也一定为true吗？

两个对象的hashCode相同，equals不一定为true；

两个对象的equals相同，则两个对象的hashCode一定为true；

六、&和&& 、 | 和 || 的区别？

1. **`&` 和 `&&`（逻辑与）**：

`&` 和 `&&` 都用于执行逻辑与操作，即在两个条件都为 `true` 时返回 `true`。
主要区别在于短路性（short-circuiting behavior）：
`&` 是非短路操作，它会对两个条件都进行求值，无论第一个条件的结果如何。
`&&` 是短路操作，它只在第一个条件为 `true` 时才会继续求值第二个条件，如果第一个条件为 `false`，则不会继续求值第二个条件。

示例：

 boolean condition1 = false;boolean condition2 = true;// 对于 &，两个条件都会被求值，然后返回 falseboolean result1 = condition1 & condition2; // result1 为 false// 对于 &&，由于第一个条件为 false，第二个条件不会被求值，直接返回 falseboolean result2 = condition1 && condition2; // result2 为 false

2. **`|` 和 `||`（逻辑或）**：

`|` 和 `||` 都用于执行逻辑或操作，即在两个条件中至少一个为 `true` 时返回 `true`。
主要区别同样在于短路性：
`|` 是非短路操作，它会对两个条件都进行求值，无论第一个条件的结果如何。
`||` 是短路操作，它只在第一个条件为 `true` 时才会继续求值第二个条件，如果第一个条件为 `true`，则不会继续求值第二个条件。

示例：

 boolean condition1 = true;boolean condition2 = false;// 对于 |，两个条件都会被求值，然后返回 trueboolean result1 = condition1 | condition2; // result1 为 true// 对于 ||，由于第一个条件为 true，第二个条件不会被求值，直接返回 trueboolean result2 = condition1 || condition2; // result2 为 true

总结：

`&` 和 `|` 是非短路逻辑操作符，它们会对两个条件都进行求值。
`&&` 和 `||` 是短路逻辑操作符，它们在满足条件的情况下不会继续求值第二个条件。
通常情况下，建议使用 `&&` 和 `||` 来执行逻辑操作，因为它们具有短路性，可以提高性能并避免不必要的计算。

七、Java中的参数传递时传值呢？还是传引用？

在 Java 中，参数传递是按值传递（pass-by-value），而不是按引用传递（pass-by-reference）。这意味着在方法调用时，将参数的值（也就是参数引用的副本）传递给方法，而不是传递参数的实际引用。

当你将一个原始数据类型（如 `int`、`double`、`char` 等）作为参数传递给方法时，你传递的是该数据的值的副本。任何对参数值的修改都不会影响原始值。

public void modifyValue(int x) {x = 10; // 修改局部变量 x 的值，不会影响原始值
}public static void main(String[] args) {int num = 5;modifyValue(num);System.out.println(num); // 输出 5，原始值不变
}

当你将一个对象作为参数传递给方法时，你传递的是对象的引用的副本，而不是对象本身。这意味着你可以通过引用访问和修改对象的状态，但不能通过修改引用来改变原始对象引用的对象。

class Person {String name;Person(String name) {this.name = name;}
}public void modifyPersonName(Person person) {person.name = "Alice"; // 修改对象的状态，会影响原始对象
}public static void main(String[] args) {Person person = new Person("Bob");modifyPersonName(person);System.out.println(person.name); // 输出 "Alice"，原始对象状态被修改
}

虽然传递的是引用的副本，但原始引用和方法中的引用指向的是同一个对象。所以，通过方法修改对象的状态会影响原始对象。但如果在方法中重新分配引用，原始引用不会受到影响。

总结：Java 中的参数传递是按值传递，原始数据类型传递值的副本，而对象类型传递引用的副本，允许修改对象的状态，但不允许修改原始引用。

八、什么是Java的序列化，如何实现Java的序列化？

Java 的序列化是一种将对象转换为字节流的过程，以便将其保存到文件、传输到网络或在不同 Java 虚拟机之间进行通信。序列化的主要目的是将对象的状态持久化或传输，以便在需要时能够还原对象。反序列化是序列化的逆过程，它将字节流重新转换为对象。

要实现 Java 的序列化，需要满足以下条件和步骤：

1. **实现 `Serializable` 接口**：
要使一个类可序列化，它必须实现 `Serializable` 接口。这是一个标记接口，没有需要实现的方法。只要类声明实现了这个接口，编译器就知道这个类可以被序列化。

 import java.io.Serializable;public class MyClass implements Serializable {// 类的成员和方法}

2. **使用 `ObjectOutputStream` 进行序列化**：
要将对象序列化为字节流，您可以使用 `ObjectOutputStream` 类。首先，创建一个 `FileOutputStream` 或 `ByteArrayOutputStream` 来写入字节流，然后将其传递给 `ObjectOutputStream`。

import java.io.*;public class SerializationExample {public static void main(String[] args) {try {MyClass obj = new MyClass();FileOutputStream fileOut = new FileOutputStream("myObject.ser");ObjectOutputStream out = new ObjectOutputStream(fileOut);out.writeObject(obj);out.close();fileOut.close();System.out.println("Object serialized successfully.");} catch (IOException e) {e.printStackTrace();}}}

3. **使用 `ObjectInputStream` 进行反序列化**：
要从字节流中反序列化对象，您可以使用 `ObjectInputStream` 类。首先，创建一个 `FileInputStream` 或 `ByteArrayInputStream` 来读取字节流，然后将其传递给 `ObjectInputStream`。

 import java.io.*;public class DeserializationExample {public static void main(String[] args) {try {FileInputStream fileIn = new FileInputStream("myObject.ser");ObjectInputStream in = new ObjectInputStream(fileIn);MyClass obj = (MyClass) in.readObject();in.close();fileIn.close();System.out.println("Object deserialized successfully.");} catch (IOException | ClassNotFoundException e) {e.printStackTrace();}}}

4. **自定义序列化和反序列化**（可选）：
如果您需要更精细的控制序列化和反序列化过程，您可以在类中定义特殊方法 `writeObject` 和 `readObject`。这允许您在序列化和反序列化期间执行自定义逻辑。

private void writeObject(ObjectOutputStream out) throws IOException {// 自定义序列化逻辑out.defaultWriteObject(); // 调用默认序列化}private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {// 自定义反序列化逻辑in.defaultReadObject(); // 调用默认反序列化}

需要注意的是，不是所有的对象都可以序列化，例如，如果对象包含不可序列化的成员变量，那么它也不能被序列化，或者需要采取额外的措施来处理这些成员。此外，序列化可能会涉及到版本控制，以确保反序列化的兼容性。

总之，Java 的序列化是将对象转换为字节流以实现持久化或传输的重要机制，通过实现 `Serializable` 接口并使用 `ObjectOutputStream` 和 `ObjectInputStream`，您可以轻松实现对象的序列化和反序列化。

九、Java中的反射怎么理解？

Java的反射机制是指在运行状态中，对于一个类都能够知道这个类所有的属性和方法；并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象方法的功能成为Java语言的反射机制。

简单的说：在运行时动态的获取、操作和修改类或对象的属性、方法、构造函数等信息的能力，而不需要在编译时预先知道类的具体信息。

1、如何利用反射机制获取class对象？

a、使用Class.forName静态方法

b、使用类型.class

c、使用实例对象的getClass方法

2、利用反射创造对象

a.使用class.newInstance()

b.使用constructor.newInstance()

// 方法1：获取classClass<?> aClass = Class.forName("com.cxb.java.face.MyUser");System.out.println(aClass);// 方法1：创造对象MyUser o = (MyUser) aClass.newInstance();System.out.println(o);// 方法2：获取classClass<?> bClass = MyUser.class;System.out.println(bClass);// 方法2：创造对象Constructor<?> con = bClass.getConstructor();MyUser o1 = (MyUser) con.newInstance();System.out.println(o1);// 方法3：获取classClass<?> cClass = new MyUser().getClass();System.out.println(cClass);System.out.println("******************");// 利用反射获取构造方法Class<?> dClass = Class.forName("com.cxb.java.face.MyUser");Constructor<?>[] declaredConstructors = dClass.getDeclaredConstructors();for (Constructor c : declaredConstructors) {System.out.println(c);}// 获取所有的public的方法Method[] methods = dClass.getMethods();for (Method method : methods) {System.out.println(method);}System.out.println("********getDeclaredMethods**********");// 获取类的所有方法Method[] declaredMethods = dClass.getDeclaredMethods();for (Method method : declaredMethods) {System.out.println(method);}System.out.println("**********getDeclaredFields********");Field[] declaredFields = dClass.getDeclaredFields();for (Field field: declaredFields) {System.out.println(field);}System.out.println("********getFields**********");Field[] fields = dClass.getFields();for (Field field: fields) {System.out.println(field);}

十、反射的应用场景有哪些？反射有什么优缺点？

反射在Java中有许多应用场景，它提供了一种在运行时检查和操作类、对象、方法和字段等信息的机制。以下是反射的一些常见应用场景：

1. **框架和库**：许多框架和库使用反射来处理各种类型的对象和配置，以提供更灵活的功能。例如，Spring框架使用反射来实现依赖注入和AOP（面向切面编程）。

2. **插件系统**：反射允许动态加载和卸载插件，这在应用程序需要扩展性时非常有用。您可以在运行时加载未知类，实现插件的动态添加。

3. **对象序列化**：反射用于对象的序列化和反序列化，允许将对象转换为字节流以进行持久化或网络传输，然后重新还原对象。

4. **单元测试**：在单元测试中，反射可以用于访问私有方法和字段，以便测试私有实现细节。

5. **动态代理**：反射用于创建动态代理对象，允许在运行时生成代理类，以实现AOP等功能。

6. **注解处理器**：反射用于处理自定义注解，例如在编写自定义注解处理器时，可以使用反射来检查和处理注解。

尽管反射提供了上述的灵活性和应用场景，但它也具有一些优点和缺点：

**优点**：

1. **动态性**：反射允许在运行时动态地操作类和对象，这在某些情况下非常有用，尤其是当您不知道类的类型或结构时。

2. **灵活性**：反射可以用于处理各种类型的对象，无需提前了解其类型。

3. **插件和扩展性**：反射允许实现插件系统和动态加载模块，从而增加了应用程序的可扩展性。

**缺点**：

1. **性能开销**：反射通常比直接调用代码的性能要差，因为它涉及到运行时的动态查找和解析。这可能会对性能敏感的应用程序产生影响。

2. **类型安全性**：反射可以绕过编译时类型检查，因此可能导致类型安全问题，如类转型异常。

3. **代码可读性和维护性**：反射代码通常较复杂，难以理解和维护，因此应该谨慎使用，避免滥用。

总之，反射是一项强大的功能，但它应该谨慎使用，只在必要时使用，以避免性能问题和类型安全问题。在大多数情况下，最好使用编译时的类型安全性，只有在确实需要在运行时动态处理未知类或对象时才使用反射。

十一、如何实现动态代理？

在 Java 中，可以使用动态代理实现代理模式，动态代理允许你在运行时创建一个代理类，该代理类实现了一个或多个接口，并且可以代理实际对象的方法调用。动态代理通常用于实现日志记录、性能监测、事务管理等方面。

Java 提供了两种方式来实现动态代理：

1. 基于接口的动态代理（JDK 动态代理）：

JDK 动态代理是通过 Java 标准库中的 `java.lang.reflect.Proxy` 类来实现的。要使用 JDK 动态代理，需要满足以下条件：

代理目标类必须实现一个或多个接口。
创建一个 `InvocationHandler` 接口的实现类，该实现类定义了代理对象的行为。
使用 `Proxy.newProxyInstance()` 方法创建代理对象。

下面是一个示例：

  import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;interface MyInterface {void doSomething();}class RealObject implements MyInterface {public void doSomething() {System.out.println("RealObject is doing something.");}}class MyInvocationHandler implements InvocationHandler {private Object realObject;public MyInvocationHandler(Object realObject) {this.realObject = realObject;}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("Before invoking method.");Object result = method.invoke(realObject, args);System.out.println("After invoking method.");return result;}}public class DynamicProxyExample {public static void main(String[] args) {MyInterface realObject = new RealObject();MyInterface proxy = (MyInterface) Proxy.newProxyInstance(DynamicProxyExample.class.getClassLoader(),new Class[]{MyInterface.class},new MyInvocationHandler(realObject));proxy.doSomething();}}

2. 基于类的动态代理（CGLIB 动态代理）：

CGLIB（Code Generation Library）动态代理是通过创建目标类的子类来实现的，它不要求目标类实现接口。要使用 CGLIB 动态代理，需要引入 CGLIB 库，并使用 CGLIB 提供的工具来创建代理对象。

下面是一个示例：

 import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;class RealObject {public void doSomething() {System.out.println("RealObject is doing something.");}}class MyMethodInterceptor implements MethodInterceptor {public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {System.out.println("Before invoking method.");Object result = proxy.invokeSuper(obj, args);System.out.println("After invoking method.");return result;}}public class DynamicProxyExample {public static void main(String[] args) {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(RealObject.class);enhancer.setCallback(new MyMethodInterceptor());RealObject proxy = (RealObject) enhancer.create();proxy.doSomething();}}

无论使用哪种动态代理方式，都可以在方法调用前后添加额外的逻辑，实现代理的功能。选择动态代理方式取决于您的需求和目标类的实现方式。如果目标类已实现接口，JDK 动态代理是一个不错的选择。如果目标类没有实现接口，可以考虑使用 CGLIB 动态代理。

十二、String为什么设计为不可变类？

Java 中的字符串（`String` 类）被设计为不可变类，这是出于一些重要的考虑和优点：

1. **安全性**：字符串常常用于存储敏感信息，如密码。如果字符串是可变的，那么它的值可以在创建后被修改，这可能会导致安全漏洞。通过设计字符串为不可变类，可以确保字符串的内容在创建后不会被修改，增强了安全性。

2. **线程安全**：不可变类天生是线程安全的，因为它的值无法在多个线程之间更改。这降低了多线程编程中的并发问题的复杂性，无需额外的同步措施。

3. **缓存**：由于字符串是不可变的，可以安全地进行缓存。字符串池（`String Pool`）是 Java 中的一个典型示例，它存储了字符串字面量的唯一实例。这减少了内存占用，提高了性能，因为相同的字符串只需要在内存中存储一次。

4. **性能优化**：不可变字符串在某些操作上可以提供性能优势。例如，字符串拼接操作（`concatenation`）可以通过创建新字符串来实现，而不必修改原始字符串，这可以减少内存分配和复制的开销。

5. **哈希码缓存**：不可变字符串可以缓存其哈希码（`hashCode`），以提高散列（`hashing`）性能。由于字符串的内容不会更改，其哈希码可以在首次计算后保持不变。

6. **参数传递安全**：由于字符串是不可变的，将其传递给方法或其他对象时不必担心它被修改，这增加了代码的可靠性。

总之，将字符串设计为不可变类带来了许多优点，包括安全性、线程安全性、性能优化和代码可靠性。这使得字符串在 Java 中成为一个重要且广泛使用的数据类型。如果需要对字符串进行修改操作，可以使用可变字符串类如 `StringBuilder` 或 `StringBuffer`，它们专门用于构建和修改字符串。但在大多数情况下，使用不可变字符串是一个良好的实践。

十三、String、StringBuilder、StringBuffer的区别？

在 Java 中，`String`、`StringBuilder` 和 `StringBuffer` 都是用于处理字符串的类，但它们之间有一些重要的区别，主要涉及到不可变性、线程安全性和性能：

1. **String（不可变字符串）**：

`String` 类是不可变的。一旦创建了一个 `String` 对象，它的值就不能被修改。
任何对 `String` 的操作都会创建一个新的 `String` 对象，原始的 `String` 对象保持不变。这包括字符串连接、剪切、替换等操作。
不可变性使得 `String` 可以被安全地共享，因此可以放心地将 `String` 对象作为参数传递给方法，而不担心其内容被修改。
由于不可变性，`String` 对象的哈希码（`hashCode`）可以在首次计算后缓存，提高了哈希性能。

2. **StringBuilder（可变字符串，非线程安全）**：

`StringBuilder` 是可变的，适用于需要频繁进行字符串操作的情况，如在循环中构建字符串。
`StringBuilder` 的方法允许在现有对象上进行修改，而不会创建新的对象，从而提高了性能。
由于 `StringBuilder` 不是线程安全的，因此在多线程环境下使用时需要额外的同步措施。

示例：

 StringBuilder sb = new StringBuilder();sb.append("Hello");sb.append(" ");sb.append("World");String result = sb.toString(); // 构建最终字符串

3. **StringBuffer（可变字符串，线程安全）**：

`StringBuffer` 与 `StringBuilder` 类似，也是可变的，但具备线程安全性。
在多线程环境中，`StringBuffer` 是一个安全的选择，因为它的方法是同步的，可以防止多个线程同时修改字符串。

示例：

 StringBuffer buffer = new StringBuffer();buffer.append("Hello");buffer.append(" ");buffer.append("World");String result = buffer.toString(); // 构建最终字符串

总结：

如果字符串不需要更改（不可变），则使用 `String` 类。
如果字符串需要频繁更改，并且在单线程环境下运行，使用 `StringBuilder` 可以提高性能。
如果字符串需要频繁更改，并且在多线程环境下运行，使用 `StringBuffer` 来确保线程安全。

十四、String str = "i" 与 String str = new String("i")一样吗？

不一样

因为内存的分配方式不一样。string str =“i”的方式，Jvm会将其分配到常量池中；而string str = new string(“i”)方式，则会分配到堆内存中。

十五、接口和抽象类有什么区别？

接口（Interface）和抽象类（Abstract Class）是 Java 中两种不同的机制，用于实现抽象类型和多态性，它们之间有以下主要区别：

1. **定义**：
- **接口**：接口是一种纯粹的抽象类型，它只包含抽象方法的声明（从 Java 8 开始，接口也可以包含默认方法和静态方法的实现）。接口不允许包含非抽象方法的实现。
- **抽象类**：抽象类是一个类，它可以包含抽象方法的声明和非抽象方法的实现。抽象类允许在其中定义一些共享的行为。

2. **继承**：
- **接口**：一个类可以实现多个接口，即一个类可以具有多个接口的特征和行为。接口之间的关系是多继承。
- **抽象类**：一个类只能继承一个抽象类，这意味着类只能从一个抽象类中继承特征和行为。Java 不支持多继承。

3. **构造函数**：
- **接口**：接口不能包含构造函数，因为接口不能被实例化。
- **抽象类**：抽象类可以包含构造函数，它可以在实例化抽象类时执行一些初始化操作。

4. **成员变量**：
- **接口**：接口中的变量默认为 `public`、`static`、`final`，也就是常量，不能包含实例变量。
- **抽象类**：抽象类可以包含实例变量、静态变量和常量，它们的可见性可以根据访问修饰符进行控制。

5. **方法实现**：
- **接口**：接口中的方法只有方法声明，不包含方法实现。实现类必须提供方法的具体实现。
- **抽象类**：抽象类中可以包含抽象方法的声明和非抽象方法的实现。子类可以选择性地覆盖抽象方法。

6. **用途**：
- **接口**：通常用于定义契约、规范或一组相关的抽象方法，以便不同的类可以实现这些方法来达到一定的共享行为。
- **抽象类**：通常用于表示一类对象的通用特征和行为，以便多个子类可以继承和共享这些特征和行为。

总结：

接口强调规范和契约，允许多继承，没有方法实现。
抽象类允许共享通用行为和状态，允许单一继承，可以包含方法实现。
选择接口还是抽象类取决于设计需求，通常需要根据具体情况来决定使用哪种方式。

十六、什么是浅拷贝和深拷贝？

浅拷贝（Shallow Copy）和深拷贝（Deep Copy）是两种不同的对象复制方式，它们涉及到如何复制对象以及复制后对象之间的引用关系。

1. **浅拷贝（Shallow Copy）**：
- 浅拷贝是一种对象复制方式，它创建一个新的对象，但只复制了原始对象的基本数据类型字段的值和引用类型字段的引用（内存地址），而不复制引用类型字段所引用的对象本身。
- 结果是，浅拷贝后的对象和原始对象共享某些引用类型字段所引用的对象。如果其中一个对象修改了共享的引用类型对象，另一个对象也会受到影响。示例：

@Data
@NoArgsConstructor
public class Address implements Serializable {private String city;public Address(String city) {this.city = city;}
}@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person implements Serializable {private String name;private Address address;
}浅拷贝：
public static void main(String[] args) {Person original = new Person("Alice", new Address("New York"));Person copy = new Person(original.getName(), original.getAddress());// 修改拷贝后的对象的地址copy.getAddress().setCity("Los Angeles");// 输出 "Los Angeles"，因为拷贝和原始对象共享同一个 Address 对象System.out.println(original.getAddress().getCity());
}深拷贝：
public static void main(String[] args) {Person original = new Person("Alice", new Address("New York"));// 使用 Java 中的深拷贝库，例如 Apache Commons Lang 库中的 SerializationUtilsPerson copy = SerializationUtils.clone(original);// 修改拷贝后的对象的地址copy.getAddress().setCity("Los Angeles");// 输出 "Los Angeles"，因为拷贝和原始对象共享同一个 Address 对象System.out.println(original.getAddress().getCity());}

2. **深拷贝（Deep Copy）**：
- 深拷贝是一种对象复制方式，它创建一个新的对象，并递归复制原始对象以及原始对象引用的所有对象。这意味着深拷贝后的对象和原始对象完全独立，不共享任何对象。
- 深拷贝通常需要额外的代码来实现，以确保所有引用类型字段都被复制，包括它们引用的对象。示例（使用 Java 中的深拷贝库或手动实现）：

 // 使用 Java 中的深拷贝库，例如 Apache Commons Lang 库中的 SerializationUtilsPerson original = new Person("Alice", new Address("New York"));Person copy = SerializationUtils.clone(original); // 深拷贝// 修改拷贝后的对象的地址copy.address.city = "Los Angeles";System.out.println(original.address.city); // 输出 "New York"，因为深拷贝后的对象和原始对象不共享对象

总结：

浅拷贝只复制对象的引用，导致拷贝后的对象和原始对象可能共享某些对象。它通常使用默认的对象复制方式实现。
深拷贝复制对象及其引用的所有对象，确保拷贝后的对象完全独立于原始对象。深拷贝通常需要额外的代码来实现，或使用深拷贝库。选择哪种方式取决于您的需求和对象结构。

十七、Overload、Override、Overwrite的区别？

"Overload"、"Override" 和 "Overwrite" 是与方法和函数相关的术语，它们在 Java 和其他编程语言中有特定的含义和用途：

1. **Overload（重载）**：
- "Overload" 是指在同一个类中定义多个具有相同名称的方法，但这些方法的参数列表不同（参数数量或参数类型不同）。编译器会根据方法调用的参数类型来选择调用哪个重载方法。
- 重载方法可以具有不同的返回类型，但不能仅依据返回类型来区分方法。因为编译器不仅根据方法的名称和参数类型，还会考虑方法的返回类型来决定调用哪个方法。示例：

 class MathUtils {int add(int a, int b) {return a + b;}double add(double a, double b) {return a + b;}}

2. **Override（重写）**：
- "Override" 是指子类重写（覆盖）了父类中的方法，子类的方法具有相同的名称、参数列表和返回类型。重写方法通常用 `@Override` 注解来标记，以确保正确性。
- 重写方法必须满足一定的规则，例如访问修饰符不能更严格（不能缩小访问范围）、不能抛出比父类更多的异常，等等。示例：

class Animal {void makeSound() {System.out.println("Animal makes a sound");}}class Dog extends Animal {@Overridevoid makeSound() {System.out.println("Dog barks");}}

3. **Overwrite（覆盖）**：
- "Overwrite" 在文件操作中，覆盖通常是指将已有的文件内容替换新的内容。

总结：
- "Overload" 重载：意味着在同一个类中定义了多个同名方法，但参数列表不同。
- "Override" 重写：表示子类重写了父类中的方法，方法名称、参数列表和返回类型都相同。
- "Overwrite" 覆盖：指在文件操作中，将文件内容替换为新的内容。

十八、Exception和Error有什么区别？

`Exception` 和 `Error` 是 Java 中的两种不同的异常类，它们之间有以下主要区别：

1. **继承关系**：

`Exception` 类属于 Java 异常层次结构中的一部分，它是 `Throwable` 类的子类。
`Error` 类也属于 Java 异常层次结构，但它是 `Throwable` 类的子类的子类。换句话说，`Error` 和 `Exception` 都是可以被抛出的可检查异常，但它们在层次结构中的位置不同。

2. **异常的用途**：

`Exception` 用于表示程序可能能够处理的异常情况。这些异常通常是由程序错误、用户输入错误或外部环境因素引起的，程序可以通过捕获和处理这些异常来继续执行。
`Error` 用于表示严重的系统问题，通常是由虚拟机（JVM）或其他底层资源出现的问题，例如内存不足、栈溢出、类加载问题等。`Error` 通常表示程序无法恢复的情况，不应该捕获和处理它们，而应该让程序崩溃。

3. **检查和非检查异常**：
a.`Exception` 分为两种：检查异常（Checked Exception）和非检查异常（Unchecked Exception）。

检查异常是编译器要求必须处理的异常，即必须使用 `try-catch` 块或在方法签名中使用 `throws` 声明来处理它们。通常是继承自 `Exception` 类的子类。
非检查异常是不受编译器检查的异常，通常是继承自 `RuntimeException` 类的子类。这些异常通常表示程序错误，如空指针异常（`NullPointerException`）和数组越界异常（`ArrayIndexOutOfBoundsException`）等。

b.`Error` 是非检查异常，它通常不需要在代码中进行显式处理。程序员不应该捕获和处理 `Error`，因为它们表示严重的系统问题，处理它们通常是不恰当的。

总结：

`Exception` 是用于表示程序可能能够处理的异常情况的类，它分为检查异常和非检查异常。
`Error` 是用于表示严重系统问题的类，通常表示程序无法恢复的情况，不应该捕获和处理。

十九、Java中的IO流的分类？说出几个熟悉的实现类？

在JAVA中，IO流可以根据其功能和作用进行分类。主要分为四种类型：字节流、字符流、缓冲流和对象流。

1、字节流（Byte Stream）：以字节为单位进行读写操作的流。字节流通常用于处理二进制数据或字节形式的文本数据。

2、字符流（Character Stream）：以字符为单位进行读写操作的流。字符流通常用于处理字符数据，支持Unicode编码。

3、缓冲流（Buffered Stream）：提供了缓冲功能，可以减少实际IO操作的次数，提高读写效率。

4、对象流（Object Stream）：用于读写Java对象的流。可以方便地将对象序列化和发序列化到文件或网络中。

二十、常见的异常类有哪些？

二十一、并行和并发有什么区别？

"并行"（Parallelism）和 "并发"（Concurrency）是计算机科学中两个重要的概念，它们描述了程序中任务执行的方式，但它们有不同的含义和应用场景：

1. **并行（Parallelism）**：

并行指的是同时执行多个任务，通常是在多个处理单元（如多核处理器、多线程或多进程）上执行。在并行计算中，多个任务真正同时运行，每个任务都有自己的执行线程或进程。
并行通常用于提高程序的性能，特别是在需要大量计算或处理的情况下。通过将任务分配给多个处理单元，可以加速任务的完成。
并行编程的一个挑战是处理竞争条件和同步问题，因为多个任务可能会同时访问共享资源。

2. **并发（Concurrency）**：

并发指的是在一个时间段内执行多个任务，但不一定是同时执行。在并发计算中，多个任务可能交替执行，每个任务执行一小段时间，然后切换到另一个任务。
并发通常用于处理多个独立的任务或响应多个请求，使程序可以更高效地利用资源。例如，一个网络服务器可以同时处理多个客户端请求。
并发编程的一个主要挑战是协调任务的执行，以确保正确性和避免竞争条件。

总结：

并行是真正同时执行多个任务，通常用于提高性能。
并发是在一个时间段内执行多个任务，任务可能交替执行，通常用于多任务处理和资源共享。
并行和并发都是重要的概念，根据问题的性质和硬件资源来选择合适的策略。有时，它们也可以结合使用，即并发任务中的每个任务可以使用并行处理来提高性能。

二十二、什么是进程和线程？

二十三、线程有几种创建方式？

二十四、为什么调用start方法时会执行run方法，那怎么不直接调用run方法？

在Java中，当你调用`start()`方法时，会启动一个新的线程，这个新线程会执行`run()`方法中的代码。这是因为`start()`方法负责启动一个新的线程，而`run()`方法是新线程的入口点，包含了新线程要执行的代码。

如果你直接调用`run()`方法，那么实际上并不会启动新线程，而只会在当前线程中执行`run()`方法的代码。这就失去了多线程的优势，因为所有的代码都在同一个线程中执行，不能充分利用多核处理器等多线程的好处。

通过调用`start()`方法来启动新线程，可以让操作系统调度新线程并分配处理器时间片，从而实现并发执行。这样可以充分利用多核处理器，提高程序的性能和响应能力。

总结：

`start()`方法负责启动新线程，新线程会执行`run()`方法中的代码。
直接调用`run()`方法只会在当前线程中执行代码，不会启动新线程，不具备多线程的并发性能优势。

二十五、线程有哪些常用的调度方法

二十六、线程有几种状态？

二十七、什么是线程上下文切换？

线程上下文切换（Thread Context Switching）是指操作系统在多线程环境下，由于多个线程之间轮流运行，需要将当前线程的执行上下文（包括寄存器内容、程序计数器、堆栈指针等）保存到内存中，同时加载下一个要执行的线程的上下文到处理器寄存器中的过程。

线程上下文切换通常在以下情况发生：

1. **时间片用完**：操作系统为每个线程分配一小段时间片（通常几毫秒），当一个线程的时间片用完后，操作系统会进行上下文切换，切换到另一个线程执行，以实现多线程并发。

2. **等待资源**：如果一个线程请求某些资源（如锁、IO操作等）而无法立即获得，它可能会被挂起（阻塞状态），并进行上下文切换，以允许其他线程继续执行。

3. **线程优先级**：线程调度器可能根据线程的优先级来决定哪个线程应该获得执行时间，这也可能导致上下文切换。

线程上下文切换的开销相对较高，因为它涉及到将寄存器内容写入内存并加载新线程的寄存器内容，这需要时间和计算资源。因此，在高度并发的系统中，频繁的上下文切换可能会导致性能下降。

为了减少线程上下文切换的开销，操作系统和编程语言运行时库通常采用了以下策略：

使用更少的线程：精心选择线程数量，避免创建过多的线程。
使用线程池：重复使用线程而不是频繁地创建和销毁线程。
避免阻塞操作：采用非阻塞的算法和IO操作，以减少线程挂起的机会。
使用协程或轻量级线程：这些机制允许更灵活地切换上下文，减少开销。

理解和管理线程上下文切换对于编写高效的多线程程序非常重要，因为它可以减少性能瓶颈和资源浪费。

二十八、线程间有哪些通信方式？

在多线程编程中，线程之间需要进行通信以实现协作和数据交换。以下是常见的线程间通信方式：

1. **共享内存**：

多个线程共享同一块内存区域，通过读写共享内存来进行通信。
优点：速度快，适用于数据共享。
缺点：需要显式的同步机制来避免竞争条件（如锁），容易引发线程安全问题。

2. **管道（Pipe）**：

一种单向通信机制，通常用于父子进程间或兄弟进程间的通信。
优点：简单易用。
缺点：只能实现单向通信。

3. **消息队列（Message Queue）**：

线程通过将消息发送到队列，然后另一个线程从队列中接收消息来进行通信。
优点：解耦了线程之间的依赖，适用于异步通信。
缺点：实现较为复杂，需要消息队列的支持。

4. **信号量（Semaphore）**：

一种用于线程间同步的计数器，通常用于控制同时访问共享资源的线程数量。
优点：用于限制并发度，可以用于解决资源管理问题。
缺点：使用复杂，容易引发死锁。

5. **条件变量（Condition Variable）**：

用于线程之间的协作，允许线程等待某个条件成立时被唤醒。
优点：可用于线程的精细控制和协作。
缺点：需要与互斥锁结合使用。

6. **屏障（Barrier）**：
- 用于同步多个线程，要求所有线程达到某个点后才能继续执行。
- 优点：适用于多个线程之间的协同工作。
- 缺点：使用复杂，需要考虑线程数量和屏障的位置。

7. **分布式通信方式**：
- 用于多台计算机或多个进程之间的通信，如远程过程调用（RPC）、消息传递接口（MPI）等。

这些通信方式可根据具体需求和场景来选择。线程之间的通信通常需要谨慎设计，以避免竞争条件、死锁等问题，同时提高多线程程序的性能和可维护性。

二十九、ThreadLocal是什么？

`ThreadLocal` 是 Java 中的一个类，用于在多线程环境下存储线程本地（Thread-Local）变量。线程本地变量是指每个线程都拥有自己独立的变量副本，这些副本在不同线程中互不干扰。`ThreadLocal` 提供了一种在多线程环境下访问线程本地变量的机制。

`ThreadLocal` 主要具有以下特点和用途：

1. **独立性**：每个线程都可以通过 `ThreadLocal` 创建自己的局部变量，这些变量不会被其他线程访问或修改。这样可以避免多线程环境下的竞争条件和同步问题。

2. **线程封闭性**：`ThreadLocal` 可以用于实现线程封闭性，即将某个对象限定在单个线程内部访问，不被其他线程访问，从而保护对象的安全性。

3. **避免参数传递**：使用 `ThreadLocal` 可以避免在方法之间传递参数，因为每个线程都可以直接访问自己的局部变量，简化了代码和方法之间的耦合度。

4. **线程池中的应用**：`ThreadLocal` 在线程池中的应用较为常见。线程池中的多个线程可以共享一些资源，但同时也需要各自保持独立的状态，这时可以使用 `ThreadLocal` 来存储每个线程的状态信息。

使用 `ThreadLocal` 的基本操作包括：

`set(T value)`：将一个值存储到当前线程的 `ThreadLocal` 变量中。
`get()`：获取当前线程的 `ThreadLocal` 变量的值。
`remove()`：移除当前线程的 `ThreadLocal` 变量。

示例：

public class ThreadLocalExample {private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);public static void main(String[] args) {threadLocal.set(42);Runnable task = () -> {int value = threadLocal.get();System.out.println("Thread-local value: " + value);};Thread thread1 = new Thread(task);Thread thread2 = new Thread(task);thread1.start();thread2.start();}
}

需要注意的是，使用 `ThreadLocal` 时应注意内存泄漏问题，因为线程本地变量的生命周期通常与线程相同，如果不及时清理或移除，可能会导致对象无法被垃圾回收。因此，一般建议在不再需要使用 `ThreadLocal` 变量时，手动调用 `remove()` 方法来清理。

从代码可以看出，每个线程都是独立的threadlocal。

三十、ThreadLocal是怎么实现的？

ThreadLocal是Java中所提供的线程本地存储机制，可以利用该机制将数据缓存在某个线程内部，该线程可以在任意时刻、任意方法中获取缓存的数据。

ThreadLocal底层是通过ThreadLocalMap来实现的，每个Thread对象（注意不是ThreadLocal对象）中都存在一个ThreadLocalMap，Map的key为ThreadLocal对象，Map的value为需要缓存的值。

三十一、ThreadLocal内存泄漏是怎么回事？

如果在线程池中使用ThreadLocal会造成内存泄漏，因为当ThreadLocal对象使用完之后，应该要把设置的key，value也就是entry对象进行回收，但线程池中的线程不会回收，而线程对象是通过强引用指向ThreadLocalMap，ThreadLocalMap也是通过强引用指向entry对象，线程不被回收，entry对象也就不会被回收，从而出现内存泄漏。

解决方法：使用了ThreadLocal对象之后，手动调用ThreadLocal的remove方法，手动清除entry对象。

三十二、ThreadLocalMap的结构

ThreadLocalMap虽然被称为Map，但是它其实是没有实现Map接口的，不够结构还是和HashMap比较类似的。

1. **数组表格（Table）**：
- `ThreadLocalMap` 实际上是一个数组表格，通常是一个固定大小的数组，每个元素都是一个 `Entry` 对象。
- 每个 `Entry` 对象包含了两个字段，一个是 `ThreadLocal` 对象作为键，另一个是线程本地变量的值。

2. **散列算法**：
- `ThreadLocalMap` 使用散列算法来确定线程本地变量的存储位置。它根据 `ThreadLocal` 对象的哈希码计算出一个索引，然后将 `Entry` 对象存储在该索引位置的数组元素中。
- 不同的 `ThreadLocal` 对象可以具有相同的哈希码，因此在数组的同一索引位置可能存在多个 `Entry` 对象，但每个 `ThreadLocal` 对象只关联一个 `Entry`。

- 就是怎么把对应的key映射到table数组的相应下标，ThreadLocalMap、用的是哈希取余法，去除key的threadLocalHashCode，然后和table数组长度减一&预算（相当于取余）

3. **哈希冲突处理**：
- 当多个 `ThreadLocal` 对象具有相同的哈希码，导致冲突时，`ThreadLocalMap` 使用线性探测法等方法来解决冲突，找到合适的存储位置。

- 补充一点每创建一个ThreadLocal对象，它就会新增0x61c88647,这个值很特殊，它是斐波那契数也叫黄金分割数。这样带来的好处就是hash分布非常均匀。

4. **扩容机制**：
- 当 `ThreadLocalMap` 中的元素数量达到一定阈值时，它会进行扩容，创建一个更大的数组，然后重新散列所有的 `Entry` 对象到新数组中。

5. **内存管理**：
- `ThreadLocalMap` 中的 `Entry` 对象通常是弱引用，这意味着如果 `ThreadLocal` 对象不再被引用，`Entry` 对象可能会被垃圾回收，从而释放相关的线程本地变量。

总的来说，`ThreadLocalMap` 是一个用于存储线程本地变量的散列表结构，它允许每个线程在其中存储和检索与特定 `ThreadLocal` 对象关联的值，确保线程之间的隔离性。这种机制允许多个线程同时访问线程本地变量，而不会相互干扰。在多线程环境中，`ThreadLocalMap` 是确保线程本地变量正确工作的关键部分。

三十三、ThreadLocalMap怎么解决Hash冲突？

我们都知道HashMap使用了链表来解决冲突，也就是所谓的链地址法。

ThreadLocalMap内部使用的是开放地址法来解决Hash冲突的问题（线性探测法）。具体来说，当发生Hash冲突时，ThreadLocalMap会将当前插入的元素从冲突位置开始依次往后遍历，直到找到一个空闲的位置，然后把该元素放在这个空闲位置。这样即使出现了Hash冲突，不会影响到已经插入的元素，而只是会影响到新的插入操作。

三十四、ThreadLocalMap扩容机制

ThreadLocalMap的扩容机制和HashMap类似，也是在元素数量达到阈值（默认为数组长度的2/3）时进行扩容。具体来说，在set方法中，如果当前元素数量已经达到了阈值，就会调用rehash方法，rehash方法会先去清理过期的entry，然后还要根据条件判断size >= threshold - threshold/4也就是size=threshold * 3/4来决定是否需要扩容。

发现需要扩容时调用resize方法，resize方法首先将数组长度翻倍，然后创建一个新的数组newTab。接着遍历旧数组oldTab中的所有元素，散列方法重新计算位置，开放地址解决冲突，然后放到新的newTab，遍历完成之后，oldTab中所有的entry数据都已经放入到newTab中了，然后table引用指向newTab。

需要注意的是，新数组的长度始终是2的整数次幂，并且扩容后新数组的长度始终大于旧数组的长度。这是为了保证哈希函数计算出的位置在新数组中仍然有效。

三十五、ThreadLocal怎么进行父子线程通信

在Java多线程编程中，父子线程之间的数据传递和共享问题一直是一个非常重要的议题。如果不处理好数据的传递和共享，会导致多线程程序的性能下降或者出现线程安全问题。ThreadLocal是Java提供的一种解决方案，可以非常好的解决父子线程数据共享和传递的问题。

那么它是如何实现通信的呢？在Thread类中存在inheritableThreadLocals变量，简单的说就是使用inheritableThreadLocals来进行传递，当父线程的inheritableThreadLocals不为空时，就会将这个值传到当前子线程的inheritableThreadLocals。

public class Test1 {public static void main(String[] args) {ThreadLocal<Object> threadLocal = new ThreadLocal<>();threadLocal.set("threadLocal");InheritableThreadLocal<Object> inheritableThreadLocal = new InheritableThreadLocal<>();inheritableThreadLocal.set("test + inheritableThreadLocal");Thread t = new Thread(() -> {System.out.println(threadLocal.get());System.out.println(inheritableThreadLocal.get());});t.start();}
}

由此可见：在子线程中可以通过inheritableThreadLocal获取主线程的值。

三十六、说一下你对Java内存模型（JMM）的理解

Java内存模型（Java memory model）是一种规范，用于描述Java虚拟机（JVM）中多线程情况下，线程之间如何协同工作，如何共享数据，并保证多线程的操作在各个线程之间的可见性、有序性和原子性。

具体定义如下：

所有的变量都存储在主内存（main memory）中。
每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的拷贝副本。
线程对变量的所有操作都必须在本地内存中进行，而不能直接读写主内存。
不同的线程之间无法直接访问对方本地内存的变量；线程间共享变量时，通过主内存来实现通信、协作和传递信息。

三十七、说说你对原子性、可见性、有序性的理解？

原子性（Atomicity）：原子性是指一个操作是不可分割的最小执行单位。在多线程环境中，原子操作要么完全执行，要么完全不执行，不存在中间状态。原子性确保了多线程环境下的数据一致性。Java 中的 synchronized 关键字和 java.util.concurrent 包中的原子类（如 AtomicInteger）可以用来实现原子性。

int count = 0; // 1
count++;       // 2
int a = count; // 3

上面展示的语句中，除了语句1是原子操作，其他两个都不是原子性操作。下面看下语句2：包括了3个指令：

指令1：首先，把变量count从内存加载到cpu寄存器
指令2：然后，在寄存器中执行+1操作
指令3：最终，将结果写入内存

对于上面的3条指令来说，如果线程A在指令1完成后线程切换，线程A和线程B按照下图顺序执行，此时执行的结果就不会达到预期。

可见性（Visibility）：可见性是指当一个线程修改了共享变量的值后，其他线程能够立即看到这个修改。在多核处理器和多线程环境下，由于缓存和指令重排序等优化，一个线程对共享变量的修改可能对其他线程不可见，导致数据不一致。为了确保可见性，通常需要使用同步机制（如 synchronized、volatile、java.util.concurrent 包中的锁等）来保证共享变量的可见性。

有序性（Ordering）：有序性是指程序执行的顺序与代码中的顺序相一致。在多线程环境中，由于指令重排序等优化，线程执行的顺序可能与代码中的顺序不一致，导致意外的结果。为了确保有序性，可以使用同步机制来限制指令重排序，或者使用 volatile 关键字来禁止特定类型的重排序。

总结：

原子性确保操作是不可分割的，要么全部执行成功，要么全部不执行。
可见性确保一个线程对共享变量的修改能够被其他线程立即看到。
有序性确保程序执行的顺序与代码中的顺序相一致，防止指令重排序导致的问题。
在多线程编程中，要注意这三个特性，以确保程序的正确性和可靠性。

三十八、说说什么是指令重排？

在不影响单线程程序执行结果的前提下，计算机为了最大限度的发挥机器性能，对机器指令进行重排序优化。

编译器级别的重排：编译器也可以进行指令重排，以优化生成的机器代码。编译器会考虑到处理器的特性和架构，生成更有效率的指令序列。
指令级别的重排：这种重排会重新排序计算机指令的执行顺序，以便更有效地利用处理器的流水线执行指令。例如，处理器可以在某个指令执行的同时开始执行下一条指令，从而减少指令之间的等待时间。
内存访问的重排：这种重排会重新排序对内存的读取和写入操作，以减少内存访问的延迟。例如，处理器可以在一个内存读取操作执行的同时，继续执行后续指令，而不必等待读取操作完成。

以双重校验锁单利模式为例，Singleton instance = new Singleton();对应的JVM指令分为3步；分配内存空间-->初始化对象-->对象指向分配的内存空间，但是经过了编译器的指令重排序，第二步和第三步就可能重排序。