1081

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

  • synchronized关键字的意义是什么？
  • 什么时候应该使用方法synchronized？
  • 它在程序上和逻辑上意味着什么？
4

17 回答 17

946

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

synchronized方法启用了一种防止线程干扰和内存一致性错误的简单策略：如果一个对象对多个线程可见，则对该对象变量的所有读取或写入都通过同步方法完成。

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

同样，这在 Java 中是一个重要的话题。要了解更多信息，请在此处探索关于 SO 和 Interwebs 的主题：

继续探索这些主题，直到“Brian Goetz”这个名字在你的大脑 中与“并发”一词永久相关。

于 2009-07-06T07:01:49.763 回答
324

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

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() 的调用。线程一次可以访问这个方法。无需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
于 2014-05-15T13:23:03.647 回答
121

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

使用非synchronized结构（如HashMap）时，您必须在代码中构建线程安全功能以防止出现一致性错误。

于 2011-01-22T18:39:44.853 回答
86

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

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

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

于 2011-01-22T18:39:33.963 回答
55

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

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

考虑一下：

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

即使所涉及的方法是同步的，因为它们是单独锁定和解锁的，两个不幸的定时线程可以创建一个包含两个元素的向量。

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

因为方法级同步 a) 在不需要时很昂贵，并且 b) 在需要同步时不够，所以现在有非同步的替换（在 Vector 的情况下为 ArrayList）。

最近，并发包已经发布，其中包含许多处理多线程问题的巧妙实用程序。

于 2009-07-06T07:09:33.447 回答
31

概述

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

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

更深的

从语法上讲，synchronized关键字将 aObject作为其参数（称为lock object），然后是 a { block of code }。

  • 当执行遇到这个关键字时，当前线程尝试“锁定/获取/拥有”（选择）锁定对象并在获得锁定后执行相关的代码块。

  • 保证对同步代码块内的变量的任何写入对于使用相同锁对象类似地执行同步代码块内的代码的每个其他线程都是可见的。

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

同步方法：

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

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

技术的

如果没有同步，则无法保证读取和写入的顺序，可能会给变量留下垃圾。
（例如，一个变量可能以一个线程写入的一半位和另一个线程写入的一半位结束，从而使变量处于两个线程都没有尝试写入的状态，而是两者的混合状态。）

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

结论

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

来源

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

于 2015-06-22T15:19:27.317 回答
22

把它想象成一种旋转栅门，就像你在足球场上发现的那样。想要进入的人是平行的，但在十字转门处，他们是“同步的”。一次只能有一个人通过。所有想要通过的人都会这样做，但他们可能必须等到他们可以通过。

于 2009-07-06T07:09:52.807 回答
16

什么是同步关键字？

线程主要通过共享对字段和对象引用字段的访问来进行通信。这种通信形式非常高效，但会导致两种错误：线程干扰和内存一致性错误。防止这些错误所需的工具是同步。

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

方法何时同步？

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

它在程序上和逻辑上是什么意思？

这意味着只有一个线程可以通过获取锁来访问临界区。除非该线程释放该锁，否则所有其他线程将不得不等待获取锁。他们没有获得锁就无法进入临界区。

这是魔法无法做到的。识别应用程序中的关键部分并相应地保护它是程序员的责任。Java 提供了一个框架来保护你的应用程序，但是所有部分要保护的位置和内容是程序员的责任。

来自 java 文档页面的更多详细信息

内在锁和同步：

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

每个对象都有一个与之关联的内在锁。按照惯例，需要对对象字段进行排他和一致访问的线程必须在访问对象之前获取对象的内在锁，然后在完成访问时释放内在锁。

在获得锁和释放锁之间，线程被称为拥有内在锁。只要一个线程拥有一个内在锁，其他线程就不能获得相同的锁。另一个线程在尝试获取锁时会阻塞。

当线程释放内在锁时，会在该操作和任何后续获取相同锁之间建立起之前的关系。

使方法同步有两个效果：

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

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

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

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

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

在 Java 中避免同步（this）？

于 2015-12-14T06:56:06.663 回答
13

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 Methods类似Synchronized Statements所以我们只需要了解Synchronized Statements。

=> 基本上，我们会有

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

这里有2个认为有助于理解synchronized

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

=> 当 athread A调用时synchronized(this){// code 1}=> 所有块代码（类内部），其中synchronized(this)所有synchronized normal method（类内部）都被锁定，因为SAME锁定。它将在thread A解锁后执行（“// code 1”完成）。

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

SAME LOCK => lock（不依赖于哪种方法？或哪些语句？）

使用同步方法或同步语句？

我更喜欢synchronized statements，因为它更具可扩展性。例如，以后只需要同步一部分方法。例如，您有 2 个同步方法，它们之间没有任何关联，但是当一个线程运行一个方法时，它会阻塞另一个方法（它可以通过 use 来阻止synchronized(a variable)）。

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

笔记

（它与 无关synchronized，它是对象和类或非静态和静态之间的区别）。

  • 当您使用synchronizedor 普通方法时， synchronized(this)orsynchronized(non-static variable)它将基于每个对象实例进行同步。
  • 当您使用synchronizedor 静态方法时，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

希望有帮助

于 2018-04-01T15:19:01.173 回答
11

这是来自The Java Tutorials的解释。

考虑以下代码：

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，那么使这些方法同步有两个效果：

  • 首先，同一对象上的同步方法的两次调用不可能交错。当一个线程正在为一个对象执行同步方法时，所有其他为同一对象调用同步方法的线程都会阻塞（暂停执行），直到第一个线程处理完该对象。
  • 其次，当同步方法退出时，它会自动与任何后续对同一对象的同步方法调用建立起之前的关系。这保证了对象状态的更改对所有线程都是可见的。
于 2016-08-01T22:03:49.063 回答
9

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

于 2009-07-06T07:01:35.973 回答
5

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

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

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

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

这种隐含的行为是一个有点有害的方面，因为大多数没有太多经验的 Java 程序员会因此而接受很多。然后在 Java 没有按照“应该”在生产环境中执行不同工作负载的情况下突然发现这个线程——而且很难测试并发问题。

于 2017-09-10T22:52:02.410 回答
3

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

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 完成。获得了两个锁，一个在 runnable1 上由线程 1 和线程 3 共享，另一个在 runnable2 上仅由线程 2 共享。

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
于 2017-06-08T18:41:15.670 回答
3

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

在示例中，我定义了两个线程并将它们命名为递增和递减。增量线程将共享变量 ( 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();
            else
                buffer.dec();                           
        }
    }
}

如果我们运行上面的程序，我们期望缓冲区的值是相同的，因为将缓冲区增加和减少相同的量会导致我们以正确的开始值？让我们看看输出：

在此处输入图像描述

正如您所看到的，无论我们运行程序多少次，我们都会得到不同的结果，原因是每个线程counter同时操作。如果我们可以设法让一个线程首先增加共享变量，然后再减少它，反之亦然，我们将获得正确的结果，这正是关键字可以通过在类似的方法之前synchronized添加关键字来完成的这：synchronizedincdecBuffer

带有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 相同的输出

于 2020-08-24T08:56:32.753 回答
1

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

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

Object.wait()
于 2013-05-19T08:11:45.900 回答
1

Java 同步

volatile[关于] =>synchronized

synchronizedJava 中的 block 是多线程中的监视器。synchronized具有相同对象/类的块只能由单个线程执行，所有其他线程都在等待。race condition当多个线程尝试更新同一个变量时，它可以提供帮助。

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

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

下一步是java.util.concurrent

于 2019-12-27T12:08:23.653 回答
-6

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

于 2014-06-19T09:05:26.420 回答