同步很慢

Question

我正在尝试在许多线程上编写生命游戏，1 个单元 = 1 个线程，它需要线程之间的同步，因此在其他线程未完成读取先前状态之前，没有线程会开始计算它的新状态。这是我的代码

        public class Cell extends Processor{
            private static int count = 0;
            private static Semaphore waitForAll = new Semaphore(0);
            private static Semaphore waiter = new Semaphore(0);
            private IntField isDead;
            public Cell(int n)
            {
                super(n);
                count ++;
            }
            public void initialize()
            {
                this.algorithmName = Cell.class.getSimpleName();
                isDead = new IntField(0);
                this.addField(isDead, "state");
            }
            public synchronized void step()
            {
                int size = neighbours.size();
                IntField[] states = new IntField[size];
                int readElementValue = 0;
                IntField readElement;
                sendAll(new IntField(isDead.getDist()));
                Cell.waitForAll.release();
    //here wait untill all other threads  finish reading
                    while (Cell.waitForAll.availablePermits() != Cell.count) {
                    }
    //here release semaphore neader lower 
                Cell.waiter.release();
                for (int i = 0; i < neighbours.size(); i++) {
                    readElement = (IntField) reciveMessage(neighbours.get(i));
                    states[i] = (IntField) reciveMessage(neighbours.get(i));
                }
                int alive = 0;
                int dead = 0;
                for(IntField ii: states)
                {
                    if(ii.getDist() == 1)
                        alive++;
                    else
                        dead++;
                }
                if(isDead.getDist() == 0)
                {
                    if(alive == 3)
                        isDead.setValue(1);
                    else
                        ;
                }
                else
                {
                    if(alive == 3 || alive == 2)
                        ;
                    else
                        isDead.setValue(0);
                }
                try {
                    while(Cell.waiter.availablePermits() != Cell.count)
                    {
                        ;
                      //if every thread finished reading we can acquire this semaphore
                    }
                    Cell.waitForAll.acquire();
                    while(Cell.waitForAll.availablePermits() != 0)
                        ;
//here we make sure every thread ends step in same moment
                    Cell.waiter.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

处理器 类扩展thread 并在运行方法中，如果我打开它调用step() 方法。好吧，它适用于少量单元格，但是当我运行大约 36 个单元格时，它开始变得非常慢，如何修复我的同步以使其更快？

Answer 1

使用大量线程往往效率不高，但 36 并没有那么多，我认为它本身会产生一种差异，你会认为它“非常慢”。我认为这个问题更有可能是你的策略所固有的。特别是，我怀疑这种忙等待是有问题的：

Cell.waitForAll.release();
//here wait untill all other threads  finish reading
while (Cell.waitForAll.availablePermits() != Cell.count) {
}

忙等待总是是一个性能问题，因为您一遍又一遍地测试条件占用了 CPU。这种忙等待比大多数情况都糟糕，因为它涉及到同步对象的状态测试，这不仅有额外的开销，还会在线程之间引入额外的干扰。

您希望使用各种方法之一来使线程暂停执行，直到满足条件，而不是忙于等待。看起来您实际上所做的是创建了 CyclicBarrier 的穷人版本，因此您可以考虑使用 CyclicBarrier 本身。或者，由于这是一个学习练习，您可能会从学习如何使用 Object.wait()、Object.notify() 和 Object.notifyAll()（Java 的内置条件变量实现）中受益。

如果您坚持使用信号量，那么我认为您可以在没有忙等待的情况下做到这一点。使用信号量的关键是它能够（完全）获取表明线程可以继续进行的信号量，而不是可用许可的数量。如果您维护一个单独的变量来跟踪在给定点有多少线程在给定信号量上等待，那么到达该点的每个线程都可以确定是释放所有其他线程（并继续自己）还是通过尝试阻止获取信号量。