分布式并发控制

Question

我已经做了几天了，我已经找到了几个解决方案，但没有一个非常简单或轻量级。问题基本上是这样的:我们有一个由10台机器组成的集群，每台机器在多线程ESB平台上运行相同的软件。我可以相当容易地处理同一台机器上线程之间的并发问题，但是不同机器上相同数据上的并发性如何呢？

从本质上说，该软件接收通过web服务将客户数据从一个业务传送到另一个业务的请求。但是，客户可能存在也可能不存在于另一个系统上。如果没有，我们将通过web服务方法创建它。因此，它需要一种测试和设置，但我需要某种类型的信号量来锁定其他机器，以避免产生争用条件。我以前曾遇到过这样的情况:为单个本地客户创建两次远程客户，这并不是理想的。

我在概念上玩过的解决方案是：

1. 使用我们的容错共享文件系统创建“锁”文件，根据客户的不同，每台机器将检查这些文件。
2. 在我们的数据库中使用一个特殊的表，并锁定整个表，以便对锁记录执行“测试和设置”。
3. 使用Terracotta，一种开源的服务器软件，它有助于扩展，但使用的是集线器和辐式模型。
4. 使用EHCache同步复制内存中的“锁”。

我无法想象我是唯一有过这种问题的人。你是怎么解决的？你是在家里做了什么，还是有最喜欢的第三方产品？

Answer 1

您可能需要考虑使用哈泽尔卡斯特分布式锁。超级轻巧又简单。

java.util.concurrent.locks.Lock lock = Hazelcast.getLock ("mymonitor");
lock.lock ();
try {
// do your stuff
}finally {
   lock.unlock();
}

分布式队列，地图，集，列表，锁

Answer 2

我们使用兵马俑，所以我想投赞成票。

我一直在关注Hazelcast，它看起来像是另一项很有前途的技术，但由于我没有使用它，所以我无法投票支持它，而且我知道它使用的是一个基于P2P的系统，所以我真的不会相信它有很大的扩展需求。

但我也听说过动物园管理员，这是从雅虎出来的，并且是在Hadoop的保护伞下移动的。如果你是冒险尝试一些新技术，这真的有很多希望，因为它是非常精益和刻薄，专注于仅仅是协调。我喜欢这个愿景和承诺，尽管它可能仍然是绿色的。

• http://www.terracotta.org
• http://wiki.apache.org/hadoop/ZooKeeper
• http://www.hazelcast.com

Answer 3

Terracotta更接近“分层”模型--所有客户端应用程序都与Terracotta对话(更重要的是，就规模而言，它们不相互交谈)。Terracotta能够对规模和可用性进行集群化(镜像，用于可用性，而条带，用于缩放)。

在任何情况下，正如您可能知道的那样，Terracotta可以通过使用POJO同步/等待/通知或使用任何java.util.concurrent原语(如ReentrantReadWriteLock、CyclicBarrier、AtomicLong、FutureTask等)，在集群中以相同的方式表示集群的并发性。

有许多简单的菜谱演示了这些原语在兵马俑食谱中的使用。

例如，我将发布ReentrantReadWriteLock示例(注意，锁没有"Terracotta“版本--您只需使用普通的ReentrantReadWriteLock)。

import java.util.concurrent.locks.*;

public class Main
{
    public static final Main instance = new Main();
    private int counter = 0;
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(true);

    public void read()
    {
        while (true) {
            rwl.readLock().lock();
                try {
                System.out.println("Counter is " + counter);
            } finally {
                rwl.readLock().unlock();
            }
            try { Thread.currentThread().sleep(1000); } catch (InterruptedException ie) {  }
        }
    }

    public void write()
    {
        while (true) {
            rwl.writeLock().lock();
            try {
               counter++;
               System.out.println("Incrementing counter.  Counter is " + counter);
            } finally {
                 rwl.writeLock().unlock();
            }
            try { Thread.currentThread().sleep(3000); } catch (InterruptedException ie) {  }
        }
    }

    public static void main(String[] args)
    {
        if (args.length > 0)  {
            // args --> Writer
            instance.write();
        } else {
            // no args --> Reader
            instance.read();
        }
    }
}