blocks|key|2358849|text|据我的理解，同步基本上意味着编译器围绕您的方法编写一个monitor.enter和monitor.exit。因此，它可能是线程安全的，这取决于它的使用方式(我的意思是，您可以使用同步方法编写对象，而不是线程安全，这取决于您的类所做的事情)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2358850|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

To my understanding synchronized basically means that the compiler write a monitor.enter and monitor.exit around your method. As such it may be thread safe depending on how it is used (what I mean is you can write an object with synchronized methods that isn't threadsafe depending on what your class does).

blocks|key|832968|text|synchronized关键字都是关于不同线程对相同的变量、对象和资源进行读写的。在Java中，这不是一个微不足道的话题，但以下是Sun的引语：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|832969|synchronized方法支持防止线程干扰和内存一致性错误的简单策略:如果一个对象对多个线程可见，则通过同步方法对该对象的变量进行所有读或写操作。|blockquote|832970|简单地说，当您有两个线程正在读取和写入相同的“资源”(比如一个名为foo的变量)时，您需要确保这些线程以原子方式访问变量。如果没有synchronized关键字，您的线程1可能不会看到将线程2更改为foo，或者更糟糕的是，它可能只更改了一半。这不是你逻辑上所期望的。|832971|同样，这是Java中一个重要的主题。要了解更多信息，请浏览SO和Interweb上的主题：|832972|并发性|unordered-list-item|832973|Java内存模型|832974|继续探索这些主题，直到"Brian“这个名字永久地与你大脑中的”并发“一词联系在一起。|832975|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/essential/concurrency/index.html|1|http://en.wikipedia.org/wiki/Java_Memory_Model^0|0|C|0|0|C|0|X|3|1T|C|2R|3|0|0|0|3|0|0|0|8|1|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|I|3|J|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|K|3|L|5|6|7|1G|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|1H|8|@]|D|@$9|1I|A|1J|1|1K]]|E|$]]|$1|P|3|Q|5|O|7|1L|8|@]|D|@$9|1M|A|1N|1|1O]]|E|$]]|$1|R|3|S|5|6|7|1P|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]]|U|$V|$5|W|X|Y|E|$Z|10]]|11|$5|W|X|Y|E|$Z|12]]]]

The <code>synchronized</code> keyword is all about different threads reading and writing to the same variables, objects and resources. This is not a trivial topic in Java, but here is a quote from Sun:

<blockquote>
 <code>synchronized</code> methods enable a simple
 strategy for preventing thread
 interference and memory consistency
 errors: if an object is visible to
 more than one thread, all reads or
 writes to that object's variables are
 done through synchronized methods.
</blockquote>

In a very, very small nutshell: When you have two threads that are reading and writing to the same 'resource', say a variable named <code>foo</code>, you need to ensure that these threads access the variable in an atomic way. Without the <code>synchronized</code> keyword, your thread 1 may not see the change thread 2 made to <code>foo</code>, or worse, it may only be half changed. This would not be what you logically expect.

Again, this is a non-trivial topic in Java. To learn more, explore topics here on SO and the Interwebs about:

<ul>
<li><a href="https://docs.oracle.com/javase/tutorial/essential/concurrency/index.html" rel="noreferrer">Concurrency</a></li>
<li><a href="http://en.wikipedia.org/wiki/Java_Memory_Model" rel="noreferrer">Java Memory Model</a></li>
</ul>

Keep exploring these topics until the name "Brian Goetz" becomes permanently associated with the term "concurrency" in your brain.

blocks|key|2358986|text|synchronized关键字导致线程在进入该方法时获得锁，因此只有一个线程可以同时执行该方法(对于给定的对象实例，除非它是静态方法)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2358987|这通常被称为使类线程安全，但我想说这是一个委婉的说法。虽然同步确实保护向量的内部状态不受损坏，但这通常不会对向量的用户有太大帮助。|2358988|考虑到这一点：|2358989|+if+(vector.isEmpty()){
+++++vector.add(data);
+}|code-block|syntax|javascript|2358990|尽管所涉及的方法是同步的，因为它们被单独锁定和解锁，但不幸的是，两个定时线程可以创建一个包含两个元素的向量。|2358991|因此，实际上，您还必须在应用程序代码中进行同步。|2358992|由于方法级同步在不需要时是昂贵的，而当需要同步时则是不够的，所以现在有了不同步的替换(向量的情况下是ArrayList)。|2358993|最近，并发包已经发布，有许多聪明的实用程序来处理多线程问题。|2358994|entityMap^0|0|C|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|12|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|13|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|15|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|16|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|17|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|X|$]]

The <code>synchronized</code> keyword causes a thread to obtain a lock when entering the method, so that only one thread can execute the method at the same time (for the given object instance, unless it is a static method).

This is frequently called making the class thread-safe, but I would say this is a euphemism. While it is true that synchronization protects the internal state of the Vector from getting corrupted, this does not usually help the user of Vector much. 

Consider this:

<pre><code> if (vector.isEmpty()){
 vector.add(data);
 }
</code></pre>

Even though the methods involved are synchronized, because they are being locked and unlocked individually, two unfortunately timed threads can create a vector with two elements.

So in effect, you have to synchronize in your application code as well.

Because method-level synchronization is a) expensive when you don't need it and b) insufficient when you need synchronization, there are now un-synchronized replacements (ArrayList in the case of Vector).

More recently, the concurrency package has been released, with a number of clever utilities that take care of multi-threading issues.

blocks|key|2359000|text|把它想象成一种转门，就像你在足球场上看到的那样。有很多人想进去，但在转门上，他们是“同步”的。一次只有一个人能通过。所有那些想要通过的人都能做到，但他们可能不得不等待，直到他们通过。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2359001|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Think of it as a kind of turnstile like you might find at a football ground. There are parallel steams of people wanting to get in but at the turnstile they are 'synchronised'. Only one person at a time can get through. All those wanting to get through will do, but they may have to wait until they can go through.

blocks|key|833047|text|synchronized意味着在多线程环境中，具有synchronized方法/block(S)的对象不允许两个线程同时访问代码的synchronized方法/block(S)。这意味着一个线程无法读取，而另一个线程更新它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|833048|第二个线程将等待第一个线程完成其执行。开销是速度，但优点是保证数据的一致性。|833049|但是，如果您的应用程序是单线程的，则synchronized块不能提供好处。|833050|entityMap^0|0|C|P|C|1T|C|0|0|I|C|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|K|$]]

<code>synchronized</code> means that in a multi threaded environment, an object having <code>synchronized</code> method(s)/block(s) does not let two threads to access the <code>synchronized</code> method(s)/block(s) of code at the same time. This means that one thread can't read while another thread updates it.

The second thread will instead wait until the first thread completes its execution. The overhead is speed, but the advantage is guaranteed consistency of data.

If your application is single threaded though, <code>synchronized</code> blocks does not provide benefits.

blocks|key|2359047|text|synchronized关键字防止多个线程并发访问代码块或对象。Hashtable的所有方法都是synchronized，因此一次只能执行一个线程。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2359048|当使用非synchronized结构(如HashMap+)时，必须在代码中构建线程安全特性，以防止一致性错误。|2359049|entityMap^0|0|C|W|9|1C|C|0|4|C|K|7|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|I|$]]

The <code>synchronized</code> keyword prevents concurrent access to a block of code or object by multiple threads. All the methods of <code>Hashtable</code> are <code>synchronized</code>, so only one thread can execute any of them at a time. 

When using non-<code>synchronized</code> constructs like <code>HashMap</code>, you must build thread-safety features in your code to prevent consistency errors.

blocks|key|833159|text|同步简单意味着没有两个线程可以同时访问块/方法。当我们说类的任何块/方法是同步的时，这意味着一次只能有一个线程访问它们。在内部，试图访问它的线程首先对该对象使用一个锁，并且只要该锁不可用，任何其他线程都不能访问该类实例的任何同步方法/块。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|833160|注另一个线程可以访问未定义为同步的同一对象的方法。线程可以通过调用|833161|Object.wait()|code-block|syntax|javascript|833162|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

synchronized simple means no two threads can access the block/method simultaneously. When we say any block/method of a class is synchronized it means only one thread can access them at a time. Internally the thread which tries to access it first take a lock on that object and as long as this lock is not available no other thread can access any of the synchronized methods/blocks of that instance of the class.

Note another thread can access a method of the same object which is not defined to be synchronized. A thread can release the lock by calling

<pre><code>Object.wait()
</code></pre>

blocks|key|947477|text|好吧，我想我们已经有足够的理论解释了，所以考虑一下这段代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|947478|public+class+SOP+{
++++public+static+void+print(String+s)+{
++++++++System.out.println(s%2B"\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%2B%2B)+{
++++++++++++SOP.print(name+%2B+"+::+"%2Bi);
++++++++++++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);
++++}
}|code-block|syntax|javascript|947479|注意:只要前一个线程的执行未完成，synchronized就会阻止下一个线程对方法test()的调用。线程可以一次访问此方法。没有synchronized，所有线程都可以同时访问此方法。|offset|length|style|CODE|947480|当线程调用对象的同步方法'test‘(此处对象是'TheDemo’类的一个实例)时，它获得该对象的锁时，任何新线程都不能调用同一对象的任何同步方法，只要获得锁的前一个线程不释放锁。|947481|当调用类的任何静态同步方法时，也会发生类似的情况。线程获取与类关联的锁(在本例中，该类实例的任何非静态同步方法都可以由任何线程调用，因为该对象级别的锁仍然可用)。任何其他线程都不能调用类的任何静态同步方法，只要当前持有锁的线程不释放类级别的锁。|947482|带有同步的输出|BOLD|947483|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|947484|没有同步的输出|947485|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|947486|entityMap^0|0|0|H|C|1T|C|0|0|0|4|1|0|0|4|1|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|13|8|@$I|14|J|15|K|L]|$I|16|J|17|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|19|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1A|8|@$I|1B|J|1C|K|S]]|9|@]|A|$]]|$1|T|3|U|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|V|3|W|5|6|7|1E|8|@$I|1F|J|1G|K|S]]|9|@]|A|$]]|$1|X|3|Y|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|Z|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|10|$]]

Well, I think we had enough of theoretical explanations, so consider this code

<pre><code>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&lt;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);
 }
}
</code></pre>

Note: <code>synchronized</code> blocks the next thread's call to method test() as long as the previous thread's execution is not finished. Threads can access this method one at a time. Without <code>synchronized</code> all threads can access this method simultaneously.

When a thread calls the synchronized method 'test' of the object (here object is an instance of 'TheDemo' class) it acquires the lock of that object, any new thread cannot call ANY synchronized method of the same object as long as previous thread which had acquired the lock does not release the lock.

Similar thing happens when any static synchronized method of the class is called. The thread acquires the lock associated with the class(in this case any non static synchronized method of an instance of that class can be called by any thread because that object level lock is still available). Any other thread will not be able to call any static synchronized method of the class as long as the class level lock is not released by the thread which currently holds the lock.

Output with synchronised

<pre><code>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
</code></pre>

Output without synchronized

<pre><code>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
</code></pre>

blocks|key|2359117|text|同步是Java中的一个关键字，用于使多线程环境中的关系发生在关系之前，以避免内存不一致和线程干扰错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2359118|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

synchronized is a keyword in Java which is used to make happens before relationship in multithreading environment to avoid memory inconsistency and thread interference error.

blocks|key|2359175|text|概述|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2359176|Java中的同步关键字与线程安全性有关，也就是说，当多个线程读取或写入相同的变量时。|2359177|这可以直接(通过访问同一个变量)或间接(通过使用使用访问相同变量的另一个类的类)来实现。|2359178|同步关键字用于定义一个代码块，其中多个线程可以安全地访问同一个变量。|2359179|更深层次|2359180|从语法上讲，synchronized关键字接受一个Object作为它的参数(称为锁对象)，然后是一个{+block+of+code+}。|offset|length|style|CODE|2359181|当执行遇到此关键字时，当前线程尝试“锁定/获取/拥有”(请选择)锁对象，并在获得锁后执行相关的代码块。|unordered-list-item|2359182|对同步代码块中的变量的任何写入都保证对使用同一个锁对象在同步代码块内执行代码的其他线程都是可见的。|2359183|每次只有一个线程可以保存锁，在此期间，试图获取同一个锁对象的所有其他线程都将等待(暂停执行)。当执行退出同步代码块时，锁将被释放。|2359184|同步方法：|2359185|将synchronized关键字添加到方法定义等于将整个方法主体包装在同步代码块中，其中锁对象为this+(例如方法)和ClassInQuestion.getClass()+(用于类方法)。|2359186|实例方法是一种没有static关键字的方法。|2359187|类方法是一种具有static关键字的方法。|2359188|技术|2359189|如果没有同步，就无法保证读取和写入的顺序，可能会将变量留给垃圾。|2359190|(例如，一个变量可能以一个线程写入的位数的一半和另一个线程写入的位数的一半结束，使变量处于两个线程都不试图写的状态，但两者的组合混乱。)|2359191|在另一个线程读取它之前(挂钟时间)完成线程中的写操作是不够的，因为硬件可能已经缓存了变量的值，并且读取线程将看到缓存的值而不是写入的值。|2359192|结论|2359193|因此，在Java的情况下，您必须遵循Java内存模型，以确保线程错误不会发生。|2359194|换句话说:使用同步、原子操作或类为您在引擎盖下面使用它们。|2359195|资料来源
http://docs.oracle.com/javase/specs/jls/se8/html/index.html
Java语言规范，2015-02-13|blockquote|2359196|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/specs/jls/se8/html/index.html^0|0|0|0|0|0|6|C|P|6|1E|H|0|0|0|0|0|1|C|1C|4|1O|Q|0|9|6|0|8|6|0|0|0|0|0|0|0|0|5|1N|0|0^^$0|@$1|2|3|4|5|6|7|1T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1X|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1Y|8|@$L|1Z|M|20|N|O]|$L|21|M|22|N|O]|$L|23|M|24|N|O]]|9|@]|A|$]]|$1|P|3|Q|5|R|7|25|8|@]|9|@]|A|$]]|$1|S|3|T|5|R|7|26|8|@]|9|@]|A|$]]|$1|U|3|V|5|R|7|27|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|28|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|29|8|@$L|2A|M|2B|N|O]|$L|2C|M|2D|N|O]|$L|2E|M|2F|N|O]]|9|@]|A|$]]|$1|10|3|11|5|6|7|2G|8|@$L|2H|M|2I|N|O]]|9|@]|A|$]]|$1|12|3|13|5|6|7|2J|8|@$L|2K|M|2L|N|O]]|9|@]|A|$]]|$1|14|3|15|5|6|7|2M|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2N|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2P|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2R|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2S|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|1K|7|2T|8|@]|9|@$L|2U|M|2V|1|2W]]|A|$]]|$1|1L|3|-4|5|6|7|2X|8|@]|9|@]|A|$]]]|1M|$1N|$5|1O|1P|1Q|A|$1R|1S]]]]

<h3>Overview</h3>

Synchronized keyword in Java has to do with thread-safety, that is, when multiple threads read or write the same variable. 
This can happen directly (by accessing the same variable) or indirectly (by using a class that uses another class that accesses the same variable).

The synchronized keyword is used to define a block of code where multiple threads can access the same variable in a safe way.

<h3>Deeper</h3>

Syntax-wise the <code>synchronized</code> keyword takes an <code>Object</code> as it's parameter (called a lock object), which is then followed by a <code>{ block of code }</code>.

<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
</ul>

<h3>Synchronized methods:</h3>

Adding <code>synchronized</code> keyword to a method definition is equal to the entire method body being wrapped in a synchronized code block with the lock object being <code>this</code> (for instance methods) and <code>ClassInQuestion.getClass()</code> (for class methods).

- Instance method is a method which does not have <code>static</code> keyword. 
- Class method is a method which has <code>static</code> keyword.

<h3>Technical</h3>

Without synchronization, it is not guaranteed in which order the reads and writes happen, possibly leaving the variable with garbage. 
(For example a variable could end up with half of the bits written by one thread and half of the bits written by another thread, leaving the variable in a state that neither of the threads tried to write, but a combined mess of both.)

It is not enough to complete a write operation in a thread before (wall-clock time) another thread reads it, because hardware could have cached the value of the variable, and the reading thread would see the cached value instead of what was written to it.

<h3>Conclusion</h3>

Thus in Java's case, you have to follow the Java Memory Model to ensure that threading errors do not happen. 
In other words: Use synchronization, atomic operations or classes that use them for you under the hoods.

<blockquote>
 <h3>Sources</h3>
 
 <a href="http://docs.oracle.com/javase/specs/jls/se8/html/index.html">http://docs.oracle.com/javase/specs/jls/se8/html/index.html</a> 
 Java® Language Specification, 2015-02-13
</blockquote>

blocks|key|2359277|text|什么是同步关键字？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|2359278|线程主要通过共享对字段的访问和对象引用字段进行通信。这种通信方式非常有效，但使两种错误成为可能：线程干扰和内存一致性错误。防止这些错误的工具是同步。|unstyled|offset|length|style|BOLD|2359279|同步块或方法防止线程干扰，并确保数据是一致的。在任何时候，只有一个线程可以通过获取锁来访问同步块或方法(关键部分)。其他线程将等待释放锁以访问关键部分。|2359280|方法什么时候同步？|2359281|方法在将synchronized添加到方法定义或声明时是同步的。还可以将特定代码块与-in方法同步。|CODE|2359282|它在语法和逻辑上是什么意思？|2359283|这意味着只有一个线程可以通过获取锁来访问关键部分。除非此线程释放此锁，否则所有其他线程都必须等待才能获得锁。他们没有进入关键部分的权限，而没有外部获取锁。|2359284|这不能用魔法来完成。程序员有责任识别应用程序中的关键部分，并对其进行相应的保护。Java提供了一个框架来保护您的应用程序，但是要保护的所有部分的位置和内容是程序员的责任。|2359285|java文档页面的更多细节|2359286|内在锁与同步：|2359287|同步是围绕称为内部锁或监视器锁的内部实体构建的。内部锁在同步的两个方面都起着作用:强制对对象状态的独占访问，并在对可见性至关重要的关系之前建立。|2359288|每个对象都有一个与其相关联的内在锁。按照约定，需要对对象的字段进行独占和一致访问的线程必须在访问对象字段之前获取对象的内部锁，然后在访问对象字段时释放内部锁。|2359289|据说线程在获得锁和释放锁之间拥有内部锁。只要一个线程拥有一个内部锁，任何其他线程都无法获得相同的锁。另一个线程在尝试获取锁时会阻塞。|2359290|当线程释放内部锁时，在该操作与后续获取同一锁之间建立关系之前，就会发生这样的情况。|2359291|使方法同步有两个效果|2359292|首先，在同一个对象上对同步方法进行两次调用是不可能的。|2359293|当一个线程为一个对象执行同步方法时，调用同一对象块的同步方法的所有其他线程(挂起执行)，直到第一个线程与该对象一起完成为止。|2359294|第二，当同步方法退出时，它会自动建立一个发生--在与对同一对象的同步方法的任何后续调用之间的关系之前。|2359295|这保证了对对象状态的更改对所有线程都是可见的。|2359296|在以下方面寻找同步的其他替代方案：|2359297|避免在Java中同步(这个)？|2359298|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html|1|https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html|2|https://stackoverflow.com/questions/442564/avoid-synchronizedthis-in-java/36692190#36692190^0|0|1C|C|0|0|0|4|C|0|0|0|0|6|2|0|0|0|7|0|0|0|0|0|8|2|1|0|0|0|0|0|0|0|F|2|0^^$0|@$1|2|3|4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1Y|8|@$E|1Z|F|20|G|H]]|9|@]|A|$]]|$1|I|3|J|5|D|7|21|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|22|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|23|8|@$E|24|F|25|G|O]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|26|8|@]|9|@]|A|$]]|$1|R|3|S|5|D|7|27|8|@]|9|@]|A|$]]|$1|T|3|U|5|D|7|28|8|@]|9|@]|A|$]]|$1|V|3|W|5|D|7|29|8|@]|9|@$E|2A|F|2B|1|2C]]|A|$]]|$1|X|3|Y|5|D|7|2D|8|@$E|2E|F|2F|G|H]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2G|8|@]|9|@]|A|$]]|$1|11|3|12|5|D|7|2H|8|@]|9|@]|A|$]]|$1|13|3|14|5|D|7|2I|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|2J|8|@]|9|@]|A|$]]|$1|17|3|18|5|D|7|2K|8|@]|9|@$E|2L|F|2M|1|2N]]|A|$]]|$1|19|3|1A|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|D|7|2P|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|D|7|2R|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|D|7|2S|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|D|7|2T|8|@]|9|@$E|2U|F|2V|1|2W]]|A|$]]|$1|1L|3|-4|5|D|7|2X|8|@]|9|@]|A|$]]]|1M|$1N|$5|1O|1P|1Q|A|$1R|1S]]|1T|$5|1O|1P|1Q|A|$1R|1U]]|1V|$5|1O|1P|1Q|A|$1R|1W]]]]

<blockquote>
 What is the synchronized keyword?
</blockquote>

Threads communicate primarily by sharing access to fields and the objects reference fields refer to. This form of communication is extremely efficient, but makes two kinds of errors possible: thread interference and memory consistency errors. The tool needed to prevent these errors is synchronization. 

Synchronized blocks or methods prevents thread interference and make sure that data is consistent. At any point of time, only one thread can access a synchronized block or method (critical section) by acquiring a lock. Other thread(s) will wait for release of lock to access critical section. 

<blockquote>
 When are methods synchronized?
</blockquote>

Methods are synchronized when you add <code>synchronized</code> to method definition or declaration. You can also synchronize a particular block of code with-in a method. 

<blockquote>
 What does it mean pro grammatically and logically?
</blockquote>

It means that only one thread can access critical section by acquiring a lock. Unless this thread release this lock, all other thread(s) will have to wait to acquire a lock. They don't have access to enter critical section with out acquiring lock.

This can't be done with a magic. It's programmer responsibility to identify critical section(s) in application and guard it accordingly. Java provides a framework to guard your application, but where and what all sections to be guarded is the responsibility of programmer.

More details from java documentation <a href="https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html" rel="noreferrer">page</a>

Intrinsic Locks and Synchronization:

<blockquote>
 Synchronization is built around an internal entity known as the intrinsic lock or monitor lock. Intrinsic locks play a role in both aspects of synchronization: enforcing exclusive access to an object's state and establishing happens-before relationships that are essential to visibility.
</blockquote>

Every object has an intrinsic lock associated with it. By convention, a thread that needs exclusive and consistent access to an object's fields has to acquire the object's intrinsic lock before accessing them, and then release the intrinsic lock when it's done with them.

A thread is said to own the intrinsic lock between the time it has acquired the lock and released the lock. As long as a thread owns an intrinsic lock, no other thread can acquire the same lock. The other thread will block when it attempts to acquire the lock.

<blockquote>
 When a thread releases an intrinsic lock, a happens-before relationship is established between that action and any subsequent acquisition of the same lock. 
</blockquote>

Making methods synchronized has two <a href="https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html" rel="noreferrer">effects</a>:

<blockquote>
 First, it is not possible for two invocations of synchronized methods on the same object to interleave. 
</blockquote>

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.

<blockquote>
 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. 
</blockquote>

This guarantees that changes to the state of the object are visible to all threads.

Look for other alternatives to synchronization in :

<a href="https://stackoverflow.com/questions/442564/avoid-synchronizedthis-in-java/36692190#36692190">Avoid synchronized(this) in Java?</a>

blocks|key|947612|text|以下是Java教程的解释。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|947613|考虑以下代码：|947614|公共类SynchronizedCounter+{私有int+c=+0；公共同步空增量(){+c%2B%2B；}公共同步空洞递减(){c-；}公共同步int值(){返回c；}
如果count是SynchronizedCounter的一个实例，那么使这些方法同步有两种效果：|blockquote|style|CODE|947615|首先，在同一个对象上对同步方法进行两次调用是不可能的。当一个线程为一个对象执行同步方法时，调用同一对象块的同步方法的所有其他线程(挂起执行)，直到第一个线程与该对象一起完成为止。|unordered-list-item|947616|第二，当同步方法退出时，它会自动建立一个发生--在与对同一对象的同步方法的任何后续调用之间的关系之前。这保证了对对象状态的更改对所有线程都是可见的。|947617|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html^0|3|6|0|0|0|2D|5|2J|J|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|12|8|@$A|13|B|14|I|J]|$A|15|B|16|I|J]]|9|@]|C|$]]|$1|K|3|L|5|M|7|17|8|@]|9|@]|C|$]]|$1|N|3|O|5|M|7|18|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|Q|$R|$5|S|T|U|C|$V|W]]]]

Here is an explanation from <a href="https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html" rel="noreferrer">The Java Tutorials</a>.

Consider the following code:

<blockquote>
<pre><code>public class SynchronizedCounter {
 private int c = 0;

 public synchronized void increment() {
 c++;
 }

 public synchronized void decrement() {
 c--;
 }

 public synchronized int value() {
 return c;
 }
}
</code></pre>
 
 if <code>count</code> is an instance of <code>SynchronizedCounter</code>, then making these methods synchronized has two effects:
 
 <ul>
 <li>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.</li>
 <li>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.</li>
 </ul>
</blockquote>

blocks|key|833429|text|同步仅仅意味着如果在特定对象上使用同步块，则多个线程(如果与单个对象相关联)可以防止脏读和写入。为了让您更清晰，让我们举个例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|833430|class+MyRunnable+implements+Runnable+{
++++int+var+=+10;
++++@Override
++++public+void+run()+{
++++++++call();
++++}

++++public+void+call()+{
++++++++synchronized+(this)+{
++++++++++++for+(int+i+=+0;+i+<+4;+i%2B%2B)+{
++++++++++++++++var%2B%2B;
++++++++++++++++System.out.println("Current+Thread+"+%2B+Thread.currentThread().getName()+%2B+"+var+value+"%2Bvar);
++++++++++++}
++++++++}
++++}
}

public+class+MutlipleThreadsRunnable+{
++++public+static+void+main(String[]+args)+{
++++++++MyRunnable+runnable1+=+new+MyRunnable();
++++++++MyRunnable+runnable2+=+new+MyRunnable();
++++++++Thread+t1+=+new+Thread(runnable1);
++++++++t1.setName("Thread+-1");
++++++++Thread+t2+=+new+Thread(runnable2);
++++++++t2.setName("Thread+-2");
++++++++Thread+t3+=+new+Thread(runnable1);
++++++++t3.setName("Thread+-3");
++++++++t1.start();
++++++++t2.start();
++++++++t3.start();
++++}
}|code-block|syntax|javascript|833431|我们创建了两个MyRunnable类对象，runnable1与线程1共享，线程3共享&+runnable2仅与线程2共享。现在，当t1和t3在不使用同步的情况下启动时，PFB输出表明线程1和3同时影响var值，对于线程2，var有自己的内存。|833432|Without+Synchronized+keyword

++++Current+Thread+Thread+-1+var+value+11
++++Current+Thread+Thread+-2+var+value+11
++++Current+Thread+Thread+-2+var+value+12
++++Current+Thread+Thread+-2+var+value+13
++++Current+Thread+Thread+-2+var+value+14
++++Current+Thread+Thread+-1+var+value+12
++++Current+Thread+Thread+-3+var+value+13
++++Current+Thread+Thread+-3+var+value+15
++++Current+Thread+Thread+-1+var+value+14
++++Current+Thread+Thread+-1+var+value+17
++++Current+Thread+Thread+-3+var+value+16
++++Current+Thread+Thread+-3+var+value+18|833433|使用同步，线程3等待线程1在所有情况下完成。获得了两个锁，一个在线程1和线程3共享的runnable1上，另一个在仅由线程2共享的runnable2上。|833434|Current+Thread+Thread+-1+var+value+11
Current+Thread+Thread+-2+var+value+11
Current+Thread+Thread+-1+var+value+12
Current+Thread+Thread+-2+var+value+12
Current+Thread+Thread+-1+var+value+13
Current+Thread+Thread+-2+var+value+13
Current+Thread+Thread+-1+var+value+14
Current+Thread+Thread+-2+var+value+14
Current+Thread+Thread+-3+var+value+15
Current+Thread+Thread+-3+var+value+16
Current+Thread+Thread+-3+var+value+17
Current+Thread+Thread+-3+var+value+18|833435|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Synchronized simply means that multiple threads if associated with single object can prevent dirty read and write if synchronized block is used on particular object. To give you more clarity , lets take an example :

<pre><code>class MyRunnable implements Runnable {
 int var = 10;
 @Override
 public void run() {
 call();
 }

 public void call() {
 synchronized (this) {
 for (int i = 0; i &lt; 4; i++) {
 var++;
 System.out.println("Current Thread " + Thread.currentThread().getName() + " var value "+var);
 }
 }
 }
}

public class MutlipleThreadsRunnable {
 public static void main(String[] args) {
 MyRunnable runnable1 = new MyRunnable();
 MyRunnable runnable2 = new MyRunnable();
 Thread t1 = new Thread(runnable1);
 t1.setName("Thread -1");
 Thread t2 = new Thread(runnable2);
 t2.setName("Thread -2");
 Thread t3 = new Thread(runnable1);
 t3.setName("Thread -3");
 t1.start();
 t2.start();
 t3.start();
 }
}
</code></pre>

We've created two MyRunnable class objects , runnable1 being shared with thread 1 and thread 3 &amp; runnable2 being shared with thread 2 only.
Now when t1 and t3 starts without synchronized being used , PFB output which suggest that both threads 1 and 3 simultaneously affecting var value where for thread 2 , var has its own memory.

<pre><code>Without Synchronized keyword

 Current Thread Thread -1 var value 11
 Current Thread Thread -2 var value 11
 Current Thread Thread -2 var value 12
 Current Thread Thread -2 var value 13
 Current Thread Thread -2 var value 14
 Current Thread Thread -1 var value 12
 Current Thread Thread -3 var value 13
 Current Thread Thread -3 var value 15
 Current Thread Thread -1 var value 14
 Current Thread Thread -1 var value 17
 Current Thread Thread -3 var value 16
 Current Thread Thread -3 var value 18
</code></pre>

Using Synchronzied, thread 3 waiting for thread 1 to complete in all scenarios. There are two locks acquired , one on runnable1 shared by thread 1 and thread 3 and another on runnable2 shared by thread 2 only.

<pre><code>Current Thread Thread -1 var value 11
Current Thread Thread -2 var value 11
Current Thread Thread -1 var value 12
Current Thread Thread -2 var value 12
Current Thread Thread -1 var value 13
Current Thread Thread -2 var value 13
Current Thread Thread -1 var value 14
Current Thread Thread -2 var value 14
Current Thread Thread -3 var value 15
Current Thread Thread -3 var value 16
Current Thread Thread -3 var value 17
Current Thread Thread -3 var value 18
</code></pre>

blocks|key|833538|text|其他答案所缺少的是一个重要的方面:记忆障碍。线程同步主要由两个部分组成:序列化和可见性。我建议大家向google推荐"jvm内存障碍“，因为这是一个非常重要的重要话题(如果您修改由多个线程访问的共享数据)。完成了这些之后，我建议查看java.util.concurrent包的类，这些类有助于避免使用显式同步，这反过来有助于保持程序的简单和高效，甚至可能防止死锁。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|833539|ConcurrentLinkedDeque就是一个这样的例子。与指挥模式一起，它允许通过将命令填充到并发队列中来创建高效的工作线程--不需要显式同步，不可能死锁，不需要显式睡眠()，只需调用just+()就可以轮询队列。|offset|length|833540|简而言之：“内存同步”是在启动线程、线程结束、读取易失性变量、解锁监视器(保留同步块/函数)等情况下隐式发生的。这种“同步”会影响(在某种意义上说是“刷新”)该特定操作之前完成的所有写操作。在上述ConcurrentLinkedDeque的情况下，文档“说明”：|833541|内存一致性效应:与其他并发集合一样，在访问或从另一个线程中从ConcurrentLinkedDeque+发生-之前中删除该元素之后，在将对象放置到一个ConcurrentLinkedDeque操作之前，线程中的操作。|blockquote|833542|这种隐式行为在某种程度上是有害的，因为大多数没有丰富经验的Java程序员都会为此付出很大的代价。然后，在Java没有在有不同工作负载的生产中执行“应该”做的事情之后，突然在这个线程上绊倒了--并且很难测试并发性问题。|833543|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ConcurrentLinkedDeque.html|1|https://en.wikipedia.org/wiki/Command_pattern|2|3|https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html#MemoryVisibility^0|0|0|L|0|W|4|1|0|2Q|L|2|0|1G|5|3|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@$D|11|E|12|1|13]|$D|14|E|15|1|16]]|A|$]]|$1|F|3|G|5|6|7|17|8|@]|9|@$D|18|E|19|1|1A]]|A|$]]|$1|H|3|I|5|J|7|1B|8|@]|9|@$D|1C|E|1D|1|1E]]|A|$]]|$1|K|3|L|5|6|7|1F|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|P|Q|R|A|$S|V]]|W|$5|P|Q|R|A|$S|T]]|X|$5|P|Q|R|A|$S|Y]]]]

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.

One such example is <a href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ConcurrentLinkedDeque.html" rel="noreferrer">ConcurrentLinkedDeque</a>. Together with the <a href="https://en.wikipedia.org/wiki/Command_pattern" rel="noreferrer">command pattern</a> it allows to create highly efficient worker threads by stuffing the commands into the concurrent queue -- no explicit synchronization needed, no deadlocks possible, no explicit sleep() necessary, just poll the queue by calling take().

In short: "memory synchronization" happens implicitly when you start a thread, a thread ends, you read a volatile variable, you unlock a monitor (leave a synchronized block/function) etc. This "synchronization" affects (in a sense "flushes") all writes done before that particular action. In the case of the aforementioned <a href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ConcurrentLinkedDeque.html" rel="noreferrer">ConcurrentLinkedDeque</a>, the documentation "says":

<blockquote>
 Memory consistency effects: As with other concurrent collections,
 actions in a thread prior to placing an object into a
 ConcurrentLinkedDeque <a href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-summary.html#MemoryVisibility" rel="noreferrer">happen-before</a> actions subsequent to the access
 or removal of that element from the ConcurrentLinkedDeque in another
 thread.
</blockquote>

This implicit behavior is a somewhat pernicious aspect because most Java programmers without much experience will just take a lot as given because of it. And then suddenly stumble over this thread after Java isn't doing what it is "supposed" to do in production where there is a different work load -- and it's pretty hard to test concurrency issues.

blocks|key|833587|text|Synchronized+normal+method等效于Synchronized+statement+(使用此)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|833588|class+A+{
++++public+synchronized+void+methodA()+{
++++++++//+all+function+code
++++}

++++equivalent+to

++++public+void+methodA()+{
++++++++synchronized(this)+{
+++++++++++++//+all+function+code
++++++++}
++++}+
}|code-block|syntax|javascript|833589|Synchronized+static+method等价于Synchronized+statement+(use+)|833590|class+A+{
++++public+static+synchronized+void+methodA()+{
++++++++//+all+function+code
++++}

++++equivalent+to

++++public+void+methodA()+{
++++++++synchronized(A.class)+{
+++++++++++++//+all+function+code
++++++++}
++++}+
}|833591|同步语句(使用变量)|833592|class+A+{
++++private+Object+lock1+=+new+Object();

++++public+void+methodA()+{
++++++++synchronized(lock1+)+{
+++++++++++++//+all+function+code
++++++++}
++++}+
}|833593|对于synchronized，我们有Synchronized+Methods和Synchronized+Statements。然而，Synchronized+Methods类似于Synchronized+Statements，因此我们只需要了解Synchronized+Statements。|833594|=>基本上，我们将有|833595|synchronized(object+or+class)+{+//+object/class+use+to+provides+the+intrinsic+lock
+++//+code+
}|833596|以下是帮助理解synchronized的2种想法|833597|每个对象/类都有一个与其相关联的intrinsic+lock。|unordered-list-item|833598|当线程调用synchronized+statement时，它会自动获取该synchronized+statement's对象的intrinsic+lock，并在方法返回时释放它。只要线程拥有intrinsic+lock，其他线程就不能获得相同的锁=>线程安全。|BOLD|833599|=>当一个thread+A调用synchronized(this){//+code+1}+=>时，由于相同的锁，所有的块代码(在类中)都被锁定，其中有synchronized(this)和synchronized+normal+method+(在类中)。它将在thread+A解锁后执行("//代码1“完成)。|833600|这种行为类似于synchronized(a+variable){//+code+1}或synchronized(class)。|833601|相同锁+=>锁(不取决于哪种方法？或哪种陈述？)|833602|使用同步方法还是同步语句？|833603|我更喜欢synchronized+statements，因为它更可扩展。例如，在将来，您只需要同步一部分方法。例如，您有两个同步方法，而且没有任何与彼此相关的，但是当线程运行一个方法时，它会阻塞另一个方法(可以通过使用synchronized(a+variable)来防止)。|833604|但是，应用同步方法很简单，代码看起来也很简单。对于某些类，只有一个同步方法，或者类中的所有同步方法在相互关联的=>中，我们可以使用synchronized+method使代码更短、更容易理解。|833605|备注|833606|(它与synchronized没有多大关系，它是对象和类之间的区别，还是没有静态和静态的区别)。|833607|当您使用synchronized或普通方法或synchronized(this)或synchronized(non-static+variable)时，它将根据每个对象实例进行同步。|833608|当您使用synchronized或静态方法或synchronized(class)或synchronized(static+variable)时，它将基于类同步|833609|参考文献|833610|https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html+https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html|833611|希望能帮上忙|833612|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html|1|https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html^0|0|Q|T|M|0|0|0|Q|T|M|0|0|0|0|2|C|I|K|13|N|1U|K|2H|N|3E|N|0|0|0|7|C|0|G|E|0|5|M|10|O|1R|E|2N|E|32|2|3B|3|0|5|8|F|T|23|I|2M|Q|3M|8|1F|3|0|7|Z|17|J|0|0|3|0|0|4|N|31|O|1X|A|0|1T|J|0|0|3|C|0|4|C|M|I|15|X|0|4|C|M|J|16|T|0|0|0|23|0|24|23|1|0|0^^$0|@$1|2|3|4|5|6|7|26|8|@$9|27|A|28|B|C]|$9|29|A|2A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|2B|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|2C|8|@$9|2D|A|2E|B|C]|$9|2F|A|2G|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|2H|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|2I|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|2J|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|2K|8|@$9|2L|A|2M|B|C]|$9|2N|A|2O|B|C]|$9|2P|A|2Q|B|C]|$9|2R|A|2S|B|C]|$9|2T|A|2U|B|C]|$9|2V|A|2W|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|2X|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|2Y|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|2Z|8|@$9|30|A|31|B|C]]|D|@]|E|$]]|$1|10|3|11|5|12|7|32|8|@$9|33|A|34|B|C]]|D|@]|E|$]]|$1|13|3|14|5|12|7|35|8|@$9|36|A|37|B|C]|$9|38|A|39|B|C]|$9|3A|A|3B|B|C]|$9|3C|A|3D|B|C]|$9|3E|A|3F|B|15]|$9|3G|A|3H|B|15]]|D|@]|E|$]]|$1|16|3|17|5|6|7|3I|8|@$9|3J|A|3K|B|C]|$9|3L|A|3M|B|C]|$9|3N|A|3O|B|C]|$9|3P|A|3Q|B|C]|$9|3R|A|3S|B|C]|$9|3T|A|3U|B|15]]|D|@]|E|$]]|$1|18|3|19|5|6|7|3V|8|@$9|3W|A|3X|B|C]|$9|3Y|A|3Z|B|C]]|D|@]|E|$]]|$1|1A|3|1B|5|6|7|40|8|@$9|41|A|42|B|15]]|D|@]|E|$]]|$1|1C|3|1D|5|6|7|43|8|@]|D|@]|E|$]]|$1|1E|3|1F|5|6|7|44|8|@$9|45|A|46|B|C]|$9|47|A|48|B|C]|$9|49|A|4A|B|15]]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|4B|8|@$9|4C|A|4D|B|C]]|D|@]|E|$]]|$1|1I|3|1J|5|6|7|4E|8|@]|D|@]|E|$]]|$1|1K|3|1L|5|6|7|4F|8|@$9|4G|A|4H|B|C]]|D|@]|E|$]]|$1|1M|3|1N|5|12|7|4I|8|@$9|4J|A|4K|B|C]|$9|4L|A|4M|B|C]|$9|4N|A|4O|B|C]]|D|@]|E|$]]|$1|1O|3|1P|5|12|7|4P|8|@$9|4Q|A|4R|B|C]|$9|4S|A|4T|B|C]|$9|4U|A|4V|B|C]]|D|@]|E|$]]|$1|1Q|3|1R|5|6|7|4W|8|@]|D|@]|E|$]]|$1|1S|3|1T|5|6|7|4X|8|@]|D|@$9|4Y|A|4Z|1|50]|$9|51|A|52|1|53]]|E|$]]|$1|1U|3|1V|5|6|7|54|8|@]|D|@]|E|$]]|$1|1W|3|-4|5|6|7|55|8|@]|D|@]|E|$]]]|1X|$1Y|$5|1Z|20|21|E|$22|23]]|24|$5|1Z|20|21|E|$22|25]]]]

<code>Synchronized normal method</code> equivalent to
<code>Synchronized statement</code> (use this)

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

 equivalent to

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

<code>Synchronized static method</code> equivalent to <code>Synchronized statement</code> (use class)

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

 equivalent to

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

Synchronized statement (using variable)

<pre><code>class A {
 private Object lock1 = new Object();

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

For <code>synchronized</code>, we have both <code>Synchronized Methods</code> and <code>Synchronized Statements</code>. However, <code>Synchronized Methods</code> is similar to <code>Synchronized Statements</code> so we just need to understand <code>Synchronized Statements</code>.

=> Basically, we will have

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

Here is 2 think that help understanding <code>synchronized</code>

<ul>
<li>Every object/class have an <code>intrinsic lock</code> associated with it.</li>
<li>When a thread invokes a <code>synchronized statement</code>, it automatically acquires the <code>intrinsic lock</code> for that <code>synchronized statement's</code> object and releases it when the method returns. As long as a thread owns an <code>intrinsic lock</code>, NO other thread can acquire the SAME lock => thread safe.</li>
</ul>

=> 
When a <code>thread A</code> invokes <code>synchronized(this){// code 1}</code> => all the block code (inside class) where have <code>synchronized(this)</code> and all <code>synchronized normal method</code> (inside class) is locked because SAME lock. It will execute after <code>thread A</code> unlock ("// code 1" finished). 

This behavior is similar to <code>synchronized(a variable){// code 1}</code> or <code>synchronized(class)</code>. 

SAME LOCK => lock (not depend on which method? or which statements?)

<h3>Use synchronized method or synchronized statements?</h3>

I prefer <code>synchronized statements</code> because it is more extendable. Example, in future, you only need synchronized a part of method. Example, you have 2 synchronized method and it don't have any relevant to each other, however when a thread run a method, it will block the other method (it can prevent by use <code>synchronized(a variable)</code>). 

However, apply synchronized method is simple and the code look simple. For some class, there only 1 synchronized method, or all synchronized methods in the class in relevant to each other => we can use <code>synchronized method</code> to make code shorter and easy to understand

<h3>Note</h3>

(it not relevant to much to <code>synchronized</code>, it is the different between object and class or none-static and static). 

<ul>
<li>When you use <code>synchronized</code> or normal method or <code>synchronized(this)</code> or <code>synchronized(non-static variable)</code> it will synchronized base on each object instance. </li>
<li>When you use <code>synchronized</code> or static method or <code>synchronized(class)</code> or <code>synchronized(static variable)</code> it will synchronized base on class</li>
</ul>

<h3>Reference</h3>

<a href="https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html" rel="noreferrer">https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html</a>
<a href="https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html" rel="noreferrer">https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html</a>

Hope it help

blocks|key|833686|text|在java中，为了防止多个线程操纵共享变量，我们使用synchronized关键字。让我们通过以下示例了解它：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|833687|在这个例子中，我定义了两个线程，并将它们命名为增量和递减。增量线程将共享变量(counter)的值增加相同的数量，减少线程使其减少5000倍，即增加5000倍(导致5000+%2B0=+5000)和减少5000倍(导致5000+-5000=+0)。|833688|没有synchronized+关键字：的程序|BOLD|833689|class+SynchronizationDemo+{

++++public+static+void+main(String[]+args){

++++++++Buffer+buffer+=+new+Buffer();+++++++++++++++++++

++++++++MyThread+incThread+=+new+MyThread(buffer,+"increment");
++++++++MyThread+decThread+=+new+MyThread(buffer,+"decrement");+

++++++++incThread.start();
++++++++decThread.start();++
+++++++
++++++++try+{
++++++++++incThread.join();
++++++++++decThread.join();
++++++++}catch(InterruptedException+e){+}

++++++++System.out.println("Final+counter:+"%2Bbuffer.getCounter());
++++}
}

class+Buffer+{
++++private+int+counter+=+0;+
++++public+void+inc()+{+counter%2B%2B;+}
++++public+void+dec()+{+counter--;+}+
++++public+int+getCounter()+{+return+counter;+}
}

class+MyThread+extends+Thread+{

++++private+String+name;
++++private+Buffer+buffer;

++++public+MyThread+(Buffer+aBuffer,+String+aName)+{++++++++++++
++++++++buffer+=+aBuffer;+
++++++++name+=+aName;+
++++}

++++public+void+run(){
++++++++for+(int+i+=+0;+i+<=+5000;+i%2B%2B){
++++++++++++if+(name.equals("increment"))
++++++++++++++++buffer.inc();
++++++++++++else
++++++++++++++++buffer.dec();+++++++++++++++++++++++++++
++++++++}
++++}
}|code-block|syntax|javascript|833690|如果我们运行上面的程序，我们期望缓冲区的值是相同的，因为以相同的数量递增和减少缓冲区会导致初始值的增加，对吗？让我们看看输出：|833691|​|833692|📷|atomic|833693|833694|正如您所看到的，不管我们运行了多少次程序，我们得到的结果是不同的原因，因为每个线程同时操作counter。如果我们能够让一个线程首先增量共享变量，然后再减少它，或者相反，那么我们就可以通过在synchronized和dec方法的Buffer方法之前添加synchronized关键字，得到正确的结果，这正是使用Buffer关键字所能做的：|833695|带有synchronized+关键字：的程序|833696|//+rest+of+the+code

class+Buffer+{
++++private+int+counter+=+0;+
++++//+added+synchronized+keyword+to+let+only+one+thread
++++//+be+it+inc+or+dec+thread+to+manipulate+data+at+a+time
++++public+synchronized+void+inc()+{+counter%2B%2B;+}
++++public+synchronized+void+dec()+{+counter--;+}+
++++public+int+getCounter()+{+return+counter;+}
}

//+rest+of+the+code|833697|以及产出：|833698|833699|833700|833701|不管我们运行了多少次，输出结果都与0相同。|833702|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/84a6e03895e797e68187cbfd3ec3c128.jpg|imageAlt|1|https://developer.qcloudimg.com/http-save/yehe-900000/ee9de1ddf336207a099f52e36cfb42bc.jpg^0|Q|C|0|13|7|0|2|C|F|4|K|2|2|C|0|0|0|1R|0|0|1|0|0|1|0|1|0|0|0|1|0|0|4P|19|7|2N|C|30|3|36|6|3I|C|4B|6|0|0|E|F|7|2|C|0|0|9U|0|0|5|0|0|1|0|0|1|0|1|1|0|0|1|0|0|L|0^^$0|@$1|2|3|4|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1O|8|@$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1R|8|@$9|1S|A|1T|B|J]|$9|1U|A|1V|B|J]|$9|1W|A|1X|B|J]|$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|K|3|L|5|M|7|20|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|21|8|@$9|22|A|23|B|J]]|D|@]|E|$]]|$1|R|3|S|5|6|7|24|8|@$9|25|A|26|B|J]]|D|@]|E|$]]|$1|T|3|U|5|V|7|27|8|@$9|28|A|29|B|J]]|D|@$9|2A|A|2B|1|2C]]|E|$]]|$1|W|3|S|5|6|7|2D|8|@$9|2E|A|2F|B|J]]|D|@]|E|$]]|$1|X|3|Y|5|6|7|2G|8|@$9|2H|A|2I|B|J]|$9|2J|A|2K|B|C]|$9|2L|A|2M|B|C]|$9|2N|A|2O|B|C]|$9|2P|A|2Q|B|C]|$9|2R|A|2S|B|C]|$9|2T|A|2U|B|C]]|D|@]|E|$]]|$1|Z|3|10|5|6|7|2V|8|@$9|2W|A|2X|B|J]|$9|2Y|A|2Z|B|J]|$9|30|A|31|B|C]]|D|@]|E|$]]|$1|11|3|12|5|M|7|32|8|@$9|33|A|34|B|J]]|D|@]|E|$N|O]]|$1|13|3|14|5|6|7|35|8|@$9|36|A|37|B|J]]|D|@]|E|$]]|$1|15|3|S|5|6|7|38|8|@$9|39|A|3A|B|J]]|D|@]|E|$]]|$1|16|3|U|5|V|7|3B|8|@$9|3C|A|3D|B|J]]|D|@$9|3E|A|3F|1|3G]]|E|$]]|$1|17|3|S|5|6|7|3H|8|@$9|3I|A|3J|B|J]]|D|@]|E|$]]|$1|18|3|19|5|6|7|3K|8|@$9|3L|A|3M|B|J]]|D|@]|E|$]]|$1|1A|3|-4|5|6|7|3N|8|@]|D|@]|E|$]]]|1B|$1C|$5|1D|1E|1F|E|$1G|1H|1I|-4]]|1J|$5|1D|1E|1F|E|$1G|1K|1I|-4]]]]

In java to prevent multiple threads manipulating a shared variable we use <code>synchronized</code> keyword. Lets understand it with help of the following example:
In the example I have defined two threads and named them increment and decrement. Increment thread increases the value of shared variable (<code>counter</code>) by the same amount the decrement thread decreases it i.e 5000 times it is increased (which result in 5000 + 0 = 5000) and 5000 times we decrease (which result in 5000 - 5000 = 0).
Program without <code>synchronized</code> keyword:
<pre><code>class SynchronizationDemo {

 public static void main(String[] args){

 Buffer buffer = new Buffer(); 

 MyThread incThread = new MyThread(buffer, &quot;increment&quot;);
 MyThread decThread = new MyThread(buffer, &quot;decrement&quot;); 

 incThread.start();
 decThread.start(); 
 
 try {
 incThread.join();
 decThread.join();
 }catch(InterruptedException e){ }

 System.out.println(&quot;Final counter: &quot;+buffer.getCounter());
 }
}

class Buffer {
 private int counter = 0; 
 public void inc() { counter++; }
 public void dec() { counter--; } 
 public int getCounter() { return counter; }
}

class MyThread extends Thread {

 private String name;
 private Buffer buffer;

 public MyThread (Buffer aBuffer, String aName) { 
 buffer = aBuffer; 
 name = aName; 
 }

 public void run(){
 for (int i = 0; i &lt;= 5000; i++){
 if (name.equals(&quot;increment&quot;))
 buffer.inc();
 else
 buffer.dec(); 
 }
 }
}
</code></pre>
If we run the above program we expect value of buffer to be same since incrementing and decrementing the buffer by same amount would result in initial value we started with right ?. Lets see the output:
<a href="https://i.stack.imgur.com/upqWt.jpg" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/upqWt.jpg" alt="enter image description here" /></a>
As you can see no matter how many times we run the program we get a different result reason being each thread manipulated the <code>counter</code> at the same time. If we could manage to let the one thread to first increment the shared variable and then second to decrement it or vice versa we will then get the right result that is exactly what can be done with <code>synchronized</code> keyword by just adding <code>synchronized</code> keyword before the <code>inc</code> and <code>dec</code> methods of <code>Buffer</code> like this:
Program with <code>synchronized</code> keyword:
<pre><code>// rest of the code

class Buffer {
 private int counter = 0; 
 // added synchronized keyword to let only one thread
 // be it inc or dec thread to manipulate data at a time
 public synchronized void inc() { counter++; }
 public synchronized void dec() { counter--; } 
 public int getCounter() { return counter; }
}

// rest of the code
</code></pre>
and the output:
<a href="https://i.stack.imgur.com/o4CGa.jpg" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/o4CGa.jpg" alt="enter image description here" /></a>
no matter how many times we run it we get the same output as 0

I have some questions regarding the usage and significance of the <code>synchronized</code> keyword. 

<ul>
<li>What is the significance of the <code>synchronized</code> keyword?</li>
<li>When should methods be <code>synchronized</code>?</li>
<li>What does it mean programmatically and logically?</li>
</ul>

What does 'synchronized' mean?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

关于synchronized关键字的用法和意义，我有一些疑问。synchronized关键字的意义是什么？什么时候方法应该是synchronized从程序和逻辑上讲，这意味着什么？

问同步是什么意思？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问同步是什么意思？EN