Java中有没有一种方法可以在单独的线程中对已经运行的对象调用方法？

其思想是，一个对象已经在执行某个方法，您可能希望调用另一个方法，该方法只在第一个方法完成时才开始执行。我想到的唯一方法是通过线程可见的成员传递消息，对象将检查消息，执行适当的方法，并可能将该方法的结果存放在第一个线程可以看到的地方。也许有更优雅的方法

---

编辑：我正在阅读有关异步注释或Spring的异步注释的文章，似乎这正是我所需要的…

向这两种方法添加

synchronized

尝试在使用和不使用synchronized关键字的情况下运行以下命令

public class SynchronizedMethods {

    public synchronized void longRunningMethodA() {
        System.out.println("Method A - Start");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e.getMessage(), e);
        }
        System.out.println("Method A - End"); 
    }

    public synchronized void longRunningMethodB() {
        System.out.println("Method B - Start");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e.getMessage(), e);
        }
        System.out.println("Method B - End"); 
    }



    public static void main(String[] args) {
        final SynchronizedMethods object = new SynchronizedMethods();

        new Thread() {public void run() {
            object.longRunningMethodB();
        }}.start();

        object.longRunningMethodA();
    }
}

---

快乐编码

将

同步
添加到两种方法中

尝试在使用和不使用synchronized关键字的情况下运行以下命令

public class SynchronizedMethods {

    public synchronized void longRunningMethodA() {
        System.out.println("Method A - Start");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e.getMessage(), e);
        }
        System.out.println("Method A - End"); 
    }

    public synchronized void longRunningMethodB() {
        System.out.println("Method B - Start");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e.getMessage(), e);
        }
        System.out.println("Method B - End"); 
    }



    public static void main(String[] args) {
        final SynchronizedMethods object = new SynchronizedMethods();

        new Thread() {public void run() {
            object.longRunningMethodB();
        }}.start();

        object.longRunningMethodA();
    }
}

快乐编码
 你会如何比较你的方法：这种方法是纯Java的，只需要添加2个关键字（没有库或学习曲线），并且已经工作了20年：D如果你需要的话，你也可以返回未来而不是无效。干杯。你会如何比较你的方法：这种方法是纯Java的，只需要添加2个关键字（没有库或学习曲线），并且已经工作了20年：D如果你需要的话，你也可以返回未来而不是无效。干杯。实际上没有“已经运行的对象”这样的东西。Java程序中唯一“运行”过的东西就是线程。方法是线程运行的对象，对象是方法指示线程操作的数据。当您希望一个线程等待另一个线程时（例如，“…调用另一个只在…”时开始执行的方法），这就是
java.util.concurrent
中的类派上用场的地方。例如，
SynchronousQueue
是一个线程向另一个线程传递“消息”或“令牌”的便捷方法<如果令牌不需要是显式对象，还可以使用code>Semaphore
和
CountDownLatch
以及其他
java.util.concurrent
类。如果调用了一个方法并且代码正在运行，可以调用第二个方法吗？如果是，第一个方法会发生什么情况？是否中断？好的，想象一个教室。老师在白板上写下一份指导清单，每个学生按照自己的步调遵循指导。方法类似于指令列表，线程类似于学生。线程执行方法要求执行的任何操作，但方法不知道或不关心线程，就像白板不知道或不关心有多少学生在遵循说明一样。如果没有阻止同步，任何数量的线程都可以同时执行相同的方法。当不同的线程访问相同的数据时，需要同步。如果白板上的说明说，“……在你的考试表格上写答案。”没问题，因为每个学生都有自己的表格。但是，如果说明书上写着“……在这里写下你的答案：Y.Y.Y.Y.Y.Y.Y.Y.S.”，那么这是个问题，因为有23个学生，只有一个空白。在Java中使用
synchronized
，以防止多个线程同时访问相同的共享数据。使用阻塞队列、信号量等以其他更复杂的方式协调线程。实际上不存在“已经运行的对象”。Java程序中唯一“运行”的是线程。方法是线程运行的对象，对象是方法指示线程操作的数据。当您希望一个线程等待另一个线程时（例如，“…调用另一个只在…”时开始执行的方法），这就是
java.util.concurrent
中的类派上用场的地方。例如，
SynchronousQueue
是一个线程向另一个线程传递“消息”或“令牌”的便捷方法<如果令牌不需要是显式对象，还可以使用code>Semaphore

和

CountDownLatch

以及其他

java.util.concurrent

类。如果调用了一个方法并且代码正在运行，可以调用第二个方法吗？如果是，第一个方法会发生什么情况？是否中断？好的，想象一个教室。老师在白板上写下一份指导清单，每个学生按照自己的步调遵循指导。方法类似于指令列表，线程类似于学生。线程执行方法要求执行的任何操作，但方法不知道或不关心线程，就像白板不知道或不关心有多少学生在遵循说明一样。如果没有阻止同步，任何数量的线程都可以同时执行相同的方法。当不同的线程访问相同的数据时，需要同步。如果白板上的说明说，“……在你的考试表格上写答案。”没问题，因为每个学生都有自己的表格。但是，如果说明书上写着“……在这里写下你的答案：Y.Y.Y.Y.Y.Y.Y.Y.S.”，那么这是个问题，因为有23个学生，只有一个空白。在Java中使用

synchronized

，以防止多个线程同时访问相同的共享数据。使用阻塞队列、信号量等以其他更复杂的方式协调线程。