A strange behaviour throwing Threads via anonymous class technique

Question

Hi friends!
I've noted a strange behaviour executing the next code:
public class ResolAnonimes
     private int value;
     public ResolAnonimes(int value)
          this.value = value;
     public ResolAnonimes myMethod(int nThreads)
          final ResolAnonimes a = this;
          int nThreadsFor = nThreads - 1;
          for( int i=0; i < nThreadsFor; i++)
               new Thread(){
                    public void run()
                            System.out.println(Thread.currentThread().getName() + " has begun processing");
                                 doSomethingWith(a);
                            System.out.println(Thread.currentThread().getName() + " has finished processing");
               }.start();
               this.value++;
          }//for loop
          return a;
     public static void doSomethingWith(ResolAnonimes a)
          System.out.println(a.value);
     public static void main(String Args[])
          ResolAnonimes first = new ResolAnonimes(1);
          ResolAnonimes result = first.myMethod(5);
}When I execute it, that's the output I get:
Thread-0 has begun processing
2
Thread-0 has finished processing
Thread-0 has begun processing
3
Thread-0 has finished processing
Thread-0 has begun processing
4
Thread-0 has finished processing
Thread-0 has begun processing
5
Thread-0 has finished processingWhere's the "1" printed? It doesn't appear! It seems it has thrown only 4 threads, not 5.
Am I doing anything wrong? Is it a bug?
Can you help me, please?
Thank you in advance.

Answer 1

Oh I'm sorry. I was changing the code because of privacy rerasons and I finally didn't type what I want.
Consider an array which all cells must be typed with the array lentgh. Moreover, the work is distributed by some threads.
I'm refering to something like this:
import java.util.Random;
import java.util.LinkedList;
public class MyArray
     private static int initialRow = 0;
     private static int lastRow = 0;
     private int[] vector;
     public MyArray(int size)
          vector = new int[size];
     public static boolean correctIndex(MyArray a )
          for(int i = 0; i< a.vector.length; i++)
               if(a.vector[i] != a.vector.length)
                    return false;
          return true;
     public String toString()
          String s ="";
          for(int i=0; i < this.vector.length; i++)
               s += this.vector[i] + " ";
          return s;
     public MyArray  operationWith(int nThreads)
          MyArray a = this;
          MyArray result = null;
          final Contenidor ctros = new Contenidor(new LinkedList());
          result = a.putTheIndexValue(nThreads, ctros);
          Thread consumerThread = new Thread( new Consumer( ctros, nThreads));
          consumerThread.start();
          try
               consumerThread.join();
          catch(InterruptedException ie){}
          return result;
     public MyArray putTheIndexValue(int nThreads, Contenidor ctros) //Este metode encara es experimental
          final MyArray a = this;
          final MyArray result = new MyArray( a.vector.length);
          final Contenidor ctrosR = ctros;
          for(int i = 0; i < result.vector.length; i++)
                    result.vector= 0;
          int incRows = a.vector.length / nThreads - 1;
          initialRow = 0;
          lastRow= incRows;
          int nFilsFor = nThreads - 1;
          Thread[] vectorFils = new Thread[nThreads];
          for( int i=0; i < nFilsFor; i++)
               /*vectorFils[i] = */ new Thread()
                                             public void run()
                                                  System.out.println(Thread.currentThread().getName() + " has begun processing");
                                                  MyArray.putTheIndexValue( a, initialRow, lastRow);
                                                  System.out.println(Thread.currentThread().getName() + " has finished processing");
                                                  String s = Thread.currentThread().getName();
                                                  ctrosR.put(s);                         
               vectorFils[i]*/.start();
               initialRow = initialRow + 1;
               lastRow = initialRow + incRows;
          new Thread()
               public void run()
                    System.out.println(Thread.currentThread().getName() + " has begun processing");
                    MyArray.putTheIndexValue( a, initialRow, a.vector.length - 1);
                    System.out.println(Thread.currentThread().getName() + " has finished processing");
                    String s = Thread.currentThread().getName();
                    ctrosR.put(s);                         
               vectorFils[i]*/.start();
          return result;
     public static void putTheIndexValue( MyArray a, int initialRow, int lastRow)
          for(int i = initialRow; i <= lastRow; i++)
               a.vector[i] = a.vector.length;
public class Interface
     public static void main(String Args[])
          int nThreads = 2;
          int arraySize = 5;
          MyArray ma = new MyArray(arraySize);
          MyArray result = ma.operationWith(nThreads);
          if(MyArray.correctIndex(result))
               System.out.println("The operation has been done correctly");
          else
               System.out.println("THE OPERATION HAS NOT BEEN CORRECTLY!");
          System.out.println(ma.toString());
public class Consumer implements Runnable
     private Contenidor ctros;
     private int nFils;
     public Consumer(Contenidor ctros, int nFils)
          this.ctros = ctros;
          this.nFils = nFils;
     public void run()
          System.out.println(Thread.currentThread().getName() + "is waiting the total process to be finished");
          for(int i = 0; i< nFils; i++)
                  System.out.println( Thread.currentThread() + " is waiting a thread to give me its chunk");
                  String s = ctros.get();
                  System.out.println( Thread.currentThread() + ":  " + s + " has already given me its chunk");
             System.out.println(Thread.currentThread().getName() + "says all threads have finished");
import java.util.Queue;
import java.util.LinkedList;
public class Contenidor
    private int nDadesNoves;
    private Queue contenidor;
    public Contenidor(Queue contenidor)
        this.contenidor = contenidor;
        this.nDadesNoves = 0;
    public synchronized String get()
        while(nDadesNoves < 1)
            try
                wait();
            catch(InterruptedException ie){}
        nDadesNoves--;
        notifyAll();
        return (String)contenidor.poll();
    public synchronized void put(String s)
        contenidor.offer(s);
        nDadesNoves++;
        notifyAll();
}The output I get sometimes is:
THE OPERATION HAS NOT BEEN CORRECTLY!
5 5 5 5 5And I get also sometimes that:
THE OPERATION HAS NOT BEEN CORRECTLY!
0 5 5 5 5That's what I wanted to refer last post. I think I'm doing a correct synchronization. Am I wrong?
I don't understand that behaviour.
Anyone can help me, please?
Thank you in advance.