Question

在我的应用程序中，我有两个类，它们实现了两种处理文件的不同方法。

现在我需要添加一个名为isProcessing的布尔变量，每当这两个类中的一个开始处理文件时，该变量将被设置为true。处理完成后，应该返回false。

每当X类尝试处理文件时，它应该检查Y类目前是否处理。

如何在不声明顶级静态全局变量的情况下实现此目的？

Answer 1

有很多方法......但为什么不使用static？

您可以拥有一个具有全局变量isProcessing的公共类，该变量具有两个嵌套类X和Y，因此两者都可以看到该变量。虽然如果你正在玩多个线程，那么你还需要同步变量....

public class Connector{

private volatile boolean isProcessing; //i am using volatile in case you have Threads but you need to further improve it.


  protected class X{

      public X(){ ... }

  }


  protected class Y{

   public Y(){....}

  }

}

更多链接：

Java share a variable between two threads

http://java-tweets.blogspot.gr/2012/01/difference-between-volatile-and.html

http://javarevisited.blogspot.gr/2011/04/synchronization-in-java-synchronized.html

非常建议您从这里阅读答案：

What is the use of a private static variable in Java?

Answer 2

相互排斥

一种方法是使用在处理类之间共享的锁定对象mutex。

public static void main(String[] args) {

    ProcessingMutex mutex = new ProcessingMutex();

    Processor fileProcessorOne = new ProcessorOne(mutex);
    Processor fileProcessorTwo = new ProcessorTwo(mutex);

    // start threads and do your stuff

}

互斥对象将包含一些逻辑，以防止一个线程覆盖其他线程锁定：

public class ProcessingMutex {

    private Object processor = null;

    public boolean processing() {
        return processor != null;
    }

    public synchronized void start(Object p) {
        if (processor == null) {
            processor = p;
        } else {
            throw new IllegalStateException("Already processing!");
        }
    }

    public synchronized void finished(Object p) {
        if (processor == p) {
            processor = null;
        } else {
            // Optional: throw new IllegalStateException("Cannot reset other processors flag!");
        }
    }

}

由于它们共享锁定机制，因此我从实现锁定的同一父类派生了两个处理器类：

public abstract class Processor /* extends Runnable? */ {
    private final ProcessingMutex mutex;

    public Processor(ProcessingMutex mutex) {
        this.mutex = mutex;
    }

    public void processFile() {
        if (getLock()) {
            try {
                doProcess();
            } finally {
                // make sure to release lock -> finally
                releaseLock();
            }
        }
    }

    protected abstract void doProcess();

    private boolean getLock() {
        // query and set mutex in synchronized block to prevent interference with other thread
        synchronized (mutex) {
            if (!mutex.processing()) {
                mutex.start(this);
            }
        }
        return false;
    }

    private void releaseLock() {
        mutex.finished(this);
    }

}

public class ProcessorOne extends Processor {

    public ProcessorOne(ProcessingMutex mutex) {
        super(mutex);
    }

    @Override
    protected void doProcess() {
        // TODO add file processing algorithm one
    }

}

public class ProcessorTwo extends Processor {

    public ProcessorTwo(ProcessingMutex mutex) {
        super(mutex);
    }

    @Override
    protected void doProcess() {
        // TODO add file processing algorithm two
    }

}

<强>声明：请注意，这只是一个非常基本的（深夜）版本来展示我的想法。根据应用程序的需要，必须在线程安全方面加以强化。

编辑：

的java.util.concurrent

您当然可以使用Java提供的其中一个Lock对象（请参阅java.util.concurrent API doc），如其他答案所示：https://stackoverflow.com/a/3493788/4791599

变量在整个应用程序中可见但不是静态的

2 个答案:

相互排斥

的java.util.concurrent