在同步代码块中调用java计时器

如果我有一个称为a的父代码块，则a是同步的。在A中，我执行一个子代码块，称为B。我假设B也将同步，对吗

如果在A中，我有一个计时器在某个t时间内延迟B的执行，当A已经完成时，B是否有可能稍后执行

非常感谢

p/S：很抱歉，代码不清楚，应该是这样的

   synchronized  A{
    Timer timer = new Timer();
    timer.schedule(new TimerTask() {
      @Override
      public void run() {
        B block
      }
    }, 2*60*1000);

    } 

---

视情况而定。如果块B是这样的方法中的一个代码块，那么是。。。它将被同步

public synchronized void methodA() {
    // Block B
    {
       // some code
    }
}

如果是另一种方法，如以下所示，则为否：

public synchronized void methodA() {
    methodB();
}

public void methodB() {
    // Block B code
    // Nothing prevents an unsynchronized method from calling this method
    //   at same time as methodA() holds  lock on `this` object
}

除非

methodB

也被标记为

synchronized

，或者从另一个同步方法（例如/

public synchronized methodC（）

）调用，或者使用了另一个同步机制，否则

methodB（）

是不同步的

public synchronized void methodA() {
    // Block B
    {
       // some code
    }
}

这些只是最简单的例子。您最好发布示例代码，因为默认情况下“块”没有很好的定义，并且同步锁的类型（通过同步方法隐式的

此
与显式的对象锁）会有所不同

但是，最后一行听起来像是在问代码的同步与异步执行，虽然与线程和
synchronized
块有关，但这是一个不同的概念

在这种情况下，这取决于
块A中发生的情况。。。如果创建新线程来执行
块B
，那么代码执行的计时可能会发生任何事情。如果没有创建线程，可以安全地假设
块A
在
块B
之前不会完成

编辑：基于现在发布的代码。。。同步的
A块
只能确保一次创建一个计时器线程。但是，除非Java
Timer
框架有什么特别之处，否则没有任何东西可以阻止两个线程同时执行
run
方法中的
B块
。。。因此，请确保内容是线程安全的

也就是说，不要假设仅仅因为在同步块中以相同的延迟创建了不同的
Timer
实例，它们就不会同时进入run方法。如果
B块
访问外部非线程安全代码（例如静态方法、磁盘访问），您可能会感到意外

正如Amm Sokun在其他回答中提到的，
A{}
将在

块B执行。
取决于。如果块B是这样的方法中的一个代码块，那么是。。。它将被同步

public synchronized void methodA() {
    // Block B
    {
       // some code
    }
}

如果是另一种方法，如以下所示，则为否：

public synchronized void methodA() {
    methodB();
}

public void methodB() {
    // Block B code
    // Nothing prevents an unsynchronized method from calling this method
    //   at same time as methodA() holds  lock on `this` object
}

除非
methodB
也被标记为
synchronized
，或者从另一个同步方法（例如/
public synchronized methodC（）
）调用，或者使用了另一个同步机制，否则
methodB（）
是不同步的

public synchronized void methodA() {
    // Block B
    {
       // some code
    }
}

这些只是最简单的例子。您最好发布示例代码，因为默认情况下“块”没有很好的定义，并且同步锁的类型（通过同步方法隐式的
此
与显式的对象锁）会有所不同

但是，最后一行听起来像是在问代码的同步与异步执行，虽然与线程和
synchronized
块有关，但这是一个不同的概念

在这种情况下，这取决于
块A中发生的情况。。。如果创建新线程来执行
块B
，那么代码执行的计时可能会发生任何事情。如果没有创建线程，可以安全地假设
块A
在
块B
之前不会完成

编辑：基于现在发布的代码。。。同步的
A块
只能确保一次创建一个计时器线程。但是，除非Java
Timer
框架有什么特别之处，否则没有任何东西可以阻止两个线程同时执行
run
方法中的
B块
。。。因此，请确保内容是线程安全的

也就是说，不要假设仅仅因为在同步块中以相同的延迟创建了不同的
Timer
实例，它们就不会同时进入run方法。如果
B块
访问外部非线程安全代码（例如静态方法、磁盘访问），您可能会感到意外

正如Amm Sokun在其他回答中提到的，
A{}
将在

块B执行。
取决于。如果块B是这样的方法中的一个代码块，那么是。。。它将被同步

public synchronized void methodA() {
    // Block B
    {
       // some code
    }
}

如果是另一种方法，如以下所示，则为否：

public synchronized void methodA() {
    methodB();
}

public void methodB() {
    // Block B code
    // Nothing prevents an unsynchronized method from calling this method
    //   at same time as methodA() holds  lock on `this` object
}

除非
methodB
也被标记为
synchronized
，或者从另一个同步方法（例如/
public synchronized methodC（）
）调用，或者使用了另一个同步机制，否则
methodB（）
是不同步的

public synchronized void methodA() {
    // Block B
    {
       // some code
    }
}

这些只是最简单的例子。您最好发布示例代码，因为默认情况下“块”没有很好的定义，并且同步锁的类型（通过同步方法隐式的
此
与显式的对象锁）会有所不同

但是，最后一行听起来像是在问代码的同步与异步执行，虽然与线程和
synchronized
块有关，但这是一个不同的概念

在这种情况下，这取决于
块A中发生的情况。。。如果创建新线程来执行
块B
，那么代码执行的计时可能会发生任何事情。如果没有创建线程，可以安全地假设
块A
在
块B
之前不会完成

编辑：基于现在发布的代码。。。同步的
A块
将只确保一次创建一个计时器线程