synchronized code blocks

[Mathilde411]

Hey ! Hello everyone !
I am looking forward to make a peripheral that throw events, so I need to keep a list of connected computers.
However, the documentation specifies that it must be done "thread-safe and reentrant".
I saw the code for the DiskDrive Peripheral and it uses synchronized blocks for this purpose and I could not figure out what they do and how to use them while searching on the internet. Could somone explain it to me ?
Thanks ^^

[Mathilde411]

@SquidDev Sorry for tagging you but I really can not figure out how to make this work :/

[SquidDev]

Basically attach and detatch may be called from both the main thread and any computer thread, so any code you write needs to handle the case where you're trying to attach, detach and read the computer set at the same time.

The easiest way to do this is with synchronized block - this ensures the current thread holds a lock on a given object, and if another thread holds it, waits for that thread to release it.

class X extends IPeripheral {
  private final Object lock = new Object();
  private final Set<IComputerAccess> computers = new HashSet<>();

  @Override
  public void attach(IComputerAccess computer) {
    synchronized (lock) {
      computers.add(computer);
    }
  }

  // TODO: void detach(IComputerAccess)

  public void doSomethingToComputers() {
    synchronized (lock) {
      for (IComputerAccess computer : computers) {
        // IDK
      }
    }
  }
}

Another strategy is to use CopyOnWriteArraySet, which makes some of these guarantees for you:

class X extends IPeripheral {
  private final Set<IComputerAccess> computers = new CopyOnWriteArraySet<>();

  @Override
  public void attach(IComputerAccess computer) {
    computers.add(computer);
  }

  // TODO: void detach(IComputerAccess)

  public void doSomethingToComputers() {
    // The iterator basically returns a snapshot at the given point in time. If you iterate
    // multiple times in a function, there's no guarantee the two sets are equal.
    for (IComputerAccess computer : computers) {
      // IDK
    }
  }
}

You can probably ignore the "re-entrant" bit. This only really matters for wired modems, where attach/detach calls the same methods on other peripherals.