TestThreads class [code mangets-Networking and threads-ch15-HeadFirstJava]

[Henry de Deaux]

Hi anyone and everyone!
I'm really a beginner, and try to complete the really good book Head First Java, which has an exercice called Code magnet and is all about threads.
I found a post about this exercice, but not about this specific problem stated below.
The output to find is :

one 98098
two 98099

I succeeded in my own way to get an output, and it's robust. I don't even really understand why.
When I implemented the exercice solution although, I couldn't match the output that I quoted.

Down there is my solution,I cheated using two times the staments a.updateCounter(1);  and the comments in the code are part of the exercice solutions as stated in the book (assuming one removed the duplicated statement).

My question, am I really multithreading here?
Because, as far as my eyes can see, I'm putting the second thread to sleep while the first is working, and when the first finishes, the second wake up and use the updated value.
I don't even need the first thread to sleep.
I understand why the second thread has to sleep, (otherwise it finishes way before the first like "two 1 one 98098"), and I understand the design Singleton.
But here, I'm trying to monitor the scheduller, which seems not to do, right? to achieve a result I could get without threading at all.

public class TestThreads {
	//Declar/instantiate threads and job
	public static void main(String[] args) {
		ThreadOne t1 = new ThreadOne();
		Thread one = new Thread(t1);
		ThreadTwo t2 = new ThreadTwo();
		Thread two = new Thread(t2);
		one.start();
		two.start();		
	}
}

//Job class
class Accum {
	private int counter=0;
	private static Accum a = new Accum();
	private Accum(){
		
	}
	public static Accum getAccum(){
		return a;
	}
	public int getCount(){
		return counter;
	}
	public void updateCounter(int add){
		counter += add;
	}
}

class ThreadOne implements Runnable {
	Accum a = Accum.getAccum();
	@Override
	public void run() {
		for(int x=0;x<98;x++){
			//a.updateCounter(1000);
			try{
				Thread.sleep(50);
				a.updateCounter(1);
				a.updateCounter(1000);
			}
			catch(InterruptedException ex){
				ex.printStackTrace();
			}	
		}
		
		System.out.println("one "+a.getCount());
	}
	
}

class ThreadTwo implements Runnable {
	Accum a = Accum.getAccum();
	@Override
	public void run() {
		for(int x=0;x<99;x++){
			//a.updateCounter(1);
			try{
				Thread.sleep(50);
			}
			catch(InterruptedException ex){
				ex.printStackTrace();
			}
		}
		a.updateCounter(1);
		System.out.println("two "+a.getCount());
	}
	
}

[Henry de Deaux]

OK, GOT IT!  

Singleton design was the point of the exercice and threading the context.
You can use some timer working with the scheduler, even if no guarantee is due, as stated in the book.
I just freaked out a bit