Ограничение вызова метода / секунд в многопоточной среде

Question

Я разрабатываю механику для управления оружием в игре. У меня проблемы со скорострельностью, она хорошо работает с одним потоком, но кажется, что мой графический интерфейс вызывает метод fire() из нескольких потоков, что иногда вызывает непредвиденное поведение (несколько выстрелов выполняются очень быстро). Поэтому я добавил блокировку в методе (с AtomicBoolean флаг), но это только заставляет ошибку появляться реже.

Класс оружия

private final AtomicBoolean locked = new AtomicBoolean(false);
private final AtomicInteger fired = new AtomicInteger(0);

@Override
// returns true if a shot was fired; false otherwise
public boolean fire() {
    if (locked.compareAndSet(false, true)) {
        return false;
    }
    if (!canFire || reloading)
        return false;

    if (bulletsInMagazine > 0) {
        canFire = false;
        timeSinceLastShot = 0;
        bulletsInMagazine--;
        fired.incrementAndGet();
        if (bulletsInMagazine == 0) {
            reload();
        }
        locked.set(false);
        return true;
    }
    reload();
    locked.set(false);
    return false;
}

@Override
public void tick(int ms) {
    timeSinceLastShot += ms;
    if (timeSinceLastShot >= delayBetweenShotsMs) {
        canFire = true;
    }

    remainingReloadTime = Math.max(0, remainingReloadTime - ms);
    if (remainingReloadTime == 0 && reloading)
        processReloading();
}

Я написал модульный тест, который воспроизводит проблему... иногда.

Тестовое задание:

@Test
public void testFiringRate() {
    int nbBullets = weapon.getBulletsInMagazine();
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(16);
    for (int i = 0; i < 16; i++) {
        scheduledExecutorService.scheduleAtFixedRate(weapon::fire, 5, 10, TimeUnit.MILLISECONDS);
    }
    System.out.println("START firing");
    int ticks = 0;
    while (ticks < 100) {
        weapon.tick(100);
        ticks++;
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        int fired = nbBullets - weapon.getBulletsInMagazine();
        int reallyFired = weapon.getFiredShotCount();
        int diff = reallyFired - fired;
        if (diff != 0) {
            System.out.println(ticks + "\t" + fired + " shot(s)\t" + reallyFired + " really fired\t" + (diff != 0 ? "(+" + diff + ")" : ""));
        } else {
            System.out.print(".");
        }
    }
    System.out.println("\nSTOP firing");
    System.out.println(ticks + " Ticks");
    try {
        System.out.print("WAITING FOR ALL TASKS TO TERMINATE...");
        scheduledExecutorService.shutdown();
        scheduledExecutorService.awaitTermination(5, TimeUnit.SECONDS);
        System.out.println("DONE.");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    int bulletsAfter = weapon.getBulletsInMagazine();
    int fired = nbBullets - bulletsAfter;
    System.out.println("Shot fired: " + fired);
    int shotsFired = weapon.getFiredShotCount();
    System.out.println("Really fired: " + shotsFired);
    assertEquals(shotsFired, fired);
}

Что я получил (иногда): рассчитанные кадры на 1 или 2 меньше реальности (из AtomicInteger уволен)

Что я хочу: независимо от количества нитей, оружие должно учитывать скорость стрельбы.

Любая идея?

РЕДАКТИРОВАТЬ:

Я пытался инвертировать условие if:

if (!locked.compareAndSet(false, true)) {
    return false;
}

Это решило проблему из модульного теста, но теперь графический интерфейс запускается только один раз и никогда больше.

Answer 1

Я переместил тело метода в synchronized(this) заблокируйте как предложено @ichantz, и это работает, потому что я не могу воспроизвести ошибку после многих попыток.