java - Java中使用双计数器进行同步

Question

我有一个奇怪的同步架构，我正在寻找一个优雅的解决方案。我已经有了一个解决方案，但我不能说它的有效性，而且它也有点难看。这就是问题所在，希望有人能帮助我。

有 2 组可以启动和运行的任务。每个任务都有自己的线程。这两组都从一个负责同步部分的父类(super class)扩展而来。为了简单起见，我将这两个组称为 A 组和 B 组。

条件:

• 如果只有 B 组任务在运行，那么它们可以同时运行并且不会互相干扰。

• 如果启动 A 组任务*，则 B 组任务的构造函数应该失败并出现异常。即使 A 组任务已在运行，也可以创建任意数量的 A 组任务

• 在所有当前 B 组任务完成之前，A 组任务无法执行。 (*来自上方)

• 一次只能运行 1 个组 A 任务。他们必须排队。 (只要前面的条件仍然适用，可以选择在两个 A 组任务运行之间阻塞 B 组任务)

我相信我的方法有效，但我不喜欢它的工作方式，因为它使用了许多不同的同步点，而且我在等待计数器时会 sleep 。无论如何，代码如下

public abstract class LockableTask<Params> extends AsyncTask {

private final boolean groupA;
private static Boolean locked = false;
private static final Semaphore semLock = new Semaphore(1);
private static int count = 0;

public LockableTask(boolean groupA) {
    this.groupA = groupA;
    synchronized (locked) {
        if (locked && !groupA) {
            throw new InputException("We are locked, please wait");
        }
    }
}

@Override
protected final AsyncReturn doInBackground(Params... params) {
    if (!groupA) {
        synchronized (locked) {
            count++;
        }
    }

    try {
        if (groupA) {
            semLock.acquireUninterruptibly();
            synchronized (locked) {
                locked = true;
            }

            while (true) {
                synchronized (locked) {
                    if (count == 0) {
                        break;
                    }
                }

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {}
            }
        }
        return runInBackground(params);
    } finally {
        synchronized (locked) {
            if (groupA) {
                locked = false;
            } else {
                count--;
            }
        }

        if (groupA) {
            semLock.release();
        }
    }
}

protected abstract AsyncReturn runInBackground(Params... params);
}

如果有人有更好的解决方案，即使只是好一点，那就太好了

Answer 1

听起来你想使用 ReadWriteLock 。让A组的每个任务获取其readLock() B组的每个任务获取其writeLock() .

这样，任意数量的 A 组任务可以同时运行，但 B 组中只能运行一个任务(此时其他 A 组任务不能运行)。

ReadWriteLock rwLock = getSharedReadWriteLock();
Lock lock = groupA ? rwLock.readLock() : rwLock.writeLock();
lock.lock();
try {
  return runInBackground(params);
} finally {
  lock.unlock();
}