java - 锁定实际正在读取哪些字段的对象

Question

我们有这样的情况

    class Pole extends Thread
{
    JButton pole;
    Plansza p;
    Pole neighbours[] = new Pole[4];
    public Pole(Plansza p)
    {
        this.p = p; 
        pole = new JButton();
        int r,g,b;
        r=p.rndColor();
        g=p.rndColor();
        b=p.rndColor();
        pole.setBackground(new Color(r,g,b));
    }
    public Pole()
    {
        ;
    }

    public void run()
    {
        while(true)
        {
            Thread.yield();
            try
            {
                Thread.sleep((int)p.rndTime());
            }
            catch(InterruptedException e)
            {
                ;
            }
            if(p.rnd.nextDouble()<=1-p.p)
                setNeighboursColor();
            if(p.rnd.nextDouble()<=p.p)
                setRandomColor();
        }
    }

    public void setRandomColor()
    {
        synchronized(this)
        {
            int r,g,b;
            r = p.rndColor();
            g = p.rndColor();
            b = p.rndColor();
            pole.setBackground(new Color(r,g,b));
        }
    }
    public void setNeighboursColor()
    {
        synchronized(this)
        {

            int r,g,b;
            Color c0 = neighbours[0].pole.getBackground();
            Color c1 = neighbours[1].pole.getBackground();
            Color c2 = neighbours[2].pole.getBackground();
            Color c3 = neighbours[3].pole.getBackground();
            r = (int)(c0.getRed() + c1.getRed() + c2.getRed() + c3.getRed())/4;
            g = (int)(c0.getGreen() + c1.getGreen() + c2.getGreen() + c3.getGreen())/4;
            b = (int)(c0.getBlue() + c1.getBlue() + c2.getBlue() + c3.getBlue())/4;
            Color nc = new Color(r,g,b);
            pole.setBackground(nc);
        }
    }
}

我编辑了问题并粘贴了我的代码，所以现在可能更清楚了每个 Pole(Field) 与其他 4 个 Pole 对象有邻居关系，因此我们有很多这样的对象，并且每个对象都是不同的线程，它们可以从邻居读取颜色并将其自身颜色更改为邻居颜色的算术平均值。

Answer 1

无意刻薄，我认为您对于 Java 中同步的工作原理完全错误。

Java 中没有办法“锁定对象”。您的问题并不完全清楚，因为 X 有一个奇怪的无限嵌套事情还在继续，所以 x[1]是模棱两可的。但本质是，如果一个对象尝试分配或读取另一个对象的字段，它将成功读取/写入。它可以等待的唯一方法是它事先选择在监视器上同步。 (当然，这种等待可以被封装，例如，如果 c 是 AtomicReference<Color> 或类似的 - 则不必显式完成。)

此外，如果涉及多个线程，那么可见性也会成为一个问题。您必须声明 X 数组，以及Color变量，如volatile否则无法保证其他线程会看到更新。或者，如果您确实选择走同步路线，并始终如一地这样做，可见性也将得到保证(尽管这听起来并不符合您的想法)。

我不完全确定您想要在这里实现什么，因此无法提供任何设计建议。不过，我确实推荐《Java Concurrency In Practice》一书。并发性很难，如果您想避免细微的错误，就必须认真思考它。与任何其他开发领域相比，它更需要预先了解原则，而不是在问题出现时就敷衍了事。