為了避免Java中的線程饑餓現象，您可以采取以下措施：

1. 公平鎖：使用java.util.concurrent.locks.ReentrantLock的公平鎖模式。在創建鎖的時候，通過傳入true參數來聲明這是一個公平鎖。公平鎖會按照線程請求鎖的順序來分配，從而避免了線程饑餓。

import java.util.concurrent.locks.ReentrantLock;

public class FairLockExample {
    private final ReentrantLock fairLock = new ReentrantLock(true);

    public void doSomething() {
        fairLock.lock();
        try {
            // Do some work here
        } finally {
            fairLock.unlock();
        }
    }
}

2. 使用java.util.concurrent.Semaphore信號量：信號量可以用來限制對共享資源的訪問。通過設置合適的許可數量，可以確保線程按照預期的順序執行，從而避免線程饑餓。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(3); // Allow 3 threads to access the resource concurrently

    public void doSomething() {
        try {
            semaphore.acquire();
            // Do some work here
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            semaphore.release();
        }
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        SemaphoreExample example = new SemaphoreExample();

        for (int i = 0; i < 10; i++) {
            executorService.submit(() -> example.doSomething());
        }

        executorService.shutdown();
    }
}

3. 使用java.util.concurrent.PriorityBlockingQueue優先級隊列：優先級隊列可以根據元素的自然順序或者自定義的比較器來對元素進行排序。這樣，高優先級的線程將優先執行，從而避免了線程饑餓。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.TimeUnit;

class Task implements Runnable, Comparable<Task> {
    @Override
    public int compareTo(Task other) {
        // Define the priority order here (higher priority first)
        return Integer.compare(other.priority, this.priority);
    }

    @Override
    public void run() {
        // Do some work here
    }

    public int priority;
}

public class PriorityQueueExample {
    private final PriorityBlockingQueue<Task> taskQueue = new PriorityBlockingQueue<>();

    public void addTask(Task task) {
        taskQueue.add(task);
    }

    public void startProcessing() {
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        executorService.submit(() -> {
            while (!taskQueue.isEmpty()) {
                try {
                    Task task = taskQueue.take();
                    task.run();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        executorService.shutdown();
    }

    public static void main(String[] args) throws InterruptedException {
        PriorityQueueExample example = new PriorityQueueExample();

        // Add tasks with different priorities
        example.addTask(new Task(3));
        example.addTask(new Task(1));
        example.addTask(new Task(2));

        example.startProcessing();
    }
}

通過使用這些方法，您可以有效地避免線程饑餓現象，確保所有線程都能公平地訪問共享資源。