概述

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

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在生产中没有做它“应该”做的事情，因为有不同的工作负载——并且很难测试并发性问题。

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

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

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

Object.wait()

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

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

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

希望能有所帮助