JAVA中具有优先级的互斥

我需要构建一个我称之为具有优先级的不公平信号量。 例如：当优先级为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();
    }
}

---

为什么要自己管理线程

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

请查看以下链接：

---

为什么要自己管理线程

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

请查看以下链接：

---

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

这可以通过中的线程驻车和解压来完成。它是一个低级并发工具，但我们不使用它来实现精英化；我们使用它是因为它最自然地模拟了我们的解决方案

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

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

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

现在，release将只选择一个等待的线程并将其解压

acquirepriority将当前线程存储为等待线程；停车，直到选定为止

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
    }
}

请参阅

---

请注意，我们的获取将忽略中断。如果它应该避免中断，那么在park唤醒后添加一些逻辑。

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

这可以通过中的线程驻车和解压来完成。它是一个低级并发工具，但我们不使用它来实现精英化；我们使用它是因为它最自然地模拟了我们的解决方案

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

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

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

现在，release将只选择一个等待的线程并将其解压

acquirepriority将当前线程存储为等待线程；停车，直到选定为止

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
    }
}

请参阅

---

请注意，我们的获取将忽略中断。如果它应该避免中断，请在park醒来后添加一些逻辑。

但它不起作用它做了什么？但它不起作用它做了什么？可能是个好建议，但Java标准版中的优先级没有什么意义。如果OP需要优先级来真正意义上的东西，例如，如果应用程序有硬实时需求，那么它应该在实时Java平台上运行。Hell synchronized一开始就不是一个公平锁，公平锁的wrt性能很糟糕问题在于优先级并不取决于Thead，而是取决于线程需要访问ressource的位置。然后，有时优先级较低，有时优先级较高。这可能是个好建议，但Java标准版中的优先级意义不大。如果OP需要优先级来真正意义上的东西，例如，如果应用程序有硬实时需求，那么它应该在实时Java平台上运行。Hell synchronized一开始就不是一个公平锁，公平锁的wrt性能很糟糕问题在于优先级并不取决于Thead，而是取决于线程需要访问ressource的位置。然后，有时优先级较低，有时优先级较高。我没有测试过：自己试试看是否有效。我没有测试过：自己试试看是否有效。