Как реализовать многопоточный PID-контроллер в Java?

Question

Я своего рода новичок в Java, так что еще не полностью поняли концепцию multithreading.I хотели бы создать класс PIDController, что позволяет мне сделать это:

ControllerMethods methods = new ControllerMethods() 
          { 
           public long getError(long setpoint) 
           { 
            //get an input 
           } 
           public void setOutput(long value) 
           { 
            //do something 
           } 
           public void isComplete(long setpoint) 
           { 
            return getError() == 0; 
           } 
          }; 

PIDController motorPID = new PIDController(setpoint, kp, ki, kd, methods); 

motorPID.run(); 
//runs the PID controller to completion (methods.isComplete() == true) 

motorPID.run(false); 
//starts the PID controller in a separate thread, allowing 
//continual monitoring in the current thread 

while(motorPID.isRunning()) 
{ 
    //do something else 
    if(condition1) 
     motorPID.pause(); 
     //pause the PID controller, preventing the integral from increasing 
    else if(condition2) 
     motorPID.stop(); 
} 

Я работал, как для вычисления стандартных ПИД-алгоритмов, но я не могу решить, как обеспечить асинхронную функциональность.

Может ли кто-нибудь сказать мне, как я могу достичь аналогичного API?

Answer 1

Вы уже реализовали метод run() для PIDController, так что вы также должны реализовать интерфейс Runnable:

class PIDController implements Runnable { 
    .... 
} 

Теперь вы можете начать свой PIDController asynchonous, позвонив по телефону:

pidControllerThread = new Thread(pidController); 
pidControllerThread.start(); 

Для синхронизации (если необходимо), вы должны взглянуть на солнце concurrency guide.

Answer 2

На сегодняшний день лучшим механизмом для прикрепления нитей к чему-либо является разделение объекта, который выполняет работу с объектом, являющимся нитью. Интерфейс Runnable может быть привлекательным, поскольку он позволяет людям передавать объект конструктору или Исполнителю Thread и запускать его. Однако, если у вас есть требования к управлению жизненным циклом для вашего объекта, которые находятся вне «выполнения до завершения», например, пауза, то в большинстве случаев вам будет более уместно управлять потоком внутри вашего объекта, чтобы вы знали, какой поток (да, вы можете установить экземпляр объекта в Thread.currentThread() для записи, но ...).

Итак, я думаю, что у вас есть хорошее начало. Вам нужно добавить использование некоторой блокировки, чтобы помочь вам управлять pause() и другим управлением потоками.

 

    public class PIDController { 
     private final Object myLock = new Object(); 
     private final ControllerMethods ctrl; 
     private volatile Thread thread; 
     private volatile Runner runner; 
     private int pidInterval = 700; 
     private final double setPoint, kp, ki, kd; 

     public PIDController(double setPoint, double kp, double ki, double kd, ControllerMethods inst) { 
      this.ctrl = inst; 
      this.setPoint = setPoint; 
      this.kp = kp; 
      this.ki = ki; 
      this.kd = kd; 
     } 

     public void pause() { 
      synchronized(myLock) { 
       if(runner.paused) { 
        throw new IllegalOperationException(this+": already paused"); 
       } 
       runner.paused = true; 
      } 
     } 

     public void resume() { 
      synchronized(myLock) { 
       if(!runner.paused) { 
        throw new IllegalOperationException(this+": already resumed"); 
       } 
       runner.paused = false; 
      } 
     } 

     public bool isRunning() { 
      return running; 
     } 

     public void start() { 
      if(thread != null) { 
       throw new IllegalOperationException(this+": already running"); 
      } 
      myThread = new Thread(runner = new Runner()); 
      myThread.start(); 
     } 

     public void stop() { 
      if(runner == null) { 
       throw new IllegalOperationException(this+": PID is not running"); 
      } 
      runner.running = false; 
      if(runner.paused) 
       resume(); 
      runner = null; 
     } 


     // It is important, anytime that you implement a stoppable Runnable, that 
     // you include the "running" flag as a member of an innner instance class like 
     // this so that when you ask this instance to stop, you can immediately restart 
     // another instance and not have the two threads observing the same "running" flag 
     private class Runner implements Runnable { 
      volatile bool running = false, bool paused; 
      public void run() { 
       running = true; 
       while(running) { 
        // do this at the top of the loop so that a wake from 
        // pause will check running, before recomputing. 
        reComputePID(); 

        // Use the double check idiom to 
        if(paused) { 
         synchronized(myLock) { 
          while(paused) { 
           myLock.wait(); 
          } 
         } 
        } 
        Thread.sleep(pidInterval); 
       } 
      } 
     } 

     public void reComputePID() { 
      ... 
     } 
    }