import java.util.ArrayList;
import java.util.List;

public class MemoryLeakExample {
    private static List<Object> list = new ArrayList<>();
    
    public static void main(String[] args) {
        // Создаем утечку памяти, добавляя объекты в список, но никогда их не удаляя
        while (true) {
            list.add(new Object());
        }
    }
}
В этом примере список list продолжает расти, так как новые объекты постоянно добавляются, но никогда не удаляются. В итоге программа столкнется с OutOfMemoryError.

public class GradualMemoryLeak {
    private static List<String> cache = new ArrayList<>();
    
    public void addData() {
        for (int i = 0; i < 1000; i++) {
            cache.add("Data-" + i);
        }
    }
}
Если метод addData вызывается многократно без очистки списка cache, то список будет постоянно увеличиваться, вызывая утечку памяти.

public class StaticFieldMemoryLeak {
    private static List<Object> staticList = new ArrayList<>();
    
    public void addObject(Object obj) {
        staticList.add(obj);
    }
}
Здесь статическое поле staticList сохраняет все добавленные объекты, и они никогда не удаляются, что приводит к утечке памяти.

public class EventListenerMemoryLeak {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Example");
        JButton button = new JButton("Click Me");
        button.addActionListener(e -> System.out.println("Button clicked!"));

        frame.add(button);
        frame.setSize(200, 200);
        frame.setVisible(true);
        // Закрываем окно, но слушатель остается в памяти
        frame.dispose();
    }
}
В этом примере, если не удалить слушатели ActionListener перед dispose(), объект button и все связанные объекты будут продолжать удерживаться в памяти.

public class ThreadMemoryLeak {
    public void createThread() {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(10000);  // Ожидание в течение длительного времени
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread.start();
    }
}
Если потоки создаются многократно и не завершаются корректно, то их память будет постепенно заполняться.

jmap -dump:format=b,file=heap_dump.hprof <PID>

import java.io.*;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) {
            System.out.println(reader.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
В этом примере ресурс автоматически закрывается, даже если возникает исключение.

public class Counter {
    private int count = 0;

    public void increment() {
        count++; // Неатомарная операция: чтение, увеличение, запись
    }

    public int getCount() {
        return count;
    }
}

public class RaceConditionExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount()); // Ожидаем 2000, но результат может быть меньше
    }
}

public class DeadlockExample {

    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            System.out.println("Thread 1: Holding lock1...");
            try { Thread.sleep(50); } catch (InterruptedException e) {}

            synchronized (lock2) {
                System.out.println("Thread 1: Acquired lock2.");
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            System.out.println("Thread 2: Holding lock2...");
            try { Thread.sleep(50); } catch (InterruptedException e) {}

            synchronized (lock1) {
                System.out.println("Thread 2: Acquired lock1.");
            }
        }
    }

    public static void main(String[] args) {
        DeadlockExample demo = new DeadlockExample();

        Thread t1 = new Thread(demo::method1);
        Thread t2 = new Thread(demo::method2);

        t1.start();
        t2.start();
    }
}

public class LivelockExample {

    static class Worker {
        private boolean active = true;

        public synchronized void work(Worker other) {
            while (active) {
                System.out.println(Thread.currentThread().getName() + " is working...");
                try { Thread.sleep(50); } catch (InterruptedException e) {}

                if (other.isActive()) {
                    System.out.println(Thread.currentThread().getName() + " is waiting...");
                    continue;
                }
                break;
            }
        }

        public synchronized void setActive(boolean active) {
            this.active = active;
        }

        public synchronized boolean isActive() {
            return active;
        }
    }

    public static void main(String[] args) {
        Worker w1 = new Worker();
        Worker w2 = new Worker();

        Thread t1 = new Thread(() -> w1.work(w2), "Worker 1");
        Thread t2 = new Thread(() -> w2.work(w1), "Worker 2");

        t1.start();
        t2.start();
    }
}

private static volatile boolean running = true;

public void run() {
    while (running) {
        // Выполняем задачу
    }
}