Что такое native в Object?

Native методы в Java Object

Native методы — это методы, реализованные на языке C/C++ (а не на Java), которые используют Java Native Interface (JNI) для взаимодействия с операционной системой, аппаратным обеспечением или другим нативным кодом. В классе Object есть несколько критически важных native методов, которые работают на низком уровне с памятью и потоками.

Основные native методы в Object

1. hashCode() — native реализация

Метод hashCode() часто имеет native реализацию, которая генерирует хеш на основе адреса объекта в памяти:

public native int hashCode();

Дефолтная реализация:

• Генерирует хеш на основе внутреннего состояния объекта
• В HotSpot JVM использует адрес объекта в памяти
• Может быть переопределена для оптимизации

Object obj1 = new Object();
Object obj2 = new Object();

// Дефолтные хеши основаны на адресах в памяти
System.out.println(obj1.hashCode()); // e.g. 1234567
System.out.println(obj2.hashCode()); // e.g. 1234568

// Переопределение для пользовательского класса
public class User {
    private String name;
    
    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

2. wait() — native метод для синхронизации

Метод wait() реализован на нативном уровне для взаимодействия с монитором объекта:

public final native void wait(long timeoutMillis) throws InterruptedException;
public final void wait(long timeoutMillis, int nanos) throws InterruptedException;
public final void wait() throws InterruptedException;

Этот метод:

• Освобождает монитор объекта
• Переводит поток в режим ожидания
• Пробуждается при вызове notify() или notifyAll()

public class Producer implements Runnable {
    private Buffer buffer;
    
    @Override
    public void run() {
        synchronized(buffer) {
            // Производим данные
            buffer.add("item");
            // Уведомляем потребителей
            buffer.notifyAll();
        }
    }
}

public class Consumer implements Runnable {
    private Buffer buffer;
    
    @Override
    public void run() {
        synchronized(buffer) {
            while(buffer.isEmpty()) {
                try {
                    // Ждём данные
                    buffer.wait();
                } catch(InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            // Обрабатываем данные
            String item = buffer.remove();
        }
    }
}

3. notify() и notifyAll() — native методы

Эти native методы пробуждают потоки, ожидающие на мониторе объекта:

public final native void notify();
public final native void notifyAll();

• notify() пробуждает один случайный ожидающий поток
• notifyAll() пробуждает все ожидающие потоки

public class SharedResource {
    private volatile boolean available = false;
    
    public synchronized void waitForResource() throws InterruptedException {
        while(!available) {
            wait(); // Ждём native монитор
        }
    }
    
    public synchronized void notifyAvailable() {
        available = true;
        notifyAll(); // Native уведомление всех потоков
    }
}

Как работают native методы под капотом

JNI механизм

Native методы используют Java Native Interface для вызова кода на C/C++:

// Декларация native метода в Java
public class MemoryUtils {
    // Native реализация в C++
    public static native void allocateMemory(long size);
    
    // Загрузка native библиотеки
    static {
        System.loadLibrary("memoryutils");
    }
}

// Использование
MemoryUtils.allocateMemory(1024 * 1024); // Выделить 1 MB

Взаимодействие с операционной системой

Native методы в Object взаимодействуют с ОС для реализации синхронизации потоков:

// На уровне ОС (Linux/Windows)
// wait() использует futex (fast userspace mutex) на Linux
// notify() пробуждает потоки через системные вызовы ОС

Практические примеры

Правильное использование wait/notify

public class ThreadSafeCounter {
    private int count = 0;
    private final int MAX_COUNT = 10;
    
    public synchronized void increment() throws InterruptedException {
        while(count >= MAX_COUNT) {
            wait(); // Ждём, пока count снизится
        }
        count++;
        System.out.println("Increased: " + count);
        notifyAll(); // Уведомляем всех (native вызов)
    }
    
    public synchronized int getCount() {
        return count;
    }
    
    public synchronized void reset() {
        count = 0;
        notifyAll(); // Native уведомление
    }
}

Использование для производителя-потребителя

public class BlockingQueue<T> {
    private final Queue<T> queue = new LinkedList<>();
    private final int capacity;
    
    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }
    
    public synchronized void put(T item) throws InterruptedException {
        while(queue.size() >= capacity) {
            wait(); // Native wait на мониторе объекта
        }
        queue.offer(item);
        notifyAll(); // Native notifyAll
    }
    
    public synchronized T take() throws InterruptedException {
        while(queue.isEmpty()) {
            wait(); // Native wait
        }
        T item = queue.poll();
        notifyAll(); // Native notifyAll
        return item;
    }
}

Почему native методы в Object?

• Производительность: Критичные операции реализованы на C/C++
• Прямой доступ к памяти: Синхронизация потоков требует взаимодействия с ОС
• Универсальность: Все объекты получают базовую функциональность
• Безопасность: JVM контролирует доступ через synchronized блоки

Native методы в Object — фундамент многопоточности и синхронизации в Java.