Algo Peterson : Erreur d'exclusion mutuelle

Bonjour,
Je cherche à utiliser l'algorithme de Peterson pour 2 threads. Cependant, à l'affichage j'obtiens que les deux threads se trouvent au même moment dans la section critique.
Le code de l'algorithme m'a été donné par mon professeur et sur internet, j'ai trouvé exactement le même. Je me demande donc à quel moment j'utilise mal la classe.
Sachant que je crée juste 2 threads.

Voilà mon code :

public class MainPeterson { 
 public static void main(String[] args) { 
  Peterson f = new Peterson(); 
  Action thread1 = new Action("Tache 1", f); 
  thread1.start(); 
  Action thread2 = new Action("Tache 2", f); 
  thread2.start(); 
 } 
} 

******************* Donné par le professeur et vu sur internet *******************

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.*;

public class Peterson implements Lock{
	
	private volatile boolean[] flag = new boolean[2];
	private volatile int victim = -1 ;

	public Peterson(){
		for(int i=0 ; i<flag.length ; ++i)
			flag[i] = false;
	}
	
	@Override
	public void lock() {
        int i = ThreadID.get()%2; // ThreadID is a ThreadLocal field
        int j= 1 - i;
        flag[i] = true;    // I'm Interested
        victim = i;        // You go first
        while(flag[j] && victim == i){}; //wait
	}
	
	@Override
	public void unlock() {
		int i = ThreadID.get()%2;
		flag[i] = false; // I m not interested
	}
	
	@Override
	public void lockInterruptibly() throws InterruptedException {
	}
	
	@Override
	public Condition newCondition() {
		return null;
	}
	@Override
	public boolean tryLock() {
		return false;
	}
	@Override
	public boolean tryLock(long arg0, TimeUnit arg1)
			throws InterruptedException {
		return false;
	}
}

*************************************************************

public class ThreadID {
	private static volatile int nextID = 0;
	
	private static class ThreadLocalID extends ThreadLocal<Integer>{
		protected synchronized Integer initialValue(){
			return nextID ++;
		}
	}
	
	private static ThreadLocalID threadID = new ThreadLocalID();
	
	public static int get(){
		return threadID.get();
	}
	
	public static void set (int index){
		threadID.set(index);
	}
}

import java.util.concurrent.locks.Lock;

public class Action extends Thread {
	private String name;
	private Lock section;

	public Action(String n,Lock s) {
		name = n;
		section = s;
	}

	public void run() {
		while (true) {
			section.lock();
			System.out.println(name+" est en section critique");
			Action.Critique();
			section.unlock();
			System.out.println(name+" est sorti de la section critique");
			Action.nonCritique();
		}
	}
	public static void Critique() {
        try {
            Thread.sleep((int) (Math.random()*30));
        }
        catch (InterruptedException e) { }
    }

    public static void nonCritique() {
        try {
            Thread.sleep((int) (Math.random()*30));
        }
        catch (InterruptedException e) { }
    }
}

Problème : J'obtiens à des moments en console :
Tache 1 est en section critique
Tache 2 est en section critique
Tache 1 est sorti de la section critique
Tache 2 est sorti de la section critique

Voyez-vous l'endroit d'où le problème pourrait venir ?
Merci d'avance.