How to change an instance variable of all instances of a class at once, Java

Question

I want to have multiple instances of a class, but be able to change all non-static instances of a variable at once. Maybe this code will be more clear:

public class Example {
     public int _x; //_x and _y are NOT static
     public int _y;
     Example (int x, int y) {
     _x = x;
     _y = y;
     }
     public void zeroThem() {
     _x = 0;
     _y = 0;
     }
}

The point of the zeroThem() method is that I might have

Example A = new Example(1, 2);
Example B = new Example(3, 4);

But once I call something like: A.zeroThem(); The following will be true:

A._x == 0;
B._x == 0;
A._y == 0;
B._y == 0;

Is there any way to do this without making _x and _y static?

Yes if you have your objects in a collection then you can loop over that collection (or use streams) and zero all objects. — Joakim Danielson, May 17 '20 at 07:37
This design doesn't seem right. Is this your real problem or are you trying to achieve something else and this is just a demo? If so, maybe adding some real context may help us to better help you. — lealceldeiro, May 17 '20 at 07:41
Maybe you should have made the field `static` in the first place, if this is how it is used. — user207421, May 17 '20 at 08:13

Nowhere Man · Answer 1 · 2020-05-17T11:26:38.083

This can be achieved with the help of the following fixes:

Your instance variables need to be volatile
You need to have static synchronized collection of Example instances and iterate it.
According to your request, you need to have method zeroAll calling instance method zeroThem. zeroAll may be implemented as non-static, but as soon as it affects all instances of Example it's better to mark it as static.

public class Example {

    private static List<Example> all = Collections.synchronizedList(
        new ArrayList<>());

    public volatile int _x; //_x and _y are NOT static
    public volatile int _y;

    Example (int x, int y) {
        this._x = x;
        this._y = y;
        Example.all.add(this);
    }

    public void zeroThem() {
        _x = 0;
        _y = 0;
    }

    public static void zeroAll() {
        synchronized(Example.all) {
            Example.all.forEach(Example::zeroThem);
        }
    }
}

Update Addressing comment to resolve memory leak issue using WeakReference and ReferenceQueue:

import java.lang.ref.*;
import java.util.*;

public class Example {

    private static final ReferenceQueue<Example> refQueue = new ReferenceQueue<>();
    private static final List<WeakReference<Example>> all = Collections.synchronizedList(new ArrayList<>());

    public volatile int _x; //_x and _y are NOT static
    public volatile int _y;

    Example (int x, int y) {
        this._x = x;
        this._y = y;
        Example.all.add(new WeakReference<>(this, refQueue));
    }

    public void zeroThem() {
        _x = 0;
        _y = 0;
    }

    public static void zeroAll() {
        synchronized(Example.all) {
            Example.all.removeIf(ref -> ref.get() == null); // delete non-existing instances
            Example.all
                .stream()
                .map(WeakReference::get)
                .forEach(Example::zeroThem);
        }
    }
}

You require the OP to make the instance variables volatile but then use a non thread safe collection is instances at the class level - this makes very little sense. Without something rather sophisticated - a `ReferenceQueue` - what you’ve built here is a memory leak. — Boris the Spider, May 17 '20 at 08:56
@BoristheSpider, you've been right, thanks for pointing out these issues. I updated the answer to address your comments. — Nowhere Man, May 17 '20 at 11:29

How to change an instance variable of all instances of a class at once, Java

1 Answers1