Question

我认为,我看不出过去工作的情况。

我的锁定了排他性锁,在设计了新物体时,将安排<条码>、Lock、真实回归和另一条<条码> 。

public class A {
    private static Timer timer = new Timer();
    private static Lock clean_lock = new ReentrantLock();
    private static ConcurrentHashMap<String,B> _b_dict = new ConcurrentHashmap<String,B>();

    public A() {
        if(clean_lock.tryLock()) {
            timer.scheduleAtFixedRate(new TimerTaskThread(), new Date(), 60000);
        }
    }

    //Various NON static methods 
    // use an iterator at one point so they must be NON static

    class TimerTaskThread extends TimerTask {
        public void run() {
            //delete old stuff in _b_dict
        }
    }
}

//sample usage
public class Main {
    public Main() {
        A a = new A();
        a.contains(new B());
    }
}

Answer 1

Are you creating the other A instance from another thread? Because if you re creating both instances from the same thread, then, the lock being reentrant, tryLock obviously returns true.

如果你真的想从施工人员而不是从固定的组群中排出,那么你就应当使用静态的<代码>AtomicBoolean变量,并且只安排时间:compareAndSet(false, real)。

Answer 2

For what purpose are you using the lock here; just to ensure that timer.scheduleAtFixedRate is called only once (the first time the constructor of A is called)?

You could do it in a static initializer block instead, so that you don t need the lock at all:

public class A {
    private static final Timer timer = new Timer();
    private static final ConcurrentHashMap<String,B> _b_dict = new ConcurrentHashmap<String,B>();

    static {
        timer.scheduleAtFixedRate(new TimerTaskThread(), new Date(), 60000);
    }

    // etc.
}

If you use a static block, the scheduling will be done when the class is initialized (after it s loaded), rather than the first time you create an instance of it.

另一种可能性是使用<代码>。原子生物:

public class A {
    private static final Timer timer = new Timer();
    private static final AtomicBoolean initDone = new AtomicBoolean();
    private static final ConcurrentHashMap<String,B> _b_dict = new ConcurrentHashmap<String,B>();

    public A() {
        if (!initDone.getAndSet(true)) {
            timer.scheduleAtFixedRate(new TimerTaskThread(), new Date(), 60000);
        }
    }

    // etc.
}

Answer 3

这就是我要写的。

public class A {
    private static final ExecutorService service = Executors.newScheduledExecutorService();
    private static final ConcurrentMap<String,B> _b_dict = new ConcurrentHashmap<String,B>();
    static {
       service.scheduleAtFixedRate(new Runnable() {
           public void run() {
               cleanUp();
           }
       }, 1, 1, TimeUnit.MINUTES);
    }

    static void cleanUp() {
       // remove old entries
    }
}

友情链接