JMH ਬੈਂਚਮਾਰਕਸ ਵਿੱਚ ਮੈਮੋਰੀ ਇਕੱਤਰਤਾ ਦਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਨ ਕਰਨਾ

ਜਾਵਾ ਬੈਂਚਮਾਰਕਸ ਵਿੱਚ ਮੈਮੋਰੀ ਚੁਣੌਤੀਆਂ ਨੂੰ ਸਮਝਣਾ

ਜਾਵਾ ਵਿੱਚ ਬੈਂਚਮਾਰਕਿੰਗ ਇੱਕ ਗਿਆਨਵਾਨ ਅਨੁਭਵ ਹੋ ਸਕਦਾ ਹੈ, ਤੁਹਾਡੇ ਕੋਡ ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਦੀਆਂ ਬਾਰੀਕੀਆਂ ਨੂੰ ਪ੍ਰਗਟ ਕਰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਅਚਾਨਕ ਮੁੱਦੇ, ਜਿਵੇਂ ਕਿ ਦੁਹਰਾਓ ਦੇ ਵਿਚਕਾਰ ਮੈਮੋਰੀ ਇਕੱਠਾ ਹੋਣਾ, ਨਤੀਜਿਆਂ ਨੂੰ ਭਰੋਸੇਯੋਗ ਨਹੀਂ ਬਣਾ ਸਕਦਾ ਹੈ। 😓

Java Microbenchmark Harness (JMH) ਵਰਗੇ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਸੀਂ ਦੁਹਰਾਓ ਵਿੱਚ ਹੀਪ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਵਿੱਚ ਹੌਲੀ-ਹੌਲੀ ਵਾਧਾ ਦੇਖ ਸਕਦੇ ਹੋ। ਇਹ ਵਿਵਹਾਰ ਗੁੰਮਰਾਹਕੁੰਨ ਮਾਪਾਂ ਦੀ ਅਗਵਾਈ ਕਰ ਸਕਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਹੀਪ ਮੈਮੋਰੀ ਨੂੰ ਪ੍ਰੋਫਾਈਲ ਕਰਨਾ। ਸਮੱਸਿਆ ਅਸਧਾਰਨ ਨਹੀਂ ਹੈ, ਪਰ ਇਸ ਨੂੰ ਅਕਸਰ ਉਦੋਂ ਤੱਕ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਹ ਬੈਂਚਮਾਰਕ ਵਿੱਚ ਵਿਘਨ ਨਹੀਂ ਪਾਉਂਦਾ।

ਇਸ ਅਸਲ-ਜੀਵਨ ਦੇ ਦ੍ਰਿਸ਼ 'ਤੇ ਵਿਚਾਰ ਕਰੋ: ਤੁਸੀਂ ਹੀਪ ਮੈਮੋਰੀ ਵਰਤੋਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਲਈ JMH ਬੈਂਚਮਾਰਕ ਚਲਾ ਰਹੇ ਹੋ। ਹਰੇਕ ਵਾਰਮਅੱਪ ਅਤੇ ਮਾਪ ਦੁਹਰਾਓ ਇੱਕ ਵਧਦੀ ਬੇਸਲਾਈਨ ਮੈਮੋਰੀ ਫੁੱਟਪ੍ਰਿੰਟ ਦਿਖਾਉਂਦਾ ਹੈ। ਅੰਤਮ ਦੁਹਰਾਓ ਦੁਆਰਾ, ਵਰਤਿਆ ਗਿਆ ਢੇਰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਵਧਿਆ ਹੈ, ਨਤੀਜਿਆਂ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। ਕਾਰਨ ਦੀ ਪਛਾਣ ਕਰਨਾ ਚੁਣੌਤੀਪੂਰਨ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਸਹੀ ਕਦਮਾਂ ਦੀ ਲੋੜ ਹੈ।

ਇਹ ਗਾਈਡ JMH ਬੈਂਚਮਾਰਕਾਂ ਵਿੱਚ ਅਜਿਹੇ ਮੈਮੋਰੀ ਮੁੱਦਿਆਂ ਨੂੰ ਘਟਾਉਣ ਲਈ ਵਿਹਾਰਕ ਰਣਨੀਤੀਆਂ ਦੀ ਪੜਚੋਲ ਕਰਦੀ ਹੈ। ਉਦਾਹਰਣਾਂ ਅਤੇ ਹੱਲਾਂ ਤੋਂ ਡਰਾਇੰਗ, ਇਹ ਸੂਝ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਨਾ ਸਿਰਫ ਮੈਮੋਰੀ ਵਰਤੋਂ ਨੂੰ ਸਥਿਰ ਕਰਦਾ ਹੈ ਬਲਕਿ ਬੈਂਚਮਾਰਕਿੰਗ ਸ਼ੁੱਧਤਾ ਵਿੱਚ ਵੀ ਸੁਧਾਰ ਕਰਦਾ ਹੈ। 🛠️ ਇਹਨਾਂ ਕਮੀਆਂ ਤੋਂ ਕਿਵੇਂ ਬਚਣਾ ਹੈ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਤੁਹਾਡੇ ਬੈਂਚਮਾਰਕ ਭਰੋਸੇਯੋਗ ਹਨ, ਇਹ ਜਾਣਨ ਲਈ ਜੁੜੇ ਰਹੋ।

JMH ਵਿੱਚ ਮੈਮੋਰੀ ਇਕੱਠਾ ਕਰਨ ਲਈ ਪ੍ਰਭਾਵੀ ਤਕਨੀਕਾਂ

ਉੱਪਰ ਪ੍ਰਦਾਨ ਕੀਤੀ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਪ੍ਰੋਸੈਸ ਬਿਲਡਰ ਜਾਵਾ ਵਿੱਚ ਕਲਾਸ ਬੈਂਚਮਾਰਕਿੰਗ ਲਈ ਵੱਖਰੀ JVM ਪ੍ਰਕਿਰਿਆਵਾਂ ਸ਼ੁਰੂ ਕਰਨ ਲਈ। ਇਹ ਵਿਧੀ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ ਦੁਹਰਾਓ ਦੁਆਰਾ ਵਰਤੀ ਗਈ ਮੈਮੋਰੀ ਅਗਲੀ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਕਰਦੀ ਹੈ। ਵੱਖ-ਵੱਖ JVM ਉਦਾਹਰਨਾਂ ਵਿੱਚ ਬੈਂਚਮਾਰਕ ਨੂੰ ਅਲੱਗ ਕਰਕੇ, ਤੁਸੀਂ ਹਰੇਕ ਦੁਹਰਾਅ ਲਈ ਹੀਪ ਮੈਮੋਰੀ ਸਥਿਤੀ ਨੂੰ ਰੀਸੈਟ ਕਰਦੇ ਹੋ। ਪਿਛਲੀਆਂ ਯਾਤਰਾਵਾਂ ਤੋਂ ਯਾਤਰੀਆਂ ਨੂੰ ਲਿਜਾਣ ਵੇਲੇ ਕਾਰ ਦੀ ਈਂਧਨ ਕੁਸ਼ਲਤਾ ਨੂੰ ਮਾਪਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਦੀ ਕਲਪਨਾ ਕਰੋ। ਪ੍ਰੋਸੈਸਬਿਲਡਰ ਹਰ ਵਾਰ ਖਾਲੀ ਕਾਰ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਵਰਗਾ ਕੰਮ ਕਰਦਾ ਹੈ, ਵਧੇਰੇ ਸਹੀ ਰੀਡਿੰਗ ਲਈ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। 🚗

ਇੱਕ ਹੋਰ ਪਹੁੰਚ ਦਾ ਲਾਭ ਉਠਾਉਂਦਾ ਹੈ System.gc() ਕਮਾਂਡ, ਕੂੜਾ ਇਕੱਠਾ ਕਰਨ ਲਈ ਇੱਕ ਵਿਵਾਦਪੂਰਨ ਪਰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕਾ ਹੈ। ਇਸ ਕਮਾਂਡ ਨੂੰ ਐਨੋਟੇਟ ਕੀਤੇ ਢੰਗ ਵਿੱਚ ਰੱਖ ਕੇ @Setup(Level.Iteration), JMH ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਹਰੇਕ ਬੈਂਚਮਾਰਕ ਦੁਹਰਾਅ ਤੋਂ ਪਹਿਲਾਂ ਕੂੜਾ ਇਕੱਠਾ ਕੀਤਾ ਜਾਵੇ। ਇਹ ਸੈੱਟਅੱਪ ਪਿਛਲੇ ਕੰਮ ਤੋਂ ਗੜਬੜ ਤੋਂ ਬਚਣ ਲਈ ਕਾਰਜਾਂ ਦੇ ਵਿਚਕਾਰ ਤੁਹਾਡੇ ਵਰਕਸਪੇਸ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਦੇ ਸਮਾਨ ਹੈ। ਜਦੋਂ ਕਿ System.gc() ਤੁਰੰਤ ਕੂੜਾ ਇਕੱਠਾ ਕਰਨ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ, ਬੈਂਚਮਾਰਕਿੰਗ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ, ਇਹ ਅਕਸਰ ਮੈਮੋਰੀ ਬਿਲਡ-ਅਪ ਨੂੰ ਘਟਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ, ਸਹੀ ਪ੍ਰਦਰਸ਼ਨ ਮੈਟ੍ਰਿਕਸ ਲਈ ਇੱਕ ਨਿਯੰਤਰਿਤ ਵਾਤਾਵਰਣ ਬਣਾਉਂਦਾ ਹੈ।

ਜਿਵੇਂ ਐਨੋਟੇਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ @ਫੋਰਕ, @ਗਰਮ ਕਰਨਾ, ਅਤੇ @ਮਾਪ JMH ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਬੈਂਚਮਾਰਕਿੰਗ ਪ੍ਰਕਿਰਿਆ ਉੱਤੇ ਵਧੀਆ ਨਿਯੰਤਰਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, @Fork(ਮੁੱਲ = 1, ਵਾਰਮਅੱਪ = 1) ਵਾਰਮਅੱਪ ਦੁਹਰਾਅ ਨਾਲ ਇੱਕ ਸਿੰਗਲ ਫੋਰਕ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਸੰਚਤ ਮੈਮੋਰੀ ਮੁੱਦਿਆਂ ਨੂੰ ਰੋਕਦਾ ਹੈ ਜੋ ਮਲਟੀਪਲ ਫੋਰਕਾਂ ਤੋਂ ਪੈਦਾ ਹੋ ਸਕਦੇ ਹਨ। ਵਾਰਮਅੱਪ ਦੁਹਰਾਓ ਅਸਲ ਬੈਂਚਮਾਰਕਿੰਗ ਲਈ JVM ਨੂੰ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਸਰਵੋਤਮ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਸਰਤ ਤੋਂ ਪਹਿਲਾਂ ਗਰਮ ਹੋਣ ਦੇ ਬਰਾਬਰ ਹੈ। 🏋️‍♂️ ਇਹ ਸੰਰਚਨਾਵਾਂ JMH ਨੂੰ ਇਕਸਾਰ ਅਤੇ ਭਰੋਸੇਮੰਦ ਬੈਂਚਮਾਰਕਾਂ ਲਈ ਇੱਕ ਮਜ਼ਬੂਤ ​​ਟੂਲ ਬਣਾਉਂਦੀਆਂ ਹਨ।

ਅੰਤ ਵਿੱਚ, ਯੂਨਿਟ ਟੈਸਟਿੰਗ ਉਦਾਹਰਨ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਮੈਮੋਰੀ ਵਿਵਹਾਰ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਮਾਣਿਤ ਕਰਨਾ ਹੈ। ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਖਾਸ ਓਪਰੇਸ਼ਨਾਂ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਮੈਮੋਰੀ ਵਰਤੋਂ ਦੀ ਤੁਲਨਾ ਕਰਕੇ Runtime.getRuntime(), ਅਸੀਂ ਆਪਣੇ ਕੋਡ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਇਕਸਾਰਤਾ ਅਤੇ ਸਥਿਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹਾਂ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਕੋਈ ਅਚਾਨਕ ਖਰਚਾ ਨਾ ਲੱਗੇ, ਖਰੀਦ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਆਪਣੇ ਬੈਂਕ ਖਾਤੇ ਦੇ ਬਕਾਏ ਦੀ ਜਾਂਚ ਕਰਨ ਬਾਰੇ ਸੋਚੋ। ਅਜਿਹੀਆਂ ਪ੍ਰਮਾਣਿਕਤਾਵਾਂ ਅਸਮਾਨਤਾਵਾਂ ਦੀ ਛੇਤੀ ਪਛਾਣ ਕਰਨ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹਨ ਕਿ ਤੁਹਾਡੇ ਬੈਂਚਮਾਰਕ ਸਾਰੇ ਵਾਤਾਵਰਣ ਵਿੱਚ ਅਰਥਪੂਰਨ ਹਨ।

import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.Throughput)
@Warmup(iterations = 5)
@Measurement(iterations = 5)
@Fork(value = 1, warmups = 1)
@State(Scope.Thread)
public class MemoryBenchmark {

    @Benchmark
    public int calculate() {
        // Simulating a computational task
        return (int) Math.pow(2, 16);
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class IsolatedBenchmark {

    public static void main(String[] args) {
        try {
            ProcessBuilder pb = new ProcessBuilder("java", "-jar", "benchmark.jar");
            pb.inheritIO();
            Process process = pb.start();
            process.waitFor();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.Throughput)
@Warmup(iterations = 5)
@Measurement(iterations = 5)
@Fork(1)
@State(Scope.Thread)
public class ResetMemoryBenchmark {

    @Setup(Level.Iteration)
    public void cleanUp() {
        System.gc(); // Force garbage collection
    }

    @Benchmark
    public int compute() {
        return (int) Math.sqrt(1024);
    }
}

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class BenchmarkTests {

    @Test
    void testMemoryUsageConsistency() {
        long startMemory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        int result = (int) Math.pow(2, 10);
        long endMemory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        assertTrue((endMemory - startMemory) < 1024, "Memory usage is inconsistent");
    }
}

ਮੈਮੋਰੀ ਗਰੋਥ ਨੂੰ ਸੰਬੋਧਨ ਕਰਨ ਲਈ JMH ਬੈਂਚਮਾਰਕ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਨਾ

JMH ਬੈਂਚਮਾਰਕ ਦੇ ਦੌਰਾਨ ਮੈਮੋਰੀ ਇਕੱਠਾ ਕਰਨਾ ਵਸਤੂ ਧਾਰਨ ਅਤੇ ਕਲਾਸ ਲੋਡਿੰਗ ਦੁਆਰਾ ਵੀ ਪ੍ਰਭਾਵਿਤ ਹੋ ਸਕਦਾ ਹੈ। ਜਦੋਂ JVM ਦੁਹਰਾਓ ਦੌਰਾਨ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ, ਤਾਂ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਇਹਨਾਂ ਵਸਤੂਆਂ ਦੇ ਹਵਾਲੇ ਤੁਰੰਤ ਕਲੀਅਰ ਨਾ ਕੀਤੇ ਜਾ ਸਕਣ, ਜਿਸ ਨਾਲ ਲਗਾਤਾਰ ਮੈਮੋਰੀ ਵਰਤੋਂ ਹੁੰਦੀ ਹੈ। ਇਸ ਨੂੰ ਵੱਡੇ ਆਬਜੈਕਟ ਗ੍ਰਾਫਾਂ ਜਾਂ ਸਥਿਰ ਖੇਤਰਾਂ ਵਾਲੇ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ ਵਧਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਅਣਜਾਣੇ ਵਿੱਚ ਹਵਾਲੇ ਰੱਖਦੇ ਹਨ। ਇਸ ਨੂੰ ਘਟਾਉਣ ਲਈ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡਾ ਬੈਂਚਮਾਰਕ ਕੋਡ ਬੇਲੋੜੇ ਸਥਿਰ ਸੰਦਰਭਾਂ ਤੋਂ ਬਚਦਾ ਹੈ ਅਤੇ ਜਿੱਥੇ ਉਚਿਤ ਹੋਵੇ ਕਮਜ਼ੋਰ ਸੰਦਰਭਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਅਜਿਹੇ ਅਭਿਆਸ ਕੂੜਾ ਇਕੱਠਾ ਕਰਨ ਵਾਲੇ ਨੂੰ ਅਣਵਰਤੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ। 🔄

ਇੱਕ ਹੋਰ ਅਕਸਰ ਨਜ਼ਰਅੰਦਾਜ਼ ਪਹਿਲੂ ਥਰਿੱਡ-ਸਥਾਨਕ ਵੇਰੀਏਬਲ ਦੀ ਭੂਮਿਕਾ ਹੈ। ਥ੍ਰੈਡਲੋਕਲ ਬੈਂਚਮਾਰਕਾਂ ਵਿੱਚ ਸੌਖਾ ਹੋ ਸਕਦਾ ਹੈ ਪਰ ਜੇਕਰ ਸਹੀ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਨਾ ਕੀਤਾ ਗਿਆ ਹੋਵੇ ਤਾਂ ਮੈਮੋਰੀ ਲੰਮੀ ਹੋ ਸਕਦੀ ਹੈ। ਹਰੇਕ ਥ੍ਰੈਡ ਵੇਰੀਏਬਲ ਦੀ ਆਪਣੀ ਕਾਪੀ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦਾ ਹੈ, ਜੋ, ਜੇਕਰ ਸਾਫ਼ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ, ਤਾਂ ਥ੍ਰੈਡ ਦਾ ਜੀਵਨ ਚੱਕਰ ਖਤਮ ਹੋਣ ਤੋਂ ਬਾਅਦ ਵੀ ਕਾਇਮ ਰਹਿ ਸਕਦਾ ਹੈ। ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਹਟਾ ਕੇ ThreadLocal.remove(), ਤੁਸੀਂ ਬੈਂਚਮਾਰਕ ਦੇ ਦੌਰਾਨ ਅਣਇੱਛਤ ਮੈਮੋਰੀ ਧਾਰਨ ਨੂੰ ਘਟਾ ਸਕਦੇ ਹੋ। ਇਹ ਪਹੁੰਚ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ ਦੁਹਰਾਓ ਦੁਆਰਾ ਵਰਤੀ ਗਈ ਮੈਮੋਰੀ ਅਗਲੀ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਖਾਲੀ ਹੋ ਜਾਂਦੀ ਹੈ।

ਅੰਤ ਵਿੱਚ, ਵਿਚਾਰ ਕਰੋ ਕਿ JVM ਕਲਾਸ ਲੋਡਿੰਗ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਦਾ ਹੈ। ਬੈਂਚਮਾਰਕ ਦੇ ਦੌਰਾਨ, ਜੇਐਮਐਚ ਬਾਰ ਬਾਰ ਕਲਾਸਾਂ ਨੂੰ ਲੋਡ ਕਰ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਸਥਾਈ ਪੀੜ੍ਹੀ (ਜਾਂ ਆਧੁਨਿਕ ਜੇਵੀਐਮ ਵਿੱਚ ਮੈਟਾਸਪੇਸ) ਫੁੱਟਪ੍ਰਿੰਟ ਵਧਦਾ ਹੈ। ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ @ਫੋਰਕ ਦੁਹਰਾਓ ਨੂੰ ਅਲੱਗ ਕਰਨ ਜਾਂ ਕਸਟਮ ਕਲਾਸ ਲੋਡਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਐਨੋਟੇਸ਼ਨ ਇਸ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦੀ ਹੈ। ਇਹ ਕਦਮ ਹਰੇਕ ਦੁਹਰਾਅ ਲਈ ਇੱਕ ਕਲੀਨਰ ਕਲਾਸ ਲੋਡਿੰਗ ਸੰਦਰਭ ਬਣਾਉਂਦੇ ਹਨ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ ਕਿ ਬੈਂਚਮਾਰਕ JVM ਦੇ ਅੰਦਰੂਨੀ ਤੱਤਾਂ ਦੀ ਕਲਾਤਮਕਤਾ ਦੀ ਬਜਾਏ ਰਨਟਾਈਮ ਪ੍ਰਦਰਸ਼ਨ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਤ ਕਰਦੇ ਹਨ। ਇਹ ਅਭਿਆਸ ਪ੍ਰੋਜੈਕਟਾਂ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਵਰਕਸਪੇਸ ਨੂੰ ਸਾਫ਼ ਕਰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਇੱਕ ਕੰਮ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰ ਸਕਦੇ ਹੋ। 🧹