Commentaires

1. Le mardi 24 août 2010, 15:32 par Vincent

Solution rapide :
On récupère les threads (y compris les threads 'fils') dans un tableau.
Le deuxième élément est le TimerThread que l'on cast et on récupère le counter !
Et voilà !

timer.stop();
Thread threads = new Thread[2];
Thread.enumerate(threads);
Thread thread = threads[1];
System.out.println(((Timer.TimerThread) thread).getCounter());

2. Le mardi 24 août 2010, 15:34 par Benoît Dissert

Je propose (on est bien d'accord que je n'écrirai jamais du code comme ça en production :-) ) :

public static void main(String args) throws InterruptedException {

Timer timer = new Timer();
timer.start();

// My code : begin
Set<Thread> allThreads = Thread.getAllStackTraces().keySet();
TimerThread timerThread = null;
for (Thread thread : allThreads) {
if (thread instanceof TimerThread) {
timerThread = (TimerThread)thread;
break;
}
}
// My Code : end


Thread.sleep(new Random().nextInt(2000));
timer.stop();

if ( timerThread == null ) {
System.exit(0);
}
System.out.println("counter = " + timerThread.getCounter());
}

3. Le mardi 24 août 2010, 16:11 par Kevin L'Huillier

public class Quiz41 {

   public static void main(String[] args) throws InterruptedException {
       EH eh = new EH();
       Thread.setDefaultUncaughtExceptionHandler(eh);
       Timer timer = new Timer();
       timer.start();
       Thread.sleep(new Random().nextInt(2000));
       timer.stop();
       Thread.sleep(1000);
       System.out.println(eh.getCounter());
   }
   
   static class EH implements UncaughtExceptionHandler {
       volatile int counter;
       
       @Override
       public void uncaughtException(Thread t, Throwable e) {
           TimerThread tt = (TimerThread) t;
           counter = tt.getCounter();
       }
       
       public int getCounter() {
           return counter;
       }
   }

}

4. Le mardi 24 août 2010, 18:05 par arn

public static void main(String args) throws InterruptedException {

       
       executeInNewGroup(new Runnable() {
           
           @Override
           public void run() {
               
               try {
                   
                   Timer timer = new Timer();
                   timer.start();
                   
                   Thread[] tmpThreads = new Thread[2];
                   Thread.currentThread().getThreadGroup().enumerate(tmpThreads);
                   Timer.TimerThread timerThread = (Timer.TimerThread) tmpThreads[1];
                   
                   Thread.sleep(new Random().nextInt(2000));
                   timer.stop();
  
                   System.out.println(timerThread.getCounter());
               }
               catch (Exception ex) {
                   
                   ex.printStackTrace();
               }
           }
       });
   }

   
   public static void executeInNewGroup(Runnable runnable) throws InterruptedException {
       
       final ThreadGroup group = new ThreadGroup("mygroup");
       Thread thread = new Thread(group, runnable);
       thread.start();
       thread.join();
   }

5. Le mercredi 25 août 2010, 12:57 par Piwaï

Comme d'habitude, j'ai du mal à trouver la solution, mais les commentaires sont tous plus intéressants les uns que les autres :-) Quelle ingéniosité et quelle connaissance des API !

Merci Olivier pour ces énigmes :-)

6. Le jeudi 26 août 2010, 23:37 par Stephen

Since the nested class is both public and static

public class Quiz41 {

public static void main(String args) throws InterruptedException {

TimerThread timer = new TimerThread();
timer.start();
Thread.sleep(new Random().nextInt(2000));
timer.stop();
System.out.println(timer.getCount())

}
}

7. Le lundi 30 août 2010, 16:34 par Ptitourson

Par classe anonyme, je modifie le comportement de la méthode stop() en utilisant un autre objet TimerThread, n'ayant pas accès à l'original déclaré private, non visible dans l'héritage :

Timer timer = new Timer() {
private TimerThread thread2 = new TimerThread();
@Override
public void start() { thread2.start(); }
@Override
public void stop() { thread2.stop(); System.out.println("Counter: " + thread2.getCounter()); }
};

timer.start();
Thread.sleep(new Random().nextInt(2000));
timer.stop();