在Java中，避免超买（overbuying）和超卖（overselling）问题通常涉及到多线程并发操作时的线程安全性和同步控制。这些问题通常与共享资源的并发访问有关，如共享变量、共享数据结构等。以下是一些常见的方法来避免超买和超卖问题：

1. 使用线程安全的数据结构：Java提供了许多线程安全的数据结构，如ConcurrentHashMap、ConcurrentLinkedQueue等。这些数据结构在设计上考虑了并发访问，并提供了内置的同步机制，可以避免超买和超卖问题。

2. 使用同步控制：通过使用synchronized关键字或者ReentrantLock等锁机制来保护共享资源的访问，确保在同一时间只有一个线程可以访问共享资源，避免出现并发访问问题。

3. 使用原子类：Java提供了一系列的原子类，如AtomicInteger、AtomicLong等，它们提供了一些原子操作，可以在不需要显式加锁的情况下保证操作的原子性，避免出现超买和超卖问题。

4. 使用并发工具类：Java的java.util.concurrent包提供了许多并发工具类，如CountDownLatch、Semaphore、CyclicBarrier等，可以帮助管理多线程之间的同步和协作，避免出现超买和超卖问题。

5. 避免死锁：在设计多线程应用时，要注意避免死锁问题，即多个线程相互等待对方释放资源的情况，导致所有线程无法继续执行。

总的来说，要避免超买和超卖问题，关键在于合理设计并发访问共享资源的策略，使用合适的同步控制手段，以及避免常见的并发问题，如死锁等。同时，了解Java提供的线程安全类和工具，可以帮助更好地管理多线程并发操作，确保程序的正确性和性能。

使用synchronized关键字

public class OverbuyOversellExample {
    private static int stock = 10; // 共享资源：库存

    public static synchronized void buyProduct() {
        if (stock > 0) {
            System.out.println("购买成功，剩余库存：" + --stock);
        } else {
            System.out.println("库存不足，购买失败");
        }
    }

    public static void main(String[] args) {
        // 模拟多个线程同时购买商品
        for (int i = 1; i <= 15; i++) { // 假设有15个人同时购买商品
            new Thread(() -> {
                buyProduct();
            }).start();
        }
    }
}

使用ReentrantLock锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class OverbuyOversellExample {
    private static int stock = 10; // 共享资源：库存
    private static Lock lock = new ReentrantLock(); // 创建ReentrantLock实例

    public static void buyProduct() {
        try {
            lock.lock(); // 获取锁
            if (stock > 0) {
                System.out.println("购买成功，剩余库存：" + --stock);
            } else {
                System.out.println("库存不足，购买失败");
            }
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public static void main(String[] args) {
        // 模拟多个线程同时购买商品
        for (int i = 1; i <= 15; i++) { // 假设有15个人同时购买商品
            new Thread(() -> {
                buyProduct();
            }).start();
        }
    }
}

使用AtomicInteger

import java.util.concurrent.atomic.AtomicInteger;

public class OverbuyOversellExample {
    private static AtomicInteger stock = new AtomicInteger(10); // 共享资源：库存

    public static void buyProduct() {
        int remainingStock = stock.decrementAndGet();
        if (remainingStock >= 0) {
            System.out.println("购买成功，剩余库存：" + remainingStock);
        } else {
            System.out.println("库存不足，购买失败");
        }
    }

    public static void main(String[] args) {
        // 模拟多个线程同时购买商品
        for (int i = 1; i <= 15; i++) { // 假设有15个人同时购买商品
            new Thread(() -> {
                buyProduct();
            }).start();
        }
    }
}