synchronized关键字使线程在输入方法时获得锁，以便同一时间只有一个线程可以执行该方法(对于给定的对象实例，除非它是静态方法)。

这通常被称为使类线程安全，但我认为这是一种委婉说法。虽然同步确实可以保护Vector的内部状态不被破坏，但这通常对Vector的用户没有太大帮助。

考虑一下:

 if (vector.isEmpty()){
     vector.add(data);
 }

尽管所涉及的方法是同步的，但由于它们分别被锁定和解锁，两个不幸计时的线程可以创建具有两个元素的向量。

所以实际上，你也必须在你的应用程序代码中同步。

因为方法级同步是a)当你不需要它的时候很昂贵，b)当你需要同步的时候不够用，所以现在有了不同步的替换(Vector的情况下是ArrayList)。

最近，并发包已经发布，其中包含许多处理多线程问题的聪明实用程序。

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

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

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

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

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

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

并发性 Java内存模型

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

以我的理解，同步基本上意味着编译器编写一个监视器。进入并监控。在方法周围退出。因此，它可能是线程安全的，这取决于它是如何使用的(我的意思是，你可以编写一个具有同步方法的对象，它不是线程安全的，这取决于你的类做什么)。

synchronized关键字可以防止多个线程并发访问一个代码块或对象。Hashtable的所有方法都是同步的，因此一次只有一个线程可以执行其中的任何方法。

当使用非同步结构(如HashMap)时，必须在代码中构建线程安全特性以防止一致性错误。

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