什么'同步'的意思吗?

synchronized关键字是什么?

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

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

方法何时同步?

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

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

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

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

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

内在锁和同步:

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

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

线程在获得锁和释放锁之间拥有内在锁。当另一个线程试图获取锁时，它将阻塞。

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

使方法同步有两个影响:

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

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

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

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

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

在Java中避免同步(这)?< / >

下面是第0条的解释。

考虑下面的代码:

public class SynchronizedCounter {private int c = 0;
public synchronized void increment() {c++;}
public synchronized void decrement() {c--;}
public synchronized int value() {return c;}}

如果count是SynchronizedCounter的实例，那么使这些方法同步有两个效果:

• 首先，对同一对象的同步方法的两次调用不可能交织。当一个线程正在为一个对象执行同步方法时，所有为同一对象调用同步方法的其他线程将暂停执行，直到第一个线程处理完该对象。
• 其次，当同步方法退出时，它自动与同一对象的同步方法的任何后续调用建立happens-before关系。这保证了对对象状态的更改对于所有线程都是可见的。

Synchronized的意思是，如果在特定对象上使用Synchronized块，那么与单个对象关联的多个线程可以防止脏读写。为了让你更清楚，让我们举个例子:

class MyRunnable implements Runnable {int var = 10;@Overridepublic void run() {call();}
public void call() {synchronized (this) {for (int i = 0; i < 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();}}

Without Synchronized keyword
Current Thread Thread -1 var value 11Current Thread Thread -2 var value 11Current Thread Thread -2 var value 12Current Thread Thread -2 var value 13Current Thread Thread -2 var value 14Current Thread Thread -1 var value 12Current Thread Thread -3 var value 13Current Thread Thread -3 var value 15Current Thread Thread -1 var value 14Current Thread Thread -1 var value 17Current Thread Thread -3 var value 16Current Thread Thread -3 var value 18

使用Synchronzied，线程3在所有场景中等待线程1完成。有两个锁，一个在runnable1上，由线程1和线程3共享，另一个在runnable2上，仅由线程2共享。

Current Thread Thread -1 var value 11Current Thread Thread -2 var value 11Current Thread Thread -1 var value 12Current Thread Thread -2 var value 12Current Thread Thread -1 var value 13Current Thread Thread -2 var value 13Current Thread Thread -1 var value 14Current Thread Thread -2 var value 14Current Thread Thread -3 var value 15Current Thread Thread -3 var value 16Current Thread Thread -3 var value 17Current Thread Thread -3 var value 18

其他答案都忽略了一个重要的方面:记忆障碍。线程同步基本上由两个部分组成:序列化和可见性。我建议大家使用谷歌的“jvm内存屏障”，因为这是一个非常重要的主题(如果您修改由多个线程访问的共享数据)。完成这些之后，我建议查看java.util.concurrent包的类，这些类有助于避免使用显式同步，这反过来有助于保持程序简单高效，甚至可能防止死锁。

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

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

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

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

Synchronized normal method等效于Synchronized statement(使用这个)

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

Synchronized static method相当于Synchronized statement(使用类)

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，我们有Synchronized Methods和Synchronized Statements。然而，第一条和第二条很相似，所以我们只需要理解第二条。

基本上，我们会有

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

以下两点有助于理解第0条

• 每个对象/类都有一个与之相关的intrinsic lock。
• 当线程调用synchronized statement时，它会自动为synchronized statement's对象获取intrinsic lock，并在方法返回时释放它。只要线程拥有intrinsic lock，没有其他的线程就可以获得相同 lock =>线程安全。

这种行为类似于synchronized(a variable){// code 1}或synchronized(class)。

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

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

我更喜欢synchronized statements，因为它的可扩展性更强。例如，在将来，你只需要同步方法的一部分。例如，你有两个同步的方法和它没有了彼此相关，但是当一个线程运行一个方法时，它会阻塞另一个方法(它可以通过使用synchronized(a variable)来防止)。

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

请注意

(它与synchronized没有太大关系，它是对象和类或非静态和静态之间的区别)。

• 当你使用synchronized或普通方法或synchronized(this)或synchronized(non-static variable)时，它将基于每个对象实例进行同步。
• 当你使用synchronized或静态方法或synchronized(class)或synchronized(static variable)时，它将基于类进行同步

参考

https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html# 0 < / p >

希望能有所帮助

Java同步

# 0 # 2 =比;# 1

synchronized块在Java中是多线程中的监视器。同一个对象/类的synchronized块只能由单个线程执行，其他的都在等待。当几个线程试图更新同一个变量时，它可以帮助解决race condition的情况。

Java 5通过支持happens-before<一口>[对]< /一口>扩展了synchronized

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

下一步是java.util.concurrent

在java中，为了防止多个线程操纵一个共享变量，我们使用synchronized关键字。让我们通过下面的例子来理解它:

在这个例子中，我定义了两个线程，并将它们命名为increment和decincrement。增量线程增加共享变量(counter)的值与递减线程减少共享变量(counter)的值相同，即增加5000次(结果是5000 + 0 = 5000)，减少5000次(结果是5000 - 5000 = 0)。

没有synchronized关键字的程序:

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: "+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 <= 5000; i++){if (name.equals("increment"))buffer.inc();elsebuffer.dec();}}}

如果我们运行上面的程序，我们期望缓冲区的值是相同的，因为缓冲区的增量和减量相同，将会得到我们开始时的初始值，对吗?让我们看看输出:

正如你所看到的，无论我们运行这个程序多少次，我们都会得到不同的结果，因为每个线程同时操作了counter。如果我们能设法让一个线程先增加共享变量，然后再减少它，反之亦然，我们就会得到正确的结果，这正是synchronized关键字所能做到的，只需在Buffer的inc和dec方法之前添加synchronized关键字，如下所示:

关键字为synchronized的程序:

// 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 timepublic synchronized void inc() { counter++; }public synchronized void dec() { counter--; }public int getCounter() { return counter; }}
// rest of the code

输出:

不管我们运行多少次，我们得到的输出都是0