在JAVA中具有优先级的互斥

Question

我需要构建一个具有优先级的“不公平信号量”。例如：当优先级为1的线程想要获取信号量时，它只需等待具有相同优先级的另一个线程完成，然后就可以获取（）。但是，当优先级为2的线程想要获取信号量时，它必须等待优先级为1的所有线程完成后才能使用信号量，然后尝试获取（）。我总共有4个不同的优先事项。这是我尝试过的，但没有成功。

有人有什么解决办法吗？

public class UnfairSemaphore
{
    private Semaphore mPrior1;
    private Semaphore mPrior2;
    private Semaphore mPrior3;
    private Semaphore mPrior4;

    public UnfairSemaphore()
    {
        mPrior1 = new Semaphore(1);
        mPrior2 = new Semaphore(1);
        mPrior3 = new Semaphore(1);
        mPrior4 = new Semaphore(1);
    }

    public void acquire(int priority) throws InterruptedException
    {
        if(priority == 1)
        {
            mPrior1.acquire();
        }
        else if(priority == 2)
        {
            while(mPrior1.hasQueuedThreads() && mPrior1.availablePermits() <=0)
            {
                //wait();
            }
            mPrior2.acquire();
            mPrior1.acquire();
        }
        else if(priority == 3)
        {
            while(mPrior1.hasQueuedThreads() && mPrior1.availablePermits() <=0 && mPrior2.hasQueuedThreads() && mPrior2.availablePermits() <=0)
            {
                //wait();
            }
            mPrior3.acquire();
            mPrior2.acquire();
            mPrior1.acquire();
        }
        else
        {
            while(mPrior1.hasQueuedThreads() && mPrior1.availablePermits() <=0 && mPrior2.hasQueuedThreads() && mPrior2.availablePermits() <=0 && mPrior3.hasQueuedThreads() && mPrior3.availablePermits() <=0)
            {
                //wait();
            }
            mPrior4.acquire();
            mPrior3.acquire();
            mPrior2.acquire();
            mPrior1.acquire();
        }
    }

    public void release(int priority)
    {
        if(priority == 1)
        {
            mPrior1.release();
        }
        else if(priority == 2)
        {           
            mPrior1.release();
            mPrior2.release();          
        }
        else if(priority == 3)
        {           
            mPrior1.release();
            mPrior2.release();
            mPrior3.release();
        }
        else
        {           
            mPrior1.release();
            mPrior2.release();
            mPrior3.release();
            mPrior4.release();
        }
        //notifyAll();
    }
}

Answer 1

为什么要自己管理线程？

您应该使用Thread类中的synchronized关键字和setPriority方法。

查看以下链接：

https://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html#setPriority（int）

https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html

Answer 2

基本要求是，我们有一群等待的线程，每个线程都有一个优先级。在发布时，我们选择一个优先级最高的等待线程，并将其唤醒。

这可以通过锁定支持中的线程park（）和unpark（）来完成。它是一个低级并发工具，但我们不使用它来实现精英化；我们之所以使用它，是因为它最自然地模拟了我们的解决方案。

首先，我们需要一个存储等待线程及其优先级的数据结构。你可以通过多种方式做到这一点。

    void storeWaitingThread(Integer priority, Thread thread) { ... }

    // select and remove a waiting thread with highest priority; return null if none.
    Thread selectWaitingThread(){ ... }

现在，release（）将只选择一个等待的线程，然后对其进行解压

final Object lock = new Object();

volatile Thread owningThread;

public void release()
{
    synchronized (lock)
    {
        Thread nextOwner = selectWaitingThread();
        owningThread = nextOwner;
    }
    LockSupport.unpark(owningThread);
}

<代码>获取（优先级）将当前线程存储为等待线程；驻车，直到选中为止

public void acquire(int priority)
{
    Thread thisThread = Thread.currentThread();
    synchronized (lock)
    {
        if(owningThread==null)
        {
            owningThread=thisThread;
            return;
        }
        storeWaitingThread(priority, thisThread);
    }

    while(owningThread!=thisThread)
    {
        LockSupport.park();
        // interrupt ignored. // todo handle interrupt
    }
}

请参阅完整代码https://gist.github.com/zhong-j-yu/3ea91194f55d91059789

请注意，我们的获取将忽略中断。如果它应该保释中断，请在park（）唤醒后添加一些逻辑。