在java中不同类的线程之间同步共享变量？

Question

这是给我的 NXT 积木的。

假设我有两个不同的类，A 类和B 类，每个类都有自己的线程在运行。

但是，两个类共享一个名为MotorA 的静态变量实例。这个MotorA 变量是一个物理电机，它的运动可以由两个类控制。 A 类和B 类的线程都可以控制MotorA 的运动，但我只希望它们中的一个同时控制MotorA。

例如，如果 A 类试图向前旋转 MotorA 而 B 类试图向后旋转 MotorA，我只希望 A 类向前旋转 MotorA 并阻止 B 类效果。

问题：我可以使用 SAME 锁来同步来自不同类的线程中的方法吗？

Answer 1

是的，你可以。您实际上可以这样做：

  class MotorA {

    private static MotorA motor = new MotorA(); 
    private static final java.util.concurrent.locks.Lock lock = new java.util.concurrent.locks.ReentrantLock();

    private MotorA() { }

    public static MotorA getMotorA() {
    return motor;
    }

    public static Lock getLock() {
    return lock;
    }

    /* here go business methods for MotorA */

 }

接下来，当你想对 MotorA 实例做任何操作时，你只需要：

• 1) 通过getLock() 检索其锁
• 2) 在给定实例上调用 Lock.lock()
• 3) 通过getMotorA() 获取MotorA 单例
• 4) 对MotorA instace 执行任何方法
• 5) 调用 Lock.unlock() 释放锁。

在这种情况下，对资源的访问将不受多个线程的影响。

或者您可以简单地在 MotorA 的实例上进行同步：

  class UserOfMotor1 {

    public void doOperationInMotor1Thread() {

        synchronized(MotorA.getMotorA()) {

            MotorA motor = MotorA.getMotorA();
            motor.soSth();

        }
    }

  }

但在这种情况下，您还必须在线程使用共享资源时使用synchronized() 块 - 在您的情况下为MotorA。如果您使用这种控制同步的方法，您必须确保您在不同线程中对同一个对象进行同步 - 在这种情况下，MotorA 是 Singleton，因此您始终获得相同的实例。

Answer 2

每个线程都可以synchronize 在电机实例上使用它。但是，如果一个线程将同时使用多个电机，这将导致您获取每个电机上的锁。那么您必须非常小心嵌套同步块的顺序，否则您将遇到间歇性死锁。

相反，我建议您为所有电机使用一个锁，并且切勿在未握住该锁的情况下使用任何电机。由于电机是静态资源，因此该锁也可能是静态资源。在大型程序中，创建自己的私人锁并仔细控制谁可以访问它会更安全一些。在这种情况下，拥有一个任何代码都可以访问的全局锁变量可能没问题。

final class Locks {

  public static final Object MOTORS = new Object();

  private Locks() { /* Disallow instantiation. */ }

}

使用它：

final class ThreadA extends Thread {

  public void run() {
    ...
    synchronized(Locks.MOTORS) {
      Motor motorA = Motors.A;
      motorA.setSpeed(...);
      ...
    }
  }

}

您无需将自己局限于电机；关键是不要让嵌套块在不同的对象上同步。这可能直接发生在一种方法中，或者因为您从另一个方法中的同步块中调用具有同步块的方法。

Answer 3

您可以在 A 和 B 类中编写方法，它们在名为 motor 的互斥体上同步，如下所示：

class A{

public void doSomething(){
    synchronized(MotorA.motor){
        //do what you want
    }
}



class B{

public void doSomething(){
    synchronized(MotorA.motor){
        //do what you want
    }
}

这是MotorA的类

class MotorA{
    public static MotorA motor=new MotorA();
    ......
    ......
    ......
}

编辑

如果您已经有一个实例并希望在 A 和 B 类之间共享，那么您可以在构造中传递对象并在对象上同步：

class A{
    final MutexObject mm;
    public A(MutexObject m){
        mm=m;
    }
    public void doSomething(){
        synchronized(mm){
            //do what you want
        }
    }



class B{
final MutexObject mm;
public B(MutexObject m){
    mm=m;
}
public void doSomething(){
    synchronized(mm){
        //do what you want
    }
}

但是在将MutexObject 的对象传递给A 和B 的构造函数时要小心，它应该是同一个实例。

Answer 4

这不是对您提出的问题的直接回答，只是一些建议。

我建议您将“电机”本身设为一个类。您不必为其他任何一个类提供电机变量本身的“控制”，它们都具有对电机类的引用。您可以同步电机类上的每个方法，这样一个方法将拥有控制权，直到完成一系列命令，然后在方法返回时释放控制权。

我从未见过更多的类（或方法）会使代码变得更复杂——我听说它会发生，但我从未见过。我看到的复杂性总是来自于尝试在不创建新方法或类的情况下做事。

您的电机类中的方法也更有意义。例如（对不起，我不知道它是如何工作的，所以我只是猜测）如果你通过设置一点来激活电机，你可以暴露像“goForward（int speed）”和“goBack（int speed）”这样的方法而不是“motor|=0x10”之类的晦涩难懂的东西。

Answer 5

您可以在自己的 motorA 类中进行同步，而不是在最终用户类（ClassA 和 ClassB）中进行同步。同步其动作应该是 MotorA 类的责任。

MotorA 类：

public class MotorA {

    private static MotorA instance = new MotorA();
    private static int pointer = 0;

    private MotorA() {
    }

    public static MotorA getInstance() {
        return instance;
    }


   public void rotate() {
       synchronized(MotorA.class) {
           System.out.println(Thread.currentThread() + " Rotating "+ pointer++);
           try {
              Thread.sleep(100);
            } catch (InterruptedException e) {
              e.printStackTrace();
            }
       }
   }

}

MotorA 类的最终用户 - ClassA 和 ClassB，他们不太了解其他线程的存在。

public class ClassA implements Runnable {

    @Override
    public void run() {
        doRotate();

    }

    private void doRotate() {
        MotorA motor = MotorA.getInstance();
        while (true) {
            motor.rotate();
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


public class ClassB implements Runnable {

    @Override
    public void run() {
        doRotate();

    }

    private void doRotate() {
        MotorA motor = MotorA.getInstance();
        while (true) {
            motor.rotate();
            try {
                Thread.sleep(15);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

这里是主程序。

public class Main {
    public static void main(String[] args) {

        Thread a = new Thread(new ClassA());
        Thread b = new Thread(new ClassB());
        Thread c = new Thread(new ClassA());
        Thread d = new Thread(new ClassB());
        a.start();
        b.start();
        c.start();
        d.start();
    }
}

Answer 6

这个怎么样：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Shared<T> {
    private T _data;
    private final Lock lock = new ReentrantLock(true);

    public T getData() {
        try {
            lock.lock();
            return _data;
        } finally {
            lock.unlock();
        }
    }

    public void setData(T _data) {
        try {
            lock.lock();
            this._data = _data;
        } finally {
            lock.unlock();
        }
    }
}

用法：

Shared<Boolean> b = new Shared<Boolean>();
b.setData(true);

//other thread
while (b.getData()) {
  ...
}