“同步”是什么意思？ 意思是？

Question

我对 synchronized 关键字的用法和意义有一些疑问。

• synchronized 关键字有何意义？
• 方法何时应该同步？
• 从程序上和逻辑上来说这意味着什么？

Answer 1

synchronized 关键字是关于不同的线程读取和写入相同的变量、对象和资源。 这在 Java 中不是一个简单的话题，但这里引用了 Sun 的一句话：

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

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

再说一次，这在 Java 中是一个不平凡的话题。 要了解更多信息，请探索 SO 和 Interwebs 上的主题：

• 并发
• Java 内存模型

继续探索这些主题，直到名称​​“Brian Goetz” 在你的大脑中永久地与术语“并发”联系在一起。

Answer 2

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

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 static class TheDemo {
        public synchronized void test(String name) {
            for (int i = 0; i < 10; i++) {
                System.out.println(name + " :: " + i);
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    System.out.println(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() 的调用。 线程一次只能访问此方法。 如果没有synchronized，所有线程都可以同时访问此方法。

当线程调用对象的同步方法“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

Answer 3

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

当使用非同步构造（例如HashMap）时，您必须在代码中构建线程安全功能以防止一致性错误。

Answer 4

synchronized 表示在多线程环境中，具有 synchronized 方法/块的对象不允许两个线程访问 synchronized代码> 同时代码的方法/块。 这意味着一个线程在另一个线程更新它时无法读取它。

第二个线程将等待，直到第一个线程完成其执行。 开销是速度，但优点是保证数据的一致性。

如果您的应用程序是单线程的，则synchronized 块不会提供任何好处。

Answer 5

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

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

考虑一下：

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

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

因此，实际上，您还必须在应用程序代码中进行同步。

因为方法级同步 a) 当您不需要同步时成本高昂，b) 当您需要同步时不足，因此现在有非同步的替代方案（在 Vector 的情况下为 ArrayList）。

最近，并发包已经发布，其中有许多巧妙的实用程序可以解决多线程问题。

Answer 6

概述

Java 中的 Synchronized 关键字与线程安全有关，即多个线程读取或写入同一个变量时。
这可以直接发生（通过访问相同的变量）或间接发生（通过使用一个类，该类使用另一个访问相同变量的类）。

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

更深入的

语法方面，synchronized 关键字采用一个 Object 作为参数（称为锁定对象），然后后面跟着一个 {代码块}。

• 当执行过程中遇到此关键字时，当前线程会尝试“锁定/获取/拥有”（随意选择）锁定对象，并在获取锁定后执行关联的代码块。

• 使用相同锁对象类似地在同步代码块内执行代码的每个其他线程都是可见的。

• 一次只有一个线程可以持有锁，在此期间所有其他尝试获取同一锁对象的线程都将等待（暂停执行）。 当执行退出同步代码块时，锁将被释放。

同步方法：

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

- 实例方法是没有 static 关键字的方法。
- 类方法是具有 static 关键字的方法。

技术

如果没有同步，则无法保证读取和写入发生的顺序，可能会导致变量留下垃圾。< br>
（例如，一个变量可能最终有一半的位由一个线程写入，一半的位由另一个线程写入，使该变量处于两个线程都未尝试写入的状态，但混合在一起的混乱两者。）

在另一个线程读取之前（挂钟时间）在线程中完成写入操作是不够的，因为硬件可能已经缓存了变量的值，并且读取线程将看到缓存的值值而不是写入的内容。

结论

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

来源

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

Answer 7

可以把它想象成一种十字转门，就像你在足球场上看到的那样。 有平行的人流想要进去，但在十字转门处他们是“同步”的。 一次只有一个人可以通过。 所有想要通过的人都可以，但他们可能必须等到他们能够通过为止。

Answer 8

1. 什么是synchronized关键字？

同步块或方法可以防止线程干扰并确保数据一致。 在任何时间点，只有一个线程可以通过获取锁来访问同步块或方法（临界区）。 其他线程将等待锁释放才能访问关键部分。

2. 方法何时同步？

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

3. 从编程和逻辑上讲这是什么意思？

这意味着只有一个线程可以通过获取锁来访问临界区。 除非该线程释放该锁，否则所有其他线程都必须等待获取锁。 如果不获取锁，他们就无法进入关键部分。

程序员有责任识别应用程序中的关键部分并相应地对其进行保护。 Java提供了一个框架来保护你的应用程序，但是保护哪些部分是程序员的责任。

使方法同步有两个效果：

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

其次，当同步方法退出时，它会自动与同一对象的同步方法的任何后续调用建立发生之前关系。

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

在以下位置寻找同步的其他替代方法：

避免在 Java 中同步(this)?

Answer 9

同步普通方法相当于
Synchronized 语句（使用此）

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

    equivalent to

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

Synchronized 静态方法 等价于 Synchronized 语句（使用类）

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

    equivalent to

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

Synchronized 语句（使用变量）

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

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

For synchronized< /code>，我们有同步方法和同步语句。 不过，同步方法与同步语句类似，因此我们只需要了解同步语句即可。

=> 基本上，我们认为

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

这 2 点有助于理解synchronized

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

=>
当线程A调用synchronized(this){//代码1} =>; 所有具有 synchronized(this) 的块代码（在类内部）和所有同步普通方法（在类内部）都被锁定，因为 SAME 锁。 它将在线程 A 解锁后执行（“// code 1”完成）。

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

相同的锁 => 锁（不依赖哪个方法？或者哪个语句？）

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

我更喜欢同步语句，因为它更具可扩展性。 例如，将来您只需要同步方法的一部分。 例如，您有 2 个同步方法，并且它们彼此没有任何相关，但是当线程运行一个方法时，它将阻塞另一个方法（它可以通过使用 synchronized 来阻止（变量））。

不过，apply Synchronized方法很简单，代码看起来也很简单。 对于某个类，只有1个同步方法，或者该类中的所有同步方法彼此相关=> 我们可以使用synchronized方法使代码更短且易于理解

注意

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

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

参考

进行同步https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html
https://docs.oracle.com/javase/tutorial/essential/concurrency /locksync.html

希望有帮助

Answer 10

以下是来自Java 教程的解释。

考虑以下代码：

公共类 SynchronizedCounter { 
      私有 int c = 0; 

      公共同步无效增量（）{ 
          c++； 
      } 

      公共同步无效减量（）{ 
          C - ; 
      } 

      公共同步 int value() { 
          返回c； 
      } 
  } 
  

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

• 首先，同一对象上的同步方法的两次调用不可能交错。 当一个线程正在执行某个对象的同步方法时，所有其他为同一对象调用同步方法的线程都会阻塞（挂起执行），直到第一个线程处理完该对象为止。
• 其次，当同步方法退出时，它会自动与同一对象的同步方法的任何后续调用建立发生之前关系。 这保证了对象状态的更改对所有线程都可见。

Answer 11

据我了解，同步基本上意味着编译器在您的方法周围编写一个monitor.enter和monitor.exit。 因此，它可能是线程安全的，具体取决于它的使用方式（我的意思是，您可以使用同步方法编写一个对象，但该对象不是线程安全的，具体取决于您的类的用途）。

Answer 12

其他答案缺少的是一个重要方面：内存屏障。 线程同步基本上由两个部分组成：序列化和可见性。 我建议大家去谷歌搜索“jvm内存屏障”，因为这是一个不平凡且极其重要的主题（如果您修改多个线程访问的共享数据）。 完成此操作后，我建议查看 java.util.concurrent 包的类，它们有助于避免使用显式同步，这反过来又有助于保持程序简单高效，甚至可能防止死锁。

其中一个示例是 ConcurrentLinkedDeque。 与命令模式一起，它允许通过将命令填充到并发队列中来创建高效的工作线程-- 不需要显式同步，不会出现死锁，不需要显式 sleep()，只需通过调用 take() 轮询队列即可。

简而言之：当您启动线程、线程结束、读取易失性变量、解锁监视器（留下同步块/函数）等时，“内存同步”会隐式发生。这种“同步”影响（在某种意义上“刷新”）所有在该特定操作之前完成的写入。 对于上述 ConcurrentLinkedDeque ，文档“说”：

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

这种隐式行为是一个有点有害的方面，因为大多数没有太多经验的 Java 程序员只会因此而采取很多既定的做法。 然后，在 Java 没有执行它在生产环境中“应该”执行的操作（其中存在不同的工作负载）之后，突然遇到了这个线程，而且测试并发问题非常困难。

Answer 13

同步仅仅意味着如果在特定对象上使用同步块，则与单个对象关联的多个线程可以防止脏读和脏写。 为了让您更清楚，让我们举个例子：

class MyRunnable implements Runnable {
    int var = 10;
    @Override
    public 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();
    }
}

我们创建了两个 MyRunnable 类对象，runnable1 与线程 1 和线程 3 共享。 runnable2 仅与线程 2 共享。
现在，当 t1 和 t3 在没有使用同步的情况下启动时，PFB 输出表明线程 1 和 3 同时影响 var 值，其中对于线程 2 来说，var 有自己的内存。

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

使用 Synchronzied，线程 3 在所有情况下都会等待线程 1 完成。 获取了两个锁，一个在由线程 1 和线程 3 共享的 runnable1 上，另一个在仅由线程 2 共享的 runnable2 上。

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

Answer 14

在java中为了防止多个线程操作共享变量，我们使用synchronized关键字。 让我们借助以下示例来理解它：

在示例中，我定义了两个线程并将它们命名为增量和减量。 增量线程增加共享变量（counter）的值，增量与减量线程减少的量相同，即增加 5000 倍（结果为 5000 + 0 = 5000），减少 5000 倍（结果为 5000 + 0 = 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();
            else
                buffer.dec();                           
        }
    }
}

如果我们运行上述程序，我们期望缓冲区的值相同，因为以相同的量递增和递减缓冲区将导致我们开始时的初始值正确的 ？。 让我们看看输出：

正如您所看到的，无论我们运行程序多少次，我们都会得到不同的结果，原因是每个线程同时操作计数器。 如果我们能够设法让一个线程首先递增共享变量，然后第二次递减它，反之亦然，那么我们将获得正确的结果，这正是使用 synchronized 关键字可以完成的结果在 Buffer 的 inc 和 dec 方法之前添加 synchronized 关键字，如下所示：

Program with 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 time
    public synchronized void inc() { counter++; }
    public synchronized void dec() { counter--; } 
    public int getCounter() { return counter; }
}

// rest of the code

和输出：

无论我们运行多少次，我们都会得到与 0 相同的输出

Answer 15

Java同步

易失性^[关于] => Java中的synchronized

synchronized块是多线程中的监视器。 具有相同对象/类的同步块只能由单个线程执行，所有其他线程都在等待。 它可以帮助解决竞争条件^[关于]情况。

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

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

下一步是java.util.concurrent

Answer 16

同步简单意味着没有两个线程可以同时访问块/方法。 当我们说类的任何块/方法是同步的时，这意味着一次只有一个线程可以访问它们。 在内部，尝试访问它的线程首先会对该对象加锁，只要该锁不可用，其他线程就无法访问该类实例的任何同步方法/块。

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

Object.wait()

Answer 17

“synchronized”关键字是为了实现线程安全。 它将同步块或方法的访问限制为一次只能有一个线程，有效地防止多线程程序中的数据不一致。

何时使用方法同步

在处理数据结构等共享资源时，方法同步就变得很有必要。 它可以防止数据损坏，特别是在一次只能运行一个线程的关键部分。 对于用于多线程使用的类来说，维护线程安全也至关重要。

理解编程和逻辑含义

从编程的角度来看，Java 的同步确保只有一个线程可以通过获取和释放锁来访问同步代码。 从逻辑上讲，它在多线程环境中强制执行数据一致性和完整性。

Answer 18

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