Keeping a queue class immutable

Question

Hi,
I recently got hooked on the concept of immutable classes. I'm not really sure why, but anyway...
I have a class that queues up tasks to a worker thread for execution, which is currently immutable. However, I never implemented a way to stop the worker thread if I wanted the queue to shutdown, so I'm trying to come up with a way to do so while retaining the immutability of the class.
Normally, I'd have a boolean value, and then set the boolean to false or true or whatever, and then the run() method in the worker thread would return. However, If I have to set a boolean, it would break the concept of immutability.
So while this question may seem somewhat ridiculous, I'm more curious than anything to see if there's a way to solve this problem.
Here's my queue class, with an incomplete shutdown() method, which I'd like to, in the future, "stop" the ThreadWorker thread:
public final class ThreadQueue {
     private final ExecutorService pool;
     private final BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>(5);
     public ThreadQueue() {
          pool = Executors.newSingleThreadExecutor();
          (new Thread(new ThreadWorker())).start();
     public synchronized void addToQueue(Runnable task) {
          try {
               queue.put(task);
          } catch (InterruptedException ignored) {
     public void shutdown() {
     private final class ThreadWorker implements Runnable {
          public void run() {
               for (;;) {
                    try {
                         pool.execute(queue.take());
                    } catch (InterruptedException ignored) {
}If I'm just being pedantic with the whole immutability thing, so be it; I'm really curious.
Any advice will be greatly appreciated.
Thanks,
Dan

Answer 1

Well it looks as if I need to look up the definition of immutable again. I didn't think that adding things to a list would constitute changing the state of the object, but now that I think about it, that obviously does.
Anyway, my question is answered; the question was a bit ridiculous like I had thought, but oh well.
> >
It seems to me tho that while shutdownNow could potentially stop the pool (which it seems is just 1 thread), it won't stop the other threads... BTW, all the threads seem to do is to loop and tell the single executor to run the next job... Are they actually running the jobs? Otherwise, why do you need more than 1 of them?
As to this, shutting down the ExecutorService stops that thread, and it won't stop the thread running from ThreadWorker (which is why I changed my code as I'll show later). Anyway, the point of ThreadWorker is to execute each task in a "background" thread. Actually, since the ExecutorService runs in its own thread, it seems as if ThreadWorker is pretty worthless. If I added pool.execute(queue.take());it doesn't seem like it'll matter. Looks like I'll have to try that out and see what happens.
Anyway, here's the most recent update of my code, with the new shutdownQueue() method and a new loop in ThreadWorker:
public final class ThreadQueue {
     private final ExecutorService pool;
     private final BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>(5);
     private volatile boolean stopThreadWorker;
     public ThreadQueue() {
          pool = Executors.newSingleThreadExecutor();
          stopThreadWorker = false;
          (new Thread(new ThreadWorker())).start();
     public synchronized void addToQueue(Runnable task) {
          try {
               queue.put(task);
          } catch (InterruptedException ignored) {
     public void shutdownQueue() {
          stopThreadWorker = true;
          pool.shutdownNow();
     private final class ThreadWorker implements Runnable {
          public void run() {
               while(stopThreadWorker) {
                    try {
                         pool.execute(queue.take());
                    } catch (InterruptedException ignored) {
}Thanks for all the help!