好了，我认为我们已经有了足够多的理论解释，所以考虑一下这段代码

public class SOP {
    public static void print(String s) {
        System.out.println(s+"\n");
    }
}

public class TestThread extends Thread {
    String name;
    TheDemo theDemo;
    public TestThread(String name,TheDemo theDemo) {
        this.theDemo = theDemo;
        this.name = name;
        start();
    }
    @Override
    public void run() {
        theDemo.test(name);
    }
}

public class TheDemo {
    public synchronized void test(String name) {
        for(int i=0;i<10;i++) {
            SOP.print(name + " :: "+i);
            try{
                Thread.sleep(500);
            } catch (Exception e) {
                SOP.print(e.getMessage());
            }
        }
    }
    public static void main(String[] args) {
        TheDemo theDemo = new TheDemo();
        new TestThread("THREAD 1",theDemo);
        new TestThread("THREAD 2",theDemo);
        new TestThread("THREAD 3",theDemo);
    }
}

注意:synchronized会阻塞下一个线程对test()方法的调用，只要前一个线程的执行没有完成。线程一次只能访问一个方法。如果没有同步，所有线程都可以同时访问这个方法。

当一个线程调用对象的同步方法'test'时(这里的对象是'TheDemo'类的一个实例)，它获得了该对象的锁，任何新的线程都不能调用同一对象的任何同步方法，只要之前获得锁的线程没有释放锁。

当调用类的任何静态同步方法时，也会发生类似的事情。线程获得与类关联的锁(在这种情况下，该类实例的任何非静态同步方法都可以被任何线程调用，因为对象级锁仍然可用)。只要当前持有类级锁的线程没有释放类级锁，任何其他线程都不能调用类的任何静态同步方法。

输出同步

THREAD 1 :: 0
THREAD 1 :: 1
THREAD 1 :: 2
THREAD 1 :: 3
THREAD 1 :: 4
THREAD 1 :: 5
THREAD 1 :: 6
THREAD 1 :: 7
THREAD 1 :: 8
THREAD 1 :: 9
THREAD 3 :: 0
THREAD 3 :: 1
THREAD 3 :: 2
THREAD 3 :: 3
THREAD 3 :: 4
THREAD 3 :: 5
THREAD 3 :: 6
THREAD 3 :: 7
THREAD 3 :: 8
THREAD 3 :: 9
THREAD 2 :: 0
THREAD 2 :: 1
THREAD 2 :: 2
THREAD 2 :: 3
THREAD 2 :: 4
THREAD 2 :: 5
THREAD 2 :: 6
THREAD 2 :: 7
THREAD 2 :: 8
THREAD 2 :: 9

输出未同步

THREAD 1 :: 0
THREAD 2 :: 0
THREAD 3 :: 0
THREAD 1 :: 1
THREAD 2 :: 1
THREAD 3 :: 1
THREAD 1 :: 2
THREAD 2 :: 2
THREAD 3 :: 2
THREAD 1 :: 3
THREAD 2 :: 3
THREAD 3 :: 3
THREAD 1 :: 4
THREAD 2 :: 4
THREAD 3 :: 4
THREAD 1 :: 5
THREAD 2 :: 5
THREAD 3 :: 5
THREAD 1 :: 6
THREAD 2 :: 6
THREAD 3 :: 6
THREAD 1 :: 7
THREAD 2 :: 7
THREAD 3 :: 7
THREAD 1 :: 8
THREAD 2 :: 8
THREAD 3 :: 8
THREAD 1 :: 9
THREAD 2 :: 9
THREAD 3 :: 9

下面是来自Java教程的解释。

考虑下面的代码:

public class SynchronizedCounter { private int c = 0; public synchronized void increment() { c++; } public synchronized void decrement() { c--; } public synchronized int value() { return c; } } if count is an instance of SynchronizedCounter, then making these methods synchronized has two effects: First, it is not possible for two invocations of synchronized methods on the same object to interleave. When one thread is executing a synchronized method for an object, all other threads that invoke synchronized methods for the same object block (suspend execution) until the first thread is done with the object. Second, when a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads.

synchronized关键字是关于不同的线程读写相同的变量、对象和资源。这在Java中不是一个微不足道的话题，但这里引用Sun的一段话:

同步方法可以实现简单的 防止线程的策略 干扰和记忆一致性 错误:如果对象是可见的 多于一个线程，全部读取或 写入该对象的变量为 通过同步方法完成。

简而言之:当你有两个线程读写同一个“资源”时，比如说一个名为foo的变量，你需要确保这些线程以原子的方式访问变量。如果没有synchronized关键字，线程1可能看不到线程2对foo所做的更改，或者更糟的是，它可能只改变了一半。这不是你逻辑上所期望的。

同样，这在Java中是一个重要的主题。要了解更多，请在这里探索关于SO和互联网的主题:

并发性 Java内存模型

继续探索这些话题，直到“Brian Goetz”这个名字在你的脑海中与“并发性”这个术语永久地联系在一起。

synchronized关键字是什么?

线程主要通过共享对字段和引用字段所引用的对象的访问进行通信。这种通信形式非常高效，但可能会产生两种错误:线程干扰和内存一致性错误。防止这些错误所需的工具是同步。

同步块或方法可以防止线程干扰，并确保数据是一致的。在任何时候，只有一个线程可以通过获得锁来访问同步块或方法(临界区)。其他线程将等待锁释放来访问临界区。

方法何时同步?

将synchronized添加到方法定义或声明时，方法是同步的。您还可以在方法中同步特定的代码块。

它在语法上和逻辑上意味着什么?

这意味着只有一个线程可以通过获得锁来访问临界区。除非这个线程释放这个锁，否则所有其他线程将不得不等待获得一个锁。他们不能在没有锁的情况下进入临界区。

这不是魔法能办到的。程序员的职责是识别应用程序中的关键部分并相应地保护它。Java提供了一个框架来保护你的应用程序，但是在哪里以及保护哪些部分是程序员的责任。

更多细节，请参阅java文档页

内在锁和同步:

同步是围绕一个称为内在锁或监视器锁的内部实体构建的。内在锁在同步的两个方面都发挥作用:强制对对象状态的独占访问，并建立对可见性至关重要的happens-before关系。

每个对象都有一个与之相关的内在锁。按照惯例，需要独占和一致访问对象字段的线程必须在访问对象字段之前获得对象的内在锁，然后在使用完对象字段时释放内在锁。

线程在获得锁和释放锁之间拥有内在锁。只要一个线程拥有一个内在锁，其他线程就不能获得相同的锁。另一个线程在试图获取锁时将阻塞。

当线程释放一个内在锁时，在该操作和后续获得的任何相同锁之间建立happens-before关系。

使方法同步有两个效果:

首先，对同一对象的同步方法的两次调用不可能交织。

当一个线程正在为一个对象执行同步方法时，所有为同一对象调用同步方法的其他线程将暂停执行，直到第一个线程处理完该对象。

其次，当同步方法退出时，它自动与同一对象的同步方法的任何后续调用建立happens-before关系。

这保证了对对象状态的更改对于所有线程都是可见的。

寻找同步的其他替代方案:

避免在Java中同步(这)?

synchronized是Java中的关键字，用于在多线程环境中使发生在关系之前，以避免内存不一致和线程干扰错误。

Synchronized simple意味着没有两个线程可以同时访问块/方法。当我们说一个类的任何块/方法都是同步的，这意味着一次只有一个线程可以访问它们。在内部，试图访问它的线程首先在该对象上获得一个锁，只要这个锁不可用，其他线程就不能访问该类实例的任何同步方法/块。

注意，另一个线程可以访问同一对象的方法，该方法没有被定义为同步。线程可以通过调用来释放锁

Object.wait()