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

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

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

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

并发性 Java内存模型

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

Java同步

volatile[About] => synchronized

synchronized块在Java中是多线程中的监视器。同一对象/类的同步块只能由单个线程执行，其他的都在等待。它可以帮助解决竞赛状况。

Java 5通过支持happens-before扩展了同步[关于]

监视器的解锁(同步块或方法退出)发生在同一监视器的每个后续锁定(同步块或方法进入)之前。

下一步是java.util.concurrent

概述

Java中的Synchronized关键字与线程安全有关，也就是说，当多个线程读或写同一个变量时。 这可以直接发生(通过访问相同的变量)或间接发生(通过使用使用访问相同变量的另一个类的类)。

synchronized关键字用于定义一个代码块，其中多个线程可以以安全的方式访问同一个变量。

更深层次的

从语法上看，synchronized关键字接受一个Object作为它的参数(称为锁对象)，然后后面跟着一个{block of code}。

When execution encounters this keyword, the current thread tries to "lock/acquire/own" (take your pick) the lock object and execute the associated block of code after the lock has been acquired. Any writes to variables inside the synchronized code block are guaranteed to be visible to every other thread that similarly executes code inside a synchronized code block using the same lock object. Only one thread at a time can hold the lock, during which time all other threads trying to acquire the same lock object will wait (pause their execution). The lock will be released when execution exits the synchronized code block.

同步的方法:

将synchronized关键字添加到方法定义中等于将整个方法体包装在同步代码块中，锁对象为this(对于实例方法)和ClassInQuestion.getClass()(对于类方法)。

—实例方法是没有静态关键字的方法。 —类方法是具有静态关键字的方法。

技术

如果没有同步，就无法保证以何种顺序进行读写，可能会给变量留下垃圾。 (例如，一个变量可能由一个线程写入一半的比特，另一个线程写入一半的比特，使变量处于两个线程都没有尝试写入的状态，而是两者结合在一起的混乱状态。)

在另一个线程读取之前(时钟时间)完成一个线程的写操作是不够的，因为硬件可能已经缓存了变量的值，读取线程将看到缓存的值，而不是写入它的值。

结论

因此，在Java的情况下，您必须遵循Java内存模型，以确保线程错误不会发生。 换句话说:在底层使用同步、原子操作或为您使用它们的类。

来源 http://docs.oracle.com/javase/specs/jls/se8/html/index.html Java®语言规范，2015-02-13

下面是来自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.

What the other answers are missing is one important aspect: memory barriers. Thread synchronization basically consists of two parts: serialization and visibility. I advise everyone to google for "jvm memory barrier", as it is a non-trivial and extremely important topic (if you modify shared data accessed by multiple threads). Having done that, I advise looking at java.util.concurrent package's classes that help to avoid using explicit synchronization, which in turn helps keeping programs simple and efficient, maybe even preventing deadlocks.

ConcurrentLinkedDeque就是这样一个例子。与命令模式一起，它允许通过将命令填充到并发队列中来创建高效的工作线程——不需要显式同步，不可能发生死锁，不需要显式sleep()，只需通过调用take()轮询队列。

简而言之:“内存同步”隐式地发生在线程启动、线程结束、读取volatile变量、解锁监视器(留下同步块/函数)等时候。这种“同步”影响(在某种意义上“刷新”)在该特定操作之前完成的所有写操作。在前面提到的ConcurrentLinkedDeque的情况下，文档“说”:

内存一致性影响:与其他并发集合一样， 对象放入线程之前的操作 ConcurrentLinkedDeque访问之后的happens -before操作 或者从另一个ConcurrentLinkedDeque中删除该元素 线程。

这种隐式行为在某种程度上是有害的，因为大多数没有太多经验的Java程序员会因此而得过其实。然后突然被这个线程绊倒，因为Java在生产中没有做它“应该”做的事情，因为有不同的工作负载——并且很难测试并发性问题。

同步法等效于正常方法 同步语句(使用此语句)

class A {
    public synchronized void methodA() {
        // all function code
    }

    equivalent to

    public void methodA() {
        synchronized(this) {
             // all function code
        }
    } 
}

同步静态方法等价于Synchronized语句(使用类)

class A {
    public static synchronized void methodA() {
        // all function code
    }

    equivalent to

    public void methodA() {
        synchronized(A.class) {
             // all function code
        }
    } 
}

同步语句(使用变量)

class A {
    private Object lock1 = new Object();

    public void methodA() {
        synchronized(lock1 ) {
             // all function code
        }
    } 
}

对于同步，我们有同步方法和同步语句。然而，同步方法类似于同步语句，所以我们只需要理解同步语句。

基本上，我们会有

synchronized(object or class) { // object/class use to provides the intrinsic lock
   // code 
}

这里有2个想法，有助于理解同步

每个对象/类都有一个与之相关的内在锁。 当线程调用同步语句时，它会自动获取同步语句对象的内在锁，并在方法返回时释放锁。只要一个线程拥有一个内在锁，其他线程就不能获得相同的锁=>线程安全。

= > 当线程a调用synchronized(this){// code 1} =>时，所有synchronized(this)的块代码(类内)和所有synchronized的正常方法(类内)都被锁定，因为是SAME锁。它将在线程A解锁("// code 1"完成)后执行。

此行为类似于synchronized(变量){// code 1}或synchronized(类)。

SAME LOCK =>锁(不依赖于哪个方法?或者哪些陈述?)

使用同步方法还是同步语句?

我更喜欢同步语句，因为它更易于扩展。例如，在将来，你只需要同步方法的一部分。例如，你有两个synchronized方法，它们之间没有任何关联，但是当一个线程运行一个方法时，它会阻塞另一个方法(它可以通过使用synchronized(一个变量)来防止)。

然而，应用同步方法很简单，代码看起来很简单。对于某些类，只有一个同步方法，或者类中所有同步方法彼此相关=>，我们可以使用同步方法使代码更短，更容易理解

Note

(它与同步无关，它是对象与类或非静态与静态之间的区别)。

当你使用synchronized或普通方法或synchronized(this)或synchronized(非静态变量)时，它将基于每个对象实例进行同步。 当你使用synchronized或静态方法或synchronized(类)或synchronized(静态变量)时，它将基于类进行同步

参考

https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html

希望能有所帮助