多线程和JVM

一，多线程实现的四种方式

1. 实现Runnable接口

普通实现：?

public class MyRunnable implements Runnable {
? ? @Override
? ? public void run() {
? ? ? ? System.out.println("线程执行中...");
? ? }
}

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

?Lambda表达式：

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> System.out.println("线程执行中..."));
        thread.start();
    }
}

2. 实现Callable接口

普通实现方式：

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

public class MyCallable implements Callable<String> {
? ? @Override
? ? public String call() throws Exception {
? ? ? ? return "线程执行中...";
? ? }
}

public class Main {
? ? public static void main(String[] args) {
? ? ? ? Callable<String> callable = new MyCallable();
? ? ? ? FutureTask<String> futureTask = new FutureTask<>(callable);
? ? ? ? Thread thread = new Thread(futureTask);
? ? ? ? thread.start();
? ? ? ??
? ? ? ? try {
? ? ? ? ? ? String result = futureTask.get();
? ? ? ? ? ? System.out.println(result);
? ? ? ? } catch (InterruptedException | ExecutionException e) {
? ? ? ? ? ? e.printStackTrace();
? ? ? ? }
? ? }
}

Lambda实现：

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

public class Main {
    public static void main(String[] args) {
        Callable<String> callable = () -> "线程执行中...";
        FutureTask<String> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        
        try {
            String result = futureTask.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

3. 继承Thread类

public class MyThread extends Thread {
? ? @Override
? ? public void run() {
? ? ? ? System.out.println("线程执行中...");
? ? }
}

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

4. 使用Executors工具类创建线程池

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

public class MyRunnable implements Runnable {
? ? @Override
? ? public void run() {
? ? ? ? System.out.println("线程执行中...");
? ? }
}

public class Main {
? ? public static void main(String[] args) {
? ? ? ? ExecutorService executorService = Executors.newFixedThreadPool(5);
? ? ? ? executorService.execute(new MyRunnable());
? ? ? ? executorService.shutdown();
? ? }
}

二，JVM两种垃圾回收方式

Java 堆是垃圾收集器管理的主要区域，因此也被称作 GC 堆（Garbage Collected Heap）。从垃圾回收的角度，由于现在收集器基本都采用分代垃圾收集算法，所以 Java 堆还可以细分为：新生代和老年代；再细致一点有：Eden、Survivor、Old 等空间。进一步划分的目的是更好地回收内存，或者更快地分配内存。

---

著作权归Guide所有 原文链接：https://javaguide.cn/java/jvm/memory-area.html#%E5%A0%86

Minor GC（年轻代GC）和Full GC（老年代GC）是Java虚拟机中的垃圾收集器执行的两种不同类型的垃圾回收操作。

1. Minor GC（年轻代GC）：

它是指对年轻代（包括Eden区和Survivor区）进行垃圾回收的过程。在Minor GC中，只有年轻代区域会被扫描和回收，而老年代不会受到影响。Minor GC通常会伴随着短暂的停顿时间（性能影响小），用于回收年轻代的垃圾对象。Minor GC的频率比较高，一般在新生代空间不足时触发。

2. Full GC（老年代GC）：

它是指对整个堆内存（包括年轻代和老年代）进行垃圾回收的过程。在Full GC中，会同时对年轻代和老年代进行扫描和回收。Full GC通常会伴随着较长的停顿时间（性能影响大），因为需要扫描整个堆内存。Full GC的频率相对较低，一般在老年代空间不足、永久代空间不足、系统空闲时或者调用`System.gc()`方法时触发。

使用场景：

1. - Minor GC：适用于应用程序中大量创建和销毁对象的情况，例如短期的请求处理、临时对象的创建等。Minor GC的目标是尽快回收年轻代的垃圾对象，以保证年轻代的可用空间。
2. - Full GC：适用于应用程序中长时间运行的对象、大对象、永久代的垃圾回收等。Full GC的目标是回收整个堆内存的垃圾对象，以释放更多的可用空间。

需要注意的是，Full GC的执行会导致较长的停顿时间，可能会对应用程序的性能产生较大的影响，因此在设计和调优应用程序时需要避免Full GC的频繁触发。

三，垃圾收集算法

1，标记-清除算法

适用场景：都行

特点：

1. 效率问题：标记和清除两个过程效率都不高。
2. 空间问题：标记清除后会产生大量不连续的内存碎片。

2，复制算法

使用场景：新生代内存区收集车（存活对象数量少）

特点：

• 可用内存变小：可用内存缩小为原来的一半。
• 不适合老年代：如果存活对象数量比较大，复制性能会变得很差。?

3，标记-整理算法

适用场景：老年代内存区（存活对象数量多）

特点：由于多了整理这一步，因此效率也不高，适合老年代这种垃圾回收频率不是很高的场景。