ciao a tutti ora mi servirebbe di creare un countdown in java che pero' si comporti come un thread e che nn mi blocchi l'esecuzione della classe che chiama il contatore e che quando questo finisce cambia lo stato di una variabile.
in rete ho trovato questo ma leggendo il codice mi sembra che il metodo che fa partire il countdown deve aspettare l'esecuzione di tutta la classe..
/*
File: CountDown.java
Originally written by Doug Lea and released into the public domain.
This may be used for any purposes whatsoever without acknowledgment.
Thanks for the assistance and support of Sun Microsystems Labs,
and everyone contributing, testing, and using this code.
History:
Date Who What
11Jun1998 dl Create public version
*/
package EDU.oswego.cs.dl.util.concurrent;
/**
* A CountDown can serve as a simple one-shot barrier.
* A Countdown is initialized
* with a given count value. Each release decrements the count.
* All acquires block until the count reaches zero. Upon reaching
* zero all current acquires are unblocked and all
* subsequent acquires pass without blocking. This is a one-shot
* phenomenon -- the count cannot be reset.
* If you need a version that resets the count, consider
* using a Barrier.
*
* Sample usage. Here are a set of classes in which
* a group of worker threads use a countdown to
* notify a driver when all threads are complete.
* <pre>
* class Worker implements Runnable {
* private final CountDown done;
* Worker(CountDown d) { done = d; }
* public void run() {
* doWork();
* done.release();
* }
* }
*
* class Driver { // ...
* void main() {
* CountDown done = new CountDown(N);
* for (int i = 0; i < N; ++i)
* new Thread(new Worker(done)).start();
* doSomethingElse();
* done.acquire(); // wait for all to finish
* }
* }
* </pre>
*
*
[ Introduction to this package. ]
*
**/
public class CountDown implements Sync {
protected final int initialCount_;
protected int count_;
/** Create a new CountDown with given count value **/
public CountDown(int count) { count_ = initialCount_ = count; }
/*
This could use double-check, but doesn't out of concern
for surprising effects on user programs stemming
from lack of memory barriers with lack of synch.
*/
public void acquire() throws InterruptedException {
if (Thread.interrupted()) throw new InterruptedException();
synchronized(this) {
while (count_ > 0)
wait();
}
}
public boolean attempt(long msecs) throws InterruptedException {
if (Thread.interrupted()) throw new InterruptedException();
synchronized(this) {
if (count_ <= 0)
return true;
else if (msecs <= 0)
return false;
else {
long waitTime = msecs;
long start = System.currentTimeMillis();
for (;{
wait(waitTime);
if (count_ <= 0)
return true;
else {
waitTime = msecs - (System.currentTimeMillis() - start);
if (waitTime <= 0)
return false;
}
}
}
}
}
/**
* Decrement the count.
* After the initialCount'th release, all current and future
* acquires will pass
**/
public synchronized void release() {
if (--count_ == 0)
notifyAll();
}
/** Return the initial count value **/
public int initialCount() { return initialCount_; }
/**
* Return the current count value.
* This is just a snapshot value, that may change immediately
* after returning.
**/
public synchronized int currentCount() { return count_; }
}
Rispondi quotando
