Java enumeration that is registered as a listener when created

There are two good (as most believe) java practices that I am trying to combine and fail.

• Don't miss this in the constructor.
• Use enumeration instead of singleton pattern.

So, I want a singleton that as soon as it is created listens for some event. Here's an example. First, the event listener interface:

public interface EventListener {
    void doSomething();
}

      

        
        
        
      

    

Then the event creator:

public class EventProducer implements Runnable{

    private EventListener listener;

    public EventProducer(EventListener listener) {
        if (listener == null) {
            throw new NullPointerException("Listener should not be null.");
        }
        this.listener = listener;
    }

    @Override
    public void run() {
        listener.doSomething(); //This may run before the listener is initialized.
        do {
            long startTime = System.currentTimeMillis();
            long currentTime;
            do {
                currentTime = System.currentTimeMillis();
            } while ((currentTime - startTime) < 1000);
            listener.doSomething();
        } while (!Thread.currentThread().isInterrupted());
        listener = null; //Release the reference so the listener may be GCed
    }
}

      

        
        
        
      

    

Then an enum (as the 2nd of the listed java practices shows):

public enum ListenerEnum implements EventListener{

    INSTANCE;

    private int counter;
    private final ExecutorService exec;

    private ListenerEnum() {
        EventProducer ep = new EventProducer(this); //Automatically unregisters when the producer is done.
        counter = 0;
        exec = Executors.newSingleThreadExecutor();
        exec.submit(ep);
    }

    @Override
    public void doSomething() {
        System.out.println("Did something.");
        counter++;
        if (counter >= 5) {
            exec.shutdownNow();
        }
    }
}

      

        
        
        
      

    

And finally, start something:

public class TestRunner {

    public static void main(String[] args) {
        ListenerEnum.INSTANCE.doSomething();
    }

}

      

        
        
        
      

    

The problem is with the first line of the ListenerEnum constructor as we are leaking this, which is not in line with the 1st listed java practice. This is why our event producer can call the listener method before the listener is created.

How can I handle this? Normally I would use the Builder pattern, but how is this possible with an enum?

EDIT: For those of you who matter, the event producer in my program actually extends the BroadcastReceiver, so my enum cannot be the event producer, they must be separate. The manufacturer is created in the constructor of the enum (as an example) and later registered programmatically. So I have no problem with that. However, I would like to know if I can avoid this.

EDIT 2:

Ok, since there are suggestions for solving my problem, I would like to clarify a few things. First of all, most of the suggestions are workarounds. They suggest doing the same thing in a completely different way. I appreciate these suggestions and will probably agree with them as an answer and implement it. But the real question should be "How do I implement an enum Builder pattern?" The answer I already know, and people think that "you don't do it, do it differently." Is there anyone who can post something like "You do it! You do it like this".

I was asked to give a code close to my actual use case. Change the following:

public enum ListenerEnum implements EventListener{

    INSTANCE;

    private EventProducer ep;
    private int counter;
    private ExecutorService exec;

    private ListenerEnum() {
        ep = new EventProducer(this); //Automatically unregisters when the producer is done.
        counter = 0;
    }

    public void startGettingEvents() {
        exec = Executors.newSingleThreadExecutor();
        exec.submit(ep);
    }

    public void stopGettingEvents() {
        exec.shutdownNow();
    }

    @Override
    public void doSomething() {
        System.out.println("Did something.");
        counter++;
        if (counter >= 5) {
            stopGettingEvents();
        }
    }
}

      

        
        
        
      

    

Besides:

public class TestRunner {

    public static void main(String[] args) {
        ListenerEnum.INSTANCE.startGettingEvents();
    }

}

      

        
        
        
      

    

Now all I have to do to solve my problem is move the creation of EventsProducer to the startGettingEvents () method. It. But this is also a workaround. What I would like to know is this: In general, how to avoid leaking this in the listener enum constructor since you cannot use the Builder pattern? Or can you somehow use the Builder enum pattern? Is this done only in workarounds on a case-by-case basis? Or is there a general way to handle this that I am not aware of?