[Callable , Synchronization] Java Thread Demo With a Shared Data Object

So here I am,

I need to manage a queue of sorts, but I want many objects to interact with it, and even objects that exist in other threads within the same application.

So what is the best model?

What won't kill me?

So far I have to 2 fancy shmancy solutions, 1 model with a custom Queue controller object using synchronization , and another with an interesting interface to manage the Queue and puts in place a couple interesting scenarios when inserting into a limited Queue.

First Solution: Synchronization

Ok, your asking what is so special in Synchronization?

Well what is special is that only ONE thread can call a method at a time, so when you want to do a pull, you will be sure that a thread is doing a pull.

This in the end is nice, but wasn't 100% what I was looking for, but here is just in case you find this useful.

File: JavaThreadDemo.java

import java.util.*;
import java.util.concurrent.*;

public class JavaThreadDemo {
	//This Queue thinks too much of itself.
	static Queue gQ = new Queue();

	//A pretty constructor
	public JavaThreadDemo() {
	}

	//Main method funky funk.
	public static void main(String[] args) {
		ExecutorService pool = Executors.newFixedThreadPool(3);
		Set<Future<Boolean>> set = new HashSet<Future<Boolean>>();

		//Create the threads
		Callable<Boolean> callable = new Thready(gQ,"Thread 5000",5000); // Run every 5 seconds
		Callable<Boolean> callable2 = new Thready(gQ,"Thread 3000",3000); //Run Every
		Callable<Boolean> callable3 = new Thready(gQ,"Thread 4000",4000);
		Future<Boolean> future = pool.submit(callable);
		Future<Boolean> future2 = pool.submit(callable2);
		Future<Boolean> future3 = pool.submit(callable3);

		//Add the threads to the nice little set and let them cook.
		set.add(future);
		set.add(future2);
		set.add(future3);

		while (true) {
			//Lets see who is in there:
			gQ.print();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

File: Queue.java

public class Queue {

	private String value ="Not Set";
	private long cnt = 0;
	public Queue() {
	}

	public Queue(String mVal) {
		this.value = mVal;
	}

	public synchronized void setString(String astr) {
		this.value = astr;
	}

	public synchronized  String getValue() {
		return this.value;
	}

	public synchronized void print() {
		this.cnt++;
		System.out.println(this.cnt+" "+this.value);
	}

}

File: Thready.java

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class Thready2 implements Callable {

	private BlockingQueue mQ ;
	private boolean pull;
	private long time;
	private String thID = "";

	public Thready2(BlockingQueue aQ, boolean pull, long time,String ID) {
		this.mQ = aQ;
		this.pull = pull;
		this.time = time;
		this.thID = ID;
	}

	@Override
	public Boolean call() throws Exception {
		boolean retVal = true;
		int offerCnt = 0;
		while  (retVal) {
			Queue aQi = null;
			if(pull) {
				aQi = mQ.take();
				System.out.println("Got Something : " + mQ.size()+" : " + aQi.getValue());
			} else {
				aQi = new Queue(this.thID+":"+offerCnt);
				System.out.println("I am making a sacrifical offering.. ");
				if(mQ.offer(aQi,1,TimeUnit.SECONDS)) {
				System.out.println("The Gods have taken my offering.");
				} else {
					System.out.println("The Gods have rejected my offering of " + this.thID+":"+offerCnt);
				}
				System.out.println("The Queue is now : " + mQ.size());
				offerCnt++;
			}
			Thread.sleep(this.time);
		}

		return null;
	}

}

Second Solution: BlockingQueue Interface

Note: Please use the Queue.java from the first example.

Now for this one, I am using a BlockingQueue interface, this is nice because it does what I did with synchronization, but has a few more features that I am displaying here.

What I am displaying with putting an item on the Queue is a timeout, that is nice because you don't want a deadlocked situation when your allocated resources are maxed,
and on the listener end to pop a Queue item off the stack will wait and listen till the cows come home, and reduces the code required like other polling methods. There are other methods to poll and that also have a timeout.

Overall, I have to think that this is a better method because I can show my process who is really in control.

File: JavaThreadDemo2.java

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadDemo2 {
	//The Queue
	private final BlockingQueue<Queue> queue = new ArrayBlockingQueue<Queue>(10);

	//A Constructor
	public ThreadDemo2() {
	}

	//Where we start
	public boolean start () {
		boolean retVal = true;
		Queue cQ  = null;
		try {
			//Create Executor pool
			ExecutorService pool = Executors.newFixedThreadPool(3);

			//This is where we will "store" these threads
			Set> set = new HashSet>();

			//Creating the threads
			Callable<Boolean> callable = new Thready2(queue,true,1000,"Listen0");
			Callable<Boolean> callable2 = new Thready2(queue,false,1000,"push1000");
			Callable<Boolean> callable3 = new Thready2(queue,false,400,"push0400");
			Future<Boolean> future = pool.submit(callable);
			Future<Boolean> future2 = pool.submit(callable2);
			Future<Boolean> future3 = pool.submit(callable3);

			//Add them to the nice set and let them cook.
			set.add(future);
			set.add(future2);
			set.add(future3);
		} catch (Exception e) {
			e.printStackTrace();
		}
		if (cQ == null ) {
			System.out.println("cQ is null");
		}
		return retVal;
	}

	public static void main(String[] args) {
		ThreadDemo2 me = new ThreadDemo2();
		if(!me.start()) {
			System.out.println("I dies.");
		}
	}

}

File:Thready2.java

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class Thready2 implements Callable {

	private BlockingQueue mQ ;
	private boolean pull;
	private long time;
	private String thID = "";

	public Thready2(BlockingQueue aQ, boolean pull, long time,String ID) {
		this.mQ = aQ;
		this.pull = pull;
		this.time = time;
		this.thID = ID;
	}

	@Override
	public Boolean call() throws Exception {
		boolean retVal = true;
		int offerCnt = 0;
		while  (retVal) {
			Queue aQi = null;
			if(pull) {
				aQi = mQ.take();
				System.out.println("Got Something : " + mQ.size()+" : " + aQi.getValue());
			} else {
				aQi = new Queue(this.thID+":"+offerCnt);
				System.out.println("I am making a sacrifical offering.. ");
				if(mQ.offer(aQi,1,TimeUnit.SECONDS)) {
				System.out.println("The Gods have taken my offering.");
				} else {
					System.out.println("The Gods have rejected my offering of " + this.thID+":"+offerCnt);
				}
				System.out.println("The Queue is now : " + mQ.size());
				offerCnt++;
			}
			Thread.sleep(this.time);
		}

		return null;
	}
}