jvav面筋

线程

实现线程的方式

1、编写类直接继承 java.lang.Thread

class MyThread extends Thread {
    @Override
    public void run() {
        // 编写程序，这段程序运行在分支线程中（分支栈）。
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}
public class ThreadTest02 {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.run(); // 不会启动线程，不会分配新的分支栈(这种方式就是单线程，只顺序不并发)
        t.start();// 这里的代码还是运行在主线程中
        for(int i = 0; i < 1000; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

扫盲: 调用 start() 方法的效果是启动一个新的线程，并且让这个线程开始执行 run() 方法中的代码，此时主线程仍继续执行自己的代码，即并发
2、编写类，实现java.lang.Runnable 接口，实现run方法。

// 这不是一个线程类
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}
public class ThreadTest03 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable()); 
        // 启动线程
        t.start();
        for(int i = 0; i < 100; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

result:(独立运行)

主线程--->0
分支线程--->0
主线程--->1
主线程--->2
主线程--->3
......
主线程--->17
分支线程--->1
......
分支线程--->25
......
主线程--->99

线程的方法

r.run = false;//终止线程
...略

垃圾回收机制

必考
可达、不可达、彻底不可达

安全问题

线程同步机制：就是线程排队，必须排队
synchronized关键字:

public class Main{
    private synchronized static void increaseCounter() {....};// 使用 synchronized确保只有一个线程可以同时访问该方法
    public static void main(String[] args){
        Thread t1=new Thread(new Runnable()){
            @Override;
            public void run(){
                increaseCounter();
            }
        }
        Thread t2...;
        t1.start();
        t2.start();
        ......
    }
}

volatile

比synchronized更轻量级的控制线程同步机制
spring-boot-starter-parentxuexi1

内部类

throws和throw

J2EE

反射机制

分为编译阶段和运行阶段，运行阶段是把编译后的文件放入内存，Class对象的由来是将.class文件读入内存，并为之创建一个Class对象。

反射调用方法时可以忽略权限检查，获取这个类的私有方法和属性，因此可能会破坏类的封装性而导致安全问题。如果不需要动态地创建一个对象，那么就不需要用反射
Java 反射机制在一般的 Java 应用开发中很少使用，即便是 Java EE 阶段也很少使用。

静态方法和实例方法区别

静态方法无需实例化对象，只能访问静态变量

自动装箱、自动拆箱

装箱: 将String、Int转化为StringBulider、Integer等

volatile、synchronized

volatile 关键字保证了多线程之间对变量的修改是可见的。当一个线程修改了 volatile 变量的值，其他线程能够立即看到这个修改。这意味着当一个线程修改了 flag 的值，其他线程在读取 flag 时能够立即看到最新的值。

四大引用（强软弱虚）

强引用：是最常见的引用类型。当一个对象被强引用关联时，即使内存空间不足时，Java 的垃圾回收器也不会回收这个对象。只有当该对象不再被任何强引用关联时，垃圾回收器才会回收该对象。
软引用：软引用被用来描述一些还有用但非必需的对象。在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收后还没有足够的内存，才会抛出内存溢出异常。

SoftReference<Object> softRef = new SoftReference<>(new Object());//SoftReference: 软引用类

弱引用：弱引用与软引用的区别在于，当垃圾回收器开始工作，无论当前内存是否足够，都会回收被弱引用关联的对象。这样的对象的生命周期会比较短暂，常常被用于构建对象缓存、线程池等。
虚引用：虚引用是最弱的一种引用类型，几乎没有实际意义。