一种常见的并发编程场景的处理

/**
 * 用于标志长时间独占表的线程是否正在工作。
 */
private AtomicBoolean closed = new AtomicBoolean(false);

/**
 * 用于标志当前的数据表是否正在插入数据。
 */
private AtomicInteger busy = new AtomicInteger();

/**
 * 用于存储数据的表格。
 */
private ConcurrentHashMap<String, String> map = new ConcurrentHashMap<String, String>();

/**
 * 多个线程会并发调用该接口向
 * map表中插入数据。
 * @param key
 * @param value
 */
public void addOneRecord(String key, String value)
{
    /**
     * 大多数时候，该循环都不会占用性能资源。
     */
    while (closed.get())
    {
        waitAMoment();
    }

    if (map != null)
    {
        /**
         * 用一个同步变量在各个线程中计数。
         */
        busy.getAndIncrement();
        map.put(key, value);
        busy.getAndDecrement();
    }
}

/**
 * 后台线程会定期处理map表中的数据。
 */
public void getAndClearAllRecords()
{
    synchronized (this)
    {
        /**
         * 先将closed标志设置，以便独占该map表； 
         * 避免操作过程中被修改。
         */
        closed.set(true);

        while (busy.get() != 0)
        {
            waitAMoment();
        }
        doSomeThingWithMap(map);
        closed.set(false);
    }
}

private void doSomeThingWithMap(ConcurrentHashMap<String, String> map)
{
    // TODO Auto-generated method stub

}

private void waitAMoment()
{
    // TODO Auto-generated method stub

}

 

总觉得分析这个问题有点纠结的感觉，其实用java，这点性能损失是可以忽略不计的。并且外层两个寄存器变量的读写并不一定比加锁性能好，而且在外层加锁的情况下，map表自身的锁竞争就不存在了，实际也只有1个锁在起作用，似乎问题没有那么糟糕。不管怎么样，这个工作感觉还是有一些意义的，总归是利大于弊吧。