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

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

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

每当类X试图处理一个文件时，它都应该检查类Y此时是否没有处理

---

如何在不声明顶级静态全局变量的情况下实现这一点

有很多方法。。。但是为什么不使用

静态


您可以有一个带有全局变量
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(){....}

  }

}


其他链接：





强烈建议阅读此处的答案：

嗯，有很多方法。。。但是为什么不使用
静态


您可以有一个带有全局变量
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(){....}

  }

}


其他链接：





强烈建议阅读此处的答案：

互斥
一种方法是在处理类之间共享一个锁定对象a

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提供的一个锁对象（请参阅），正如另一个答案中所建议的那样：
互斥
一种方法是在处理类之间共享一个锁定对象a

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提供的一个锁对象（请参阅），正如另一个答案中所建议的：
您考虑过使用共享文件系统锁吗？您可能需要使用单例模式。考虑到静态正是您想要的，您能解释一下为什么不想使用它吗？我已经在下面的答案中写下了它，但我将在本次对话中重复。我认为静态变量被认为是一种糟糕的反模式。您考虑过使用共享文件系统锁吗？您可能需要使用单例模式。考虑到静态正是您想要的，您能解释一下为什么不想使用它吗？我已经在下面的答案中写下了它，但我将在本次对话中重复。我认为静态变量被认为是一种可怕的反模式。我认为静态变量是一种可怕的反模式。@Bobzone有时非常有用。想象一下，如果你想在很多类之间共享一个变量。。。尽管实现它有多种方法。我认为静态变量是一种可怕的反模式。@Bobzone有时非常有用。想象一下，如果你想在很多类之间共享一个变量。。。尽管实现这一目标有多种方法。。