如何跨不同的类和文件创建同步方法？

Question

我有多个文件和类。简而言之，一个人将计算一个粒子的位置，而另一个类移动粒子。我遇到的问题是在第一堂课完成计算之前粒子正在移动。我尝试使两种方法同步，但这似乎没有什么不同，是因为它们在不同的类中吗？最好的方法是什么？

编辑：我根本没有使用线程，它似乎在并行运行多个方法。

编辑 2：这是我的代码大纲

MovingParticle.java

public int x, y;

public void shootParticle(){
//move particle and change x, y values
//this method is called by a timer
}

public void drawParticle(){
//draws the particle
}

第二个文件

AllOtherParticles.java

public void checkIfTheyCollide(){
for(run through arrayList){
    //check if it collides with each point in array
}

public void drawCluster(){
//draws the cluster
}

Answer 1

我尝试使这两种方法同步，但似乎没有什么不同，是因为它们属于不同的类吗？

是的，将同步修饰符添加到方法会在调用该方法的对象上同步。也就是说，

public synchronized void foo() {
    // code
}

等价于

public void foo() {
    synchronized (this) {
        // code
    }
}

由于方法驻留在不同的类中，this 引用不同的对象，因此您不会在两种方法中使用相同的锁。

解决当前问题的合理方法是：

class Particle {
    synchronized void setLocation(Location loc) {
        // code
    }

    synchronized Location getLocation() {
        return location;
    }
}

编辑：当然，这假设涉及多个线程。如果只有一个线程，synchronized 无效，因此无济于事。

Answer 2

我还不明白你为什么要使用线程，而不是一个简单的循环，在它的主体中使用许多类。

但也许循环障碍会帮助您解决线程问题，我还没有完全理解。

使用 Cyclic Barrier 可以让您例如在多个线程中从 1 计数到 100，确保一个线程永远不会比其他线程快 1 步。

http://download.oracle.com/javase/6/docs/api/java/util/concurrent/CyclicBarrier.html

Answer 3

在两个线程中同步您正在修改的对象。

synchronized (TheParticle) {
  // Move it
}


synchronized (TheParticle) {
  // Calculate on it
}

Answer 4

假设这些方法不是同一个类上的方法，如果你简单地将它们声明为synchronized，它们将不会在同一个对象上同步。因此，您还没有实现互斥。

如果你想让两个不同的类在同一个对象上同步，你需要这样做：

public class Particle {
    public synchronized void foo() {
        // ... in critical region 
    }
}

public class Mover {
    public void bar() {
        ...
        synchronize (someParticle) {
            // ... in critical region 
        }
        ...
    }
}

请注意，这两种方法需要在同一个Particle 实例上同步。 synchronized 语句允许您在指定实例上同步，而不是在this 上同步。

Answer 5

我想我们可以在类上使用同步来实现两个不同资源之间的同步。 sn -p synchronized(X.class) 使用类实例作为监视器。看下面的代码和结果。如果我错了，请纠正我。

public class SyncTest1 {
    public static void main(String[] args) {
        System.out.println("Starting");
        SyncTest1 syncTest1 = new SyncTest1();
        Resource r1 = syncTest1.new Resource();
        Resource1 r2 = syncTest1.new Resource1();

    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            r1.printThread("T1");
        }
    };

    Runnable runnable2 = new Runnable() {
        @Override
        public void run() {
            r2.printThread("T2");
        }
    };

    new Thread(runnable).start();
    new Thread(runnable2).start();

    System.out.println("Done");
}

private class Resource {

    public void printThread(String threadName) {
        synchronized (String.class) {
            try {
                System.out.println(threadName + " Sleeping for 5 Sec");
                Thread.sleep(5000);
                System.out.println(threadName + " Waked up after 5 sec");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

private class Resource1 {
    public void printThread(String threadName) {
        synchronized (String.class) {
            try {
                System.out.println(threadName + " Sleeping for 5 Sec");
                Thread.sleep(5000);
                System.out.println(threadName + " Waked up after 5 sec");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

}

结果：

Starting
Done
T1 Sleeping for 5 Sec
T1 Waked up after 5 sec
T2 Sleeping for 5 Sec
T2 Waked up after 5 sec