面试 - JAVA线程

最新推荐文章于 2024-07-28 21:26:53 发布
最新推荐文章于 2024-07-28 21:26:53 发布
阅读量257 收藏 2
点赞数 1
文章标签： java 面试 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44696295/article/details/130924407
版权

学习 Java 线程相关的知识，需要具备一定的 Java 基础知识，特别是对于并发编程、多线程和数据同步方面的概念和基础知识。以下是一些学习 Java 线程的建议：

  1. 学习并理解 Java 并发编程和线程模型的基本原理和理论，尤其是对于线程和内存模型方面的知识。

  2. 阅读 Java 并发编程的经典书籍，例如《Java并发编程实战》、《Java多线程编程核心技术》等，这些书籍讲述了 Java 并发编程的原理和实践技巧，并且提供了许多实际的案例和应用场景。

  3. 参加 Java 线程相关的 MOOC 课程或者在线直播课程，例如网易云课堂、慕课网等，这些课程讲解了 Java 并发编程的实际应用和实践技巧，并提供了一些基于编程题的实践训练。

  4. 查阅 Java 相关文档和在线资源，例如 Oracle 官方文档、Java 语言规范、Java API 文档等，这些资源提供了更加详细和精细的技术细节和使用说明。

  5. 进行实践编程练习，有一句话是说：“理论是灵魂，实践是根本”。只有通过实践，才能够深入理解和掌握 Java 线程相关的知识和技能，并提升实际编程能力。

  6. 加入在线社区和讨论组，例如 StackOverflow、CSDN、JavaCodeGeeks 等，这些社区提供了实际编程和开发过程中的问题和解决方案，并且可以广泛交流和分享经验和资源。

需要注意的是，Java 线程相关的知识是一个深度和广度都比较大的领域，需要有足够的耐心和学习精神，并且结合实际场景来灵活应用并调整相关知识。同时，也需要注重实践能力和经验积累，并且结合其他技能和知识综合运用。

以下为常见的相关面试题。

  1. 什么是线程？

线程是程序执行流的最小单元，一个程序可以同时运行多个线程，每个线程可以独立执行不同的任务，共享进程中的资源。

例如，在一个 Web 应用程序中，可能有多个线程同时服务于不同的客户端请求，每个线程负责处理其中的一部分请求，在多个线程之间进行协调和同步。

  1. 线程与进程的区别？

进程是操作系统资源分配的最小单位，而线程是操作系统调度的最小单位。在一个进程中可以同时运行多个线程，每个线程可以共享进程中的资源，但在不同进程之间的资源是独立的。

例如，同一个程序如果启动了多个进程，这些进程之间的内存是独立的，不能互相访问，而如果同一个进程启动了多个线程，这些线程之间可以共享同一块内存区域，因此在多线程编程中需要注意线程同步和资源访问的问题。

  1. 创建线程的方式有哪些？各自的优缺点是什么？

Java 中创建线程的方式有三种，分别是继承 Thread 类、实现 Runnable 接口和使用 Callable 和 Future 接口。

  • 继承 Thread 类：通过定义一个继承自 Thread 类的子类可以创建线程。这种方式的优点是比较简单，代码可读性好，缺点是因为 Java 不支持多继承，因此如果需要继承其他类或扩展其他接口时比较困难。

  • 实现 Runnable 接口：通过实现 Runnable 接口，然后将其实例作为 Thread 类的构造函数参数传入，来创建线程。这种方式的优点是避免了单继承的问题，代码可读性也很好，但缺点是需要手动管理线程的状态。

  • 使用 Callable 和 Future 接口：Callable 接口类似于 Runnable 接口，但它允许方法有返回值，并可以抛出异常。通过将 Callable 实例传递给 ExecutorService 等线程池中的 submit() 方法，可以异步地执行 Callable 任务，并获取 Callable 的返回结果。

例如，以下是使用 Runnable 接口的示例：

public class SimpleRunnable implements Runnable {
  @Override
  public void run() {
    System.out.println("Hello from Runnable");
  }
}

// 创建线程并执行 Runnable 任务
Thread t = new Thread(new SimpleRunnable());
t.start();
  1. 线程的生命周期及状态，它们之间有什么关系？

Java 线程的生命周期通常包括 5 个状态，分别是新建 (New)、就绪 (Runnable)、运行 (Running)、阻塞 (Blocked) 和终止 (Terminated)。

线程在创建后进入新建状态，等待被执行，当线程调用 start() 方法后进入就绪状态，也就是等待 CPU 调度执行。当线程获得 CPU 时间片并真正开始执行时，进入运行状态。如果线程的执行被阻塞（比如调用了 sleep() 方法、等待 I/O 操作等），则进入阻塞状态。当线程执行完 run() 方法后，进入终止状态。

线程的状态之间可能存在转换关系，例如当一个线程在运行状态中调用了 sleep() 方法时，该线程会进入阻塞状态；当阻塞状态中的线程获取到了锁时，它会进入就绪状态等待 CPU 时钟；当线程执行完 run() 方法后，线程将进入终止状态。

例如，以下是线程状态之间的转换示例：

// 创建线程并启动
Thread t = new Thread(()// 实现 run() 方法
@Override
public void run() {
    // 线程进入运行状态
    System.out.println("Thread is running.");
    try {
        // 线程休眠 3 秒，进入阻塞状态
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 线程执行完毕，进入终止状态
    System.out.println("Thread is terminated.");
}

// 查看线程状态
System.out.println("Thread state: " + t.getState());  // 打印 NEW 状态
t.start();  // 启动线程，进入就绪状态
System.out.println("Thread state: " + t.getState());  // 打印 RUNNABLE 状态
Thread.sleep(1000);  // 让线程执行一段时间
System.out.println("Thread state: " + t.getState());  // 打印 TIMED_WAITING 状态
t.join();  // 等待线程执行完毕
System.out.println("Thread state: " + t.getState());  // 打印 TERMINATED 状态
  1. 线程安全的概念是什么？

线程安全是指多个线程访问同一份数据时，获取到的数据与预期一致，不会出现数据竞争、脏数据、重复计算等问题。线程安全的实现通常需要使用同步机制来保证多个线程之间的协作和同步。

例如，以下是一个线程不安全的示例：

public class UnsafeCounter {
  private int count;

  public void increment() {
    count++;
  }

  public int getCount() {
    return count;
  }
}

// 创建 100 个线程共享一个计数器
UnsafeCounter counter = new UnsafeCounter();
for (int i = 0; i < 100; i++) {
  new Thread(() -> {
    for (int j = 0; j < 1000; j++) {
      counter.increment();  // 计数器自增
    }
  }).start();
}

// 等待所有线程执行完毕
Thread.sleep(1000);

// 输出计数器的值
System.out.println("Counter value: " + counter.getCount());  // 输出一个大于 100000 的值
  1. Java 中如何实现线程安全？

Java 中实现线程安全的方式有多种，包括使用 synchronized 关键字、ReentrantLock、volatile 变量、原子变量等。这些机制可以保证线程安全、状态同步、原子性操作等多方面问题。以下是一个使用 synchronized 关键字的示例，它可以确保计数器的正确性：

public class SafeCounter {
  private int count;

  public synchronized void increment() {
    count++;
  }

  public synchronized int getCount() {
    return count;
  }
}

// 创建 100 个线程共享一个计数器
SafeCounter counter = new SafeCounter();
for (int i = 0; i < 100; i++) {
  new Thread(() -> {
    for (int j = 0; j < 1000; j++) {
      counter.increment();  // 计数器自增
    }
  }).start();
}

// 等待所有线程执行完毕
Thread.sleep(1000);

// 输出计数器的值
System.out.println("Counter value: " + counter.getCount());  // 输出 100000
  1. synchronized 和 ReentrantLock 有什么区别？

synchronized 是 Java 内置的互斥锁机制，可以修饰方法和代码块，可以保证同步访问被修饰的代码不会被多个线程同时执行，从而保证线程安全。

ReentrantLock 是 Java 中的锁接口实现，是一种线程安全的可重入锁。与 synchronized 相比，ReentrantLock 具有更高的灵活性和粒度，支持可中断式锁、公平锁、条件变量等高级特性。

例如，以下是使用 ReentrantLock 的示例：

public class SafeCounter {
  private int count;
  private final ReentrantLock lock = new ReentrantLock();

  public void increment() {
    lock.lock();
    try {
      count++;
    } finally {
      lock.unlock();
    }
  }

  public int getCount() {
    lock.lock();
    try {
      return count;
    } finally {
      lock.unlock();
    }
  }
}

// 创建 100 个线程共享一个计数器
SafeCounter counter = new SafeCounter();
for (int i = 0; i < 100; i++) {
  new Thread(() -> {
    for (int j = 0; j < 1000; j++) {
      counter.increment();  // 计数器自增
    }
  }).start();
}

// 等待所有线程执行完毕
Thread.sleep(1000);

// 输出计数器的值
System.out.println("Counter value: " + counter.getCount());  // 输出 100000
  1. 什么是线程池？使用线程池的好处是什么？

线程池是用于管理和重用线程的一种机制，它通过维护一定数量的线程并重复使用它们，来避免线程的创建和销毁带来的开销，提高了代码的效率和可扩展性。

Java 中提供了 Executor 和 ThreadPoolExecutor 两种线程池的实现，用户可以根据需要选择不同的线程池类型和参数。

使用线程池的好处包括：

  • 提高性能：线程池可以重用线程，避免了频繁地创建和销毁线程，从而降低了操作系统的调度开销。

  • 简化编程：使用线程池可以简化线程编程的复杂性，让开发者更容易地实现多线程任务和调度。

  • 控制资源：线程池可以限制并发数量和资源占用，避免过多的线程数导致系统崩溃或阻塞。

例如，以下是使用 ThreadPoolExecutor 的示例：

// 创建一个线程池，最大同时执行 10 个任务
ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < 100; i++) {
  executor.submit(() -> {
    // 执行任务
    System.out.println("Task executed by thread: " + Thread.currentThread().getName());
  });
}
  1. Java 中如何停止一个线程？

Java 中提供了两种方式来停止一个线程，分别是使用标志位和使用 Thread.interrupt() 方法。

使用标志位的方式是在代码中设置一个标志位，让线程检查该标志位并在需要退出时返回。这种方式相对简单，但需要开发者进行手动控制，并且如果代码中存在阻塞操作，可能会导致该线程无法及时退出。

使用 Thread.interrupt() 方法的方式是向线程发送一个中断信号，线程会收到该信号并立即中断阻塞操作，从而停止当前任务。这种方式相对安全和可控，但需要确保目标线程对中断信号的处理符合预期。

例如，以下是使用标志位停止线程的示例：

public class StoppableThread extends Thread {
  private volatile boolean stopped = false;

  @Override
  public void run() {
    while (!stopped) {
      // 执行任务
    }
  }

  public void stopThread() {
    stopped = true;
    interrupt();
  }
}

// 创建线程并启动
StoppableThread t = new StoppableThread();
t.start();

// 停止线程
t.stopThread();
  1. volatile 关键字有什么作用？

volatile 关键字用于修饰变量，它可以确保该变量的写入和读取操作都是原子性的，并且线程之间对该变量的访问是可见的。

使用 volatile 可以解决某些多线程并发问题，如单例模式的 double-checked locking 和多线程间的状态同步等问题。但是 volatile 不能保证线程间操作的有序性，因此需要谨慎使用。

例如，以下是使用 volatile 关键字的单例模式示例：

public class Singleton {
  private static volatile Singleton instance;

  private Singleton() {}

  public static Singleton getInstance() {
    if (instance == null) {  // 双重检查
      synchronized (Singleton.class) {
        if (instance == null) {
          instance = new Singleton();
        }
      }
    }
    return instance;
  }
}

好的，接下来继续解答一些问题。

  1. 什么是死锁？

死锁是指两个或多个进程在执行过程中因竞争资源或彼此等待而无限期地阻塞、相互等待的现象。

在多线程编程中，死锁通常发生在当两个或多个线程持有对方需要的资源并相互等待时。此时如果没有外部干预或超时机制，这些线程将永远无法继续执行下去。

例如，以下是一个可能导致死锁的代码示例：

public class Deadlock {
  private static final Object lock1 = new Object();
  private static final Object lock2 = new Object();

  public void method1() {
    synchronized (lock1) {
      System.out.println(Thread.currentThread().getName() + " acquire lock1");
      // 线程休眠，尝试获取 lock2
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      synchronized (lock2) {
        System.out.println(Thread.currentThread().getName() + " acquire lock2");
      }
    }
  }

  public void method2() {
    synchronized (lock2) {
      System.out.println(Thread.currentThread().getName() + " acquire lock2");
      // 线程休眠，尝试获取 lock1
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      synchronized (lock1) {
        System.out.println(Thread.currentThread().getName() + " acquire lock1");
      }
    }
  }

  public static void main(String[] args) {
    Deadlock d = new Deadlock();
    new Thread(() -> d.method1()).start();
    new Thread(() -> d.method2()).start();
  }
}
  1. 如何避免死锁？

避免死锁的方法包括：

  • 避免多个线程竞争相同的资源。如果一个资源只能被一个线程使用，那么其他线程就需要等待它释放后才能使用，这样就容易出现死锁。

  • 按顺序获取资源。如果多个线程需要获取多个资源，那么可以按照相同的顺序获取，避免出现互相等待的情况。例如，线程 A 先获取资源 X，再获取资源 Y，线程 B 也按照相同的顺序获取资源 X 和 Y，这样就能避免死锁。

  • 使用定时锁。如果线程 A 获取了锁，但一段时间后没有获取到对应的资源，就释放锁并等待一段时间后再尝试获取，避免无限等待而导致出现死锁。

  • 使用不可抢占锁。如果线程 A 正在使用某个资源，那么其他线程不能夺走它的锁，避免其他线程无限等待而导致出现死锁。

例如，以下是按顺序获取锁的示例：

public class OrderedLock {
  private static final Object lock1 = new Object();
  private static final Object lock2 = new Object();

  public void method1() {
    synchronized (lock1) {
      System.out.println(Thread.currentThread().getName() + " acquire lock1");
      // 线程休眠，尝试获取 lock2
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      synchronized (lock2) {
        System.out.println(Thread.currentThread().getName() + " acquire lock2");
      }
    }
  }

  public void method2() {
    synchronized (lock1) {  // 按顺序获取
      System.out.println(Thread.currentThread().getName() + " acquire lock1");
      // 线程休眠，尝试获取 lock2
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      synchronized (lock2) {
        System.out.println(Thread.currentThread().getName() + " acquire lock2");
      }
    }
  }

  public static void main(String[] args) {
    OrderedLock ol = new OrderedLock();
    new Thread(() -> ol.method1()).start();
    new Thread(() -> ol.method2()).start();
  }
}
  1. 什么是线程间的通信？Java 中如何实现线程间的通信？

线程间的通信是指多个线程之间传递消息和共享资源的过程，主要用于协调不同线程之间的工作。

Java 中实现线程间通信的方式包括：

  • 使用共享变量，即多个线程共享一个变量，并通过加锁等机制来保证线程安全和正确性。

  • 使用 wait() 和 notify() 方法，即当一个线程需要等待某个条件的发生时，就调用 wait() 方法进入等待状态，当条件满足时，就调用 notify() 或 notifyAll() 方法来唤醒等待线程。

  • 使用阻塞队列，即多个线程通过共享一个阻塞队列来传递消息和资源，其中一个线程向阻塞队列中添加消息，另一个线程从队列中取出消息并进行处理。

例如，以下是使用共享变量实现线程间通信的示例：

public class SharedData {
  private int value;
  private boolean flag = false;

  public synchronized void setValue(int value) {
    while (flag) {  // 等待条件满足
      try {
        wait();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
    this.value = value;
    flag = true;
    notifyAll();  // 唤醒等待的线程
  }

  public synchronized int getValue() {
    while (!flag) {  // 等待条件满足
      try {
        wait();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
    int result = value;
    flag = false;
    notifyAll();  // 唤醒等待的线程
    return result;
  }
}

// 创建共享数据对象并启动线程
SharedData data = new SharedData();
new Thread(() -> {
  for (int i = 1; i <= 10; i++) {
    data.setValue(i);
    System.out.println("Thread 1 set value: " + i);
  }
}).start();
new Thread(() -> {
  for (int i = 1; i <= 10; i++) {
    int value = data.getValue();
    System.out.println("Thread 2 get value: " + value);
  }
}).start();
  1. 内存模型是什么？

内存模型是指编程语言中用于描述程序如何读写内存的规范。Java 中的内存模型规定了在多线程并发执行时如何保证内存的可见性、原子性和有序性，以及如何防止线程间的数据竞争和冲突。

Java 内存模型（JMM）采用了基于 happens-before 原则的内存同步机制来保证线程之间的数据同步和协作。happens-before 原则指如果一个操作 happens-before 另一个操作，那么前一个操作对后一个操作可见，即前一个操作对后一个操作具有可见性和有序性。

在 Java 内存模型中，以下操作具有 happens-before 关系：

  • 程序的顺序性规则：程序中每个操作都必须在其前面的操作执行后才能执行。

  • volatile 规则：对一个 volatile 变量的写操作先于对该变量的读操作。

  • 锁规则：对一个锁的解锁操作先于对该锁的加锁操作。

  • 传递性规则：如果操作 A happens-before 操作 B，操作 B happens-before 操作 C，那么操作 A happens-before 操作 C。

  • 线程启动规则：一个线程的 start() 方法先于该线程的每个动作。

  • 线程终止规则：一个线程的所有动作先于该线程的终止。

  • 线程中断规则：对线程 interrupt() 方法的调用先于该线程检查到中断状态的发生。

  • 对象终结规则：一个对象的初始化完成先于它的 finalize() 方法的开始。

例如，以下是使用 volatile 解决线程不可见性问题的示例：

public class SharedData {
  private volatile boolean flag = false;

  public void setFlag(boolean flag) {
    this.flag = flag;
  }

  public boolean isFlag() {
    return flag;
  }
}

// 创建共享数据对象并启动线程
SharedData data = new SharedData();
new Thread(() -> {
  try {
    Thread.sleep(1000);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  data.setFlag(true);
}).start();
while (!data.isFlag()) {
  System.out.println("Value not updated yet.");
}
System.out.println("Value updated.");
  1. 什么是线程安全？

线程安全指的是多线程并发执行时，程序仍能保持正确的行为和结果。如果程序在多线程并发执行时出现了错误、异常或不一致的结果，就说明程序存在线程安全问题。

线程安全问题通常是因为多个线程同时访问了共享的数据和资源，产生了冲突和竞争。为了避免线程安全问题，开发者需要使用合适的同步机制和资源管理策略，并保证程序在多线程执行时依然能够正确地执行。

例如，以下是线程不安全的示例：

public class UnsafeCounter {
  private int count;

  public void increment() {
    count++;
  }

  public int getCount() {
    return count;
  }
}

// 创建 100 个线程共享一个计数器
UnsafeCounter counter = new UnsafeCounter();
for (int i = 0; i < 100; i++) {
  new Thread(() -> {
    for (int j = 0; j < 1000; j++) {
      counter.increment();  // 计数器自增
    }
  }).start();
}

// 等待所有线程执行完毕
Thread.sleep(1000);

// 输出计数器的值
System.out.println("Counter value: " + counter.getCount());  // 输出 98916 或其他不一致的结果

以上代码中，由于多个线程同时对计数器执行自增操作，会导致计数器的值产生不一致和竞争的问题，从而导致线程不安全。

  1. 对于Java 项目而言，如何合理的配置线程池中的线程？

    合理配置线程池中的线程数量是优化 Java 项目性能的重要步骤。线程池的线程数量应该根据系统硬件条件、处理器数量、CPU 负载情况、任务的类型和数量等因素进行综合考虑。

    以下是一些建议和推荐的线程池配置：

    1. CPU 核心数 x 2，作为线程池的最大线程数，可以用于处理 CPU 密集型任务。例如，在一个 8 核 CPU 的服务器上，可以使用一个最大线程数为 16 的线程池。

    2. 对于 I/O 密集型任务，线程池的最大线程数应该比 CPU 核心数多一些，以充分利用空闲的 I/O 资源。例如，在处理网络请求或文件读取时，可以使用一个最大线程数为 20 的线程池。

    3. 使用 Executors 工具类提供的线程池创建方法时，应该避免使用默认的线程池配置。例如，Executors.newCachedThreadPool() 或 Executors.newFixedThreadPool() 方法会使用无限制的最大线程数或固定的线程数量，容易导致线程过多或过少的问题。最好是自己实现 ThreadPoolExecutor 类，并根据具体任务类型和数量进行灵活的线程池配置。

    4. 如果线程池中的线程在执行任务时需要占用更多的资源，例如内存或磁盘存储，那么线程的数量应该更少。同时，也应该避免在单个线程中执行过长时间的任务，以免影响系统的响应和稳定性。

    5. 在使用线程池时，要注意要设置合适的队列容量来处理突发情况。如果队列容量过大，会导致任务过多排队，而不能及时处理；而如果队列容量过小，会造成任务丢失等问题。

    6. 可以考虑使用附加的监视工具去评估线程池配置是否优秀，并为线程池配置提供操作意见。

    总体而言，线程池的合理配置是根据具体应用场景和任务类型而定的，需要进行灵活性和调整，同时也需要考虑到系统的易维护性、易扩展性和稳定性。

kai_44696295
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java面试-线程.doc
05-06
面试中，关于Java线程的知识点通常包括线程的创建、同步控制以及线程的生命周期管理。以下是对这些主题的详细解释： 1. **线程创建**： - **继承Thread类**：创建一个新的类，该类继承自Thread类，并重写run()方法...
面试-Java一些常见面试题+题解之多线程开发-JavaConcurrent.zip
03-03
- Java线程具有优先级，但实际调度很大程度上依赖于操作系统，不保证优先级高的线程优先执行。 10. **中断机制** - Thread类的interrupt()方法用于请求中断线程，isInterrupted()和interrupted()检查中断状态。 ...
Java面试题-线程多线程.pdf
06-12
Java线程有五种状态：新建（New）、可运行（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）。线程从新建到运行，可能经历 `start()` 调用、调度器的选择以及可能的同步等待。线程状态的转换受到 `...
2023黑马面试宝典-Java面试宝典大全-java面试宝典黑马
11-16
4. **多线程**：Java提供了丰富的多线程支持，面试中会考察线程的创建、同步机制（synchronized、Lock）、死锁、线程池等。理解线程状态转换图，掌握线程安全问题的解决方案，如volatile、ThreadLocal等，有助于在...
java-java面试题库整理-基础-JVM-线程并发-框架等.zip
02-06
这份"java-java面试题库整理-基础-JVM-线程并发-框架等.zip"文件提供了一个全面的复习资源，帮助求职者准备Java相关的面试。 1. **Java基础知识** - 类与对象：Java是一种面向对象的语言，了解类的定义、构造器、...
golang 接口
m0_70982551的博客
07-24 873
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 461
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 569
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 550
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 346
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 398
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 79
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 168
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 853
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
Jvm基础（一）
G81948577的博客
07-19 1019
本地方法就是不使用java编写的，比如C++编写的程序，只是需要传递参数。
教务管理平台/高校教务管理系统的设计与实现/教务网站/学生成绩管理系统/学生课程管理系统
weixin_47958760的博客
07-27 423
本毕业设计的内容是设计并且实现一个基于JSP技术的教务管理平台。采用MYSQL为数据库开发平台，SSM框架，Tomcat网络信息服务作为应用服务器。教务管理平台的功能已基本实现，主要有学生、教师、课程信息、课程选择、教师课表、学生成绩、图书信息、考试等管理功能。 论文主要从系统的分析与设计 、数据库设计和系统的详细设计等几个方面来进行论述，系统分析与设计部分主要论述了系统的功能分析、系统的设计思路，数据库设计主要论述了数据库的设计，系统的详细设计部分主要论述了几个主要模块的详细设计过程。
android audio不同音频流，(八)music流音量APK按键调整
五味香的专栏
07-24 412
apk通过监测按键事件，再调用AudioManager函数接口，调节STREAM_MUSIC流音量调节。
PHP中static的使用
likeshopgood的博客
07-24 860
本文详细介绍了PHP中static关键字的使用，并通过实例展示了其强大功能。利用静态属性和方法，我们可以在类实例间共享数据和行为，从而提高代码的效率和可维护性。然而，使用静态成员时，需注意内存管理和访问权限的特殊性，以确保代码的健売性和可管理性。关于我们本文由ChatMoney团队出品，ChatMoney专注于AI应用落地与变现，我们提供全套、持续更新的AI源码系统与可执行的变现方案，致力于帮助更多人利用AI来变现，欢迎进入ChatMoney获取更多AI变现方案！
AOP~面向切面编程介绍
最新发布
m0_61801450的博客
07-28 579
springboot框架中的AOP操作、日志记录功能的填写。
Java面试精华：线程实现与同步方法详解
在Java面试中，关于线程的话题是常被考察的重要知识点。Java提供多种方式来实现线程，主要分为两个阶段： 1. **Java早期版本（Java 5之前）**： - **直接创建新线程**：使用`new Thread()`构造函数创建匿名Thread...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值