JIT（Just-In-Time）编译和AOT（Ahead-Of-Time）编译都是计算机程序运行时的编译策略，但是它们的方式和时机都有所不同。

  1. JIT编译：在Java中，JIT编译器是Java虚拟机的一部分，它将字节码（一种中间语言）转换为在特定硬件和操作系统上运行的机器代码。这个转换过程在程序运行时发生，因此被称为即时编译。JIT编译器在运行时分析程序的性能，确定哪些部分的代码被频繁执行，并选择将这些部分的代码编译为机器代码，以提高程序的运行速度。JIT编译器可以实现一些编译器优化，如内联，常量折叠，死代码消除等。
  2. AOT编译：与JIT编译不同，AOT编译是在程序运行之前进行的。AOT编译器将程序的源代码直接编译成特定硬件和操作系统上运行的机器代码，这样程序在运行时就不需要再进行编译。AOT编译可以减少程序的启动时间，并且由于不需要运行时编译，所以可以减少运行时的内存消耗。然而，由于AOT编译在编译时不能知道程序的运行情况，因此可能无法实现一些运行时编译器的优化。

总的来说，JIT和AOT编译各有优势，选择哪种编译策略取决于特定的应用场景和需求。

在Java中，可以使用BufferedReader或者BufferedInputStream等缓冲流来读取大文件，这种方式可以避免一次性将整个文件加载到内存中，避免内存溢出。这里提供一个使用BufferedReader来读取文件的示例：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ReadLargeFile {
    public static void main(String[] args) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader("largefile.txt"));
            String line = null;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

在以上代码中，我们首先创建了一个BufferedReader对象，然后通过readLine()方法逐行读取文件内容，这样可以有效地处理大文件，而不会因为文件过大而导致内存溢出。注意，当读取完文件后，一定要记得关闭BufferedReader对象，以释放系统资源。

采用FileInputStrea：

在Java中，我们通常会使用BufferedInputStream来包装FileInputStream以提高读取大文件的效率。下面是一个例子：

import java.io.*;

public class ReadBigFile {
    public static void main(String[] args) {
        File file = new File("your_file_path"); //替换为你的文件路径
        try {
            FileInputStream fis = new FileInputStream(file);
            BufferedInputStream bis = new BufferedInputStream(fis);
            byte[] buffer = new byte[1024]; //可以根据实际情况调整缓冲区大小
            int length = 0;
            while ((length = bis.read(buffer)) != -1) {
                //处理读取的数据，例如打印
                System.out.write(buffer, 0, length);
            }
            //记得关闭流
            bis.close();
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

上述代码每次会读取1024字节的数据到缓冲区，然后进行处理。这样可以有效地减少磁盘I/O操作，提高读取大文件的速度。

要在Windows本地运行Kafka，您可以按照以下步骤进行操作：

  1. 下载Kafka：从Apache Kafka的官方网站（https://kafka.apache.org/downloads）上下载适用于Windows的Kafka二进制文件。
  2. 解压Kafka：将下载的Kafka压缩包解压到您选择的目录中。

  3. 配置Kafka：进入Kafka解压目录，编辑config/server.properties文件，根据需要修改以下配置：

    • listeners：设置Kafka监听的地址和端口。默认值是PLAINTEXT://localhost:9092。
    • log.dirs：设置Kafka存储日志文件的目录。默认值是/tmp/kafka-logs。

  4. 启动Zookeeper：Kafka依赖于Zookeeper。下载Zookeeper并解压到您选择的目录中。进入Zookeeper解压目录，复制conf/zoo_sample.cfg文件并将其重命名为zoo.cfg，然后编辑zoo.cfg文件，根据需要修改以下配置：

    • dataDir：设置Zookeeper数据存储目录。

    在命令提示符中，进入Zookeeper解压目录，运行以下命令来启动Zookeeper服务器：

    bin\zkServer.cmd

  5. 启动Kafka：在命令提示符中，进入Kafka解压目录，运行以下命令来启动Kafka服务器：

    bin\windows\kafka-server-start.bat config\server.properties

    Kafka服务器将在后台运行，并开始监听配置的地址和端口。

  6. 创建主题和发送消息：在命令提示符中，进入Kafka解压目录，运行以下命令来创建一个名为test的主题：

    bin\windows\kafka-topics.bat --create --topic test --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1

    然后，可以使用以下命令来发送消息到主题：

    bin\windows\kafka-console-producer.bat --topic test --bootstrap-server localhost:9092

    您可以在控制台中输入消息，然后按Enter发送。

  7. 消费消息：在命令提示符中，进入Kafka解压目录，运行以下命令来消费主题的消息：

    bin\windows\kafka-console-consumer.bat --topic test --bootstrap-server localhost:9092 --from-beginning

    您将看到在生产者发送的消息被消费者接收到。

这样，您就可以在Windows本地成功运行Kafka，并进行主题的发布和消费。请根据您的实际需求进行进一步的配置和使用。

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.UUID;

/**
 * 在上述示例中，`SerializeOnFinalize`类重写了`finalize()`方法，在方法中将对象序列化到文件`serializedObject.ser`中。
 * 在`main()`方法中，我们创建了一个`SerializeOnFinalize`对象，然后将其置为`null`，使其成为垃圾回收的候选对象。
 * 最后，我们手动调用`System.gc()`方法触发垃圾回收。
 * <p>
 * 当垃圾回收器执行完毕时，`finalize()`方法会被调用，对象的内容将被序列化到文件中。
 * 请注意，垃圾回收的执行时间是不确定的，因此无法保证`finalize()`方法会立即执行。
 * @author Percy
 * @date 2023/11/6
 */
public class SerializeOnFinalize implements Serializable {
    private String data;

    public SerializeOnFinalize(String data) {
        this.data = data;
    }

    @Override
    protected void finalize() throws Throwable {
        try {
            // 将对象序列化到文件中
            try (FileOutputStream fileOut = new FileOutputStream("serializedObject.ser")) {
                ObjectOutputStream out = new ObjectOutputStream(fileOut);
                out.writeObject(this);
                out.close();
            }
            System.out.println("对象已序列化到文件中");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            super.finalize();
        }
    }

    public static void main(String[] args) {
        SerializeOnFinalize obj = new SerializeOnFinalize("Hello World");

        // 将对象置为null，使其成为垃圾回收的候选对象
        obj = null;

        // 手动进行垃圾回收
        System.gc();

        System.out.println(UUID.randomUUID());
    }
}

ZK分布式锁实现 https://www.php.cn/faq/466231.html
ZooKeeper是一个为分布式应用提供一致性服务的开源组件，它内部是一个分层的文件系统目录树结构，规定同一个目录下只能有一个唯一文件名。基于ZooKeeper实现分布式锁的步骤如下：
（1）创建一个目录mylock；
（2）线程A想获取锁就在mylock目录下创建临时顺序节点；
（3）获取mylock目录下所有的子节点，然后获取比自己小的兄弟节点，如果不存在，则说明当前线程顺序号最小，获得锁；
（4）线程B获取所有节点，判断自己不是最小节点，设置监听比自己次小的节点；
（5）线程A处理完，删除自己的节点，线程B监听到变更事件，判断自己是不是最小的节点，如果是则获得锁。
Apache的开源库Curator，它是一个ZooKeeper客户端，Curator提供的InterProcessMutex是分布式锁的实现，acquire方法用于获取锁，release方法用于释放锁。
优点：具备高可用、可重入、阻塞锁特性，可解决失效死锁问题。
缺点：因为需要频繁的创建和删除节点，性能上不如Redis方式。主要原因是写操作（获取锁释放锁）都需要在Leader上执行，然后同步到follower。

  1. 1
  2. 2
  3. 3
  4. 4
  5. ...
  6. 10