while while循环等待期间

Question

我的应用程序有1个全局驱动程序，负责做低级别的工作。 然后我有2个线程，这两个线程使用无限循环来完成一些工作。我的问题是如何让1个线程尽可能地使用驱动程序，但给第二个线程在必要时使用它的机会。

为了详细说明，我的代码如下：

public class Game { 
    private static final Object LOCK = new Object(); 
    private static final Logger LOGGER = Logger.getLogger(Game.class); 

    private WebDriverController controller; 

    public Game(WebDriverController controler) { 
     this.controller = controller; 
    } 

    public void startThreadA() { 
     new Thread(new Runnable() { 
      @Override 
      public void run() { 
       while (true) { 
        synchronized (LOCK) { 
         controller.doSomethingA(); 
        } 
       } 
      } 
     }).start(); 
    } 

    public void startThreadB() { 
     new Thread(new Runnable() { 
      @Override 
      public void run() { 
       while (true) { 
        ... 
        ... 
        synchronized (LOCK) { 
         controller.doSomethingB(); 
        } 
        ... 
        ... 
       } 
      } 
     }).start(); 
    } 
} 

的逻辑是允许第一线程执行doSomethingA()尽可能，与第二线程只有获取锁来完成的小任务然后将锁返回到第一个线程。

使用此代码，第一个线程将持续使用控制器来完成它需要做的事情，而第二个线程在其同步块中等待。目前我已经解决了这个问题的方法是通过将暂停到第一线，给第二个线程有机会获得锁，如下所示：

public void startThreadA() { 
    new Thread(new Runnable() { 
     @Override 
     public void run() { 
      while (true) { 
       synchronized (LOCK) { 
        controller.doSomethingA(); 
       } 
       try { 
        Thread.sleep(1); 
       } catch (InterruptedException e) { 
        LOGGER.error(null, e); 
       } 
      } 
     } 
    }).start(); 
} 

这正好没有工作的打算，但它不” t看起来没错。我对每次迭代后的手动暂停都不满意，尤其是如果第二个线程不需要锁定，因为它浪费了时间。

我该如何更换暂停以提高效率？

Answer 1

我觉得你正在从错误的方向来处理这个问题，就像在你当前的设置中一样，线程A调用监视器的时间为99.999％，处理时间被浪费了。然而，由于我没有你的实际问题的足够的细节，这里是用的ReentrantLock与公平调度（FIFO）一个快速的解决方案：

protected final ReentrantLock lock = new ReentrantLock(true); // fair scheduling 

public void functionA() { 
    lock.lock(); 
    try { 
    controller.functionA(); 
    } finally { 
    lock.unlock(); 
    } 
} 

public void functionB() { 
    lock.lock(); 
    try { 
    controller.functionB(); 
    } finally { 
    lock.unlock(); 
    } 
} 

说明：

如果线程A目前持有锁定和线程B调用，B保证在A释放后立即接收显示器，即使A立即（在任何线程切换发生之前）再次调用它。

Answer 2

这里有几个选项。在这种情况下，最好的办法是去掉决定何时从线程开始工作的责任，而是等待监视器发出的事件释放线程来完成工作。然后，您可以按照最适合该目的的比例安排工作。

或者，从控制器代码中删除线程安全性的缺失。

Answer 3

假设上面的线程组织是针对您的特定情况的最佳方式，那么您的问题是第一个线程将锁持续时间过长，从而导致第二个线程挨饿。

您可以检查doSomethingA函数在执行时是否真的需要锁定驱动程序（大多数情况下不会），并且如果不将它分割成多个较小的执行块，其中一些块会保持锁定状态别人不会。这将为第二个线程创建更多时间，以便在需要时启动。

如果无法完成，那么您确实需要重新考虑您的应用程序，因为您已经创建了资源瓶颈。

Answer 4

它看起来像Thread.yield()是你在找什么。

Answer 5

为什么在run()中使用​​？在WebDriverController的方法中使用​​或Lock。

public void doSomeThingA(){ 
    lock.lock(); 
    try { 
     //your stuff 
    } finally { 
     lock.unlock(); 
    } 
} 

而在Thread的run方法中调用这些方法。