java中的同步功能是如何工作的？

Question

自从我开始用 Java 编程以来，我一直在想这个问题（大约一两年）。在C中，我们必须知道不同的方法才能正确避免线程之间的死锁，因此同步方法之间有更多的选择。

那么Java呢？当我们进行同步时，如何避免线程陷入死锁情况？它的内部是如何运作的？是否因为我们在比 C（或 C++）更高的级别上进行同步而避免了死锁？有没有关于java中的死锁和同步的文档？

Answer 1

在底层，它在字节码级别使用两个操作码 monitorenter 和 monitorexit，它们在 JVM 全局级别获取/释放对象引用上的锁。我强烈建议您阅读 Java虚拟机如何进行线程同步。

Answer 2

我们在多线程代码中遇到的主要问题是共享数据，我同意并发并行化进程的目的，并且“经常”发生在并行化处理期间线程需要访问以读取/写入共享数据。

java的synchronized关键字允许以下操作：

它告诉JVM在对象或同步代码片段的监视器上放置一个锁，这使其能够独占访问该部分代码或对象。

这是一个单例的例子：

public class Singleton {
    private Singleton INSTANCE;

    private Singleton() {
    }

    public Singleton getInstance() {
        if (null == INSTANCE) {
            INSTANCE = new Singleton();
        }
        return INSTANCE;
    }
}

这个单例不是线程安全，如果一个线程试图获取一个实例，而另一个线程也试图做同样的事情（竞争条件），那么可能会发生在此之前第一个线程完成了实例的创建，第二个线程已经可以访问 getInstance() 方法并创建了他自己的 Singleton 实例，这意味着在 T 时间内我们应该有两个实例Singleton（当时称为multiton）。

为了解决这个问题，我们必须同步单例的创建行为，这可以通过 INSTANCE 本身的 if 语句上方的关键字 synchronized 来完成：

public class Singleton {
    private Singleton INSTANCE;

    private Singleton() {
    }

    public Singleton getInstance() {
        synchronized (Singleton.class) {
            if (null == INSTANCE) {
                synchronized(Singleton.class) {
                   Singleton inst = new Singleton();
                   INSTANCE = inst;   
                }
            }
        }
        return INSTANCE;
    }
}

结果是第一个线程请求 Singleton 实例，并且在创建期间，JVM 将在实例的监视器上加锁，拒绝对实例的任何访问，直到线程 1 完成其请求。

也有不同的方法可以实现这一点，前面引用的书是一个很好的学习来源，javadoc也是。

Answer 3

Java 中的同步实际上并不比 C 中的容易多少。从语法上来看，它更容易，因为对于互斥体，您所需要做的就是将方法声明为同步或使用，

synchronized(someObject)
{
   someCode();
}

而在 C/C++ 中，您可以要使用操作系统特定的函数来使用互斥锁，或者您必须使用 Boost 库。

但关于死锁的陷阱与任何语言基本上都是相同的。

Answer 4

简短回答：

1. 同步方法和lock块使用监视器来锁定锁定对象的信号量在方法或块的持续时间内。

2. Java 语言本身并不能防止死锁。作为程序员，您需要确保以正确的顺序锁定/解锁对象以防止争用。

Answer 5

您还必须处理 Java 中的死锁。产生死锁的最简单方法是让一个线程在 A 上运行一个同步块，然后在 B 上运行另一个同步块，而另一个线程在 B 上执行一个同步块，然后在 A 上运行一个同步块

。阅读 有关并发的 Java 教程。 如果您想继续学习，请阅读Java 并发实践。

Answer 6

您是否尝试过 google（Java 死锁）？第一个结果是这样的： http://download.oracle.com/javase/ tutorial/essential/concurrency/deadlock.html

在这里您可以看到，使用synchronized死锁仍然会发生，因为同步的设计初衷并不是为了防止死锁。

Answer 7

我在上面看到了 Singleton 的一些问题。我认为这个类永远不会被创建。请考虑下面的代码。

public class Singleton {
     private static Singleton INSTANCE;
     private Singleton() {     }
     public static Singleton getInstance() {
         synchronized (Singleton.class) {
             if (null == INSTANCE) {
                 synchronized(Singleton.class) {
                    Singleton inst = new Singleton();
                    INSTANCE = inst;
                    }
             }
         }
         return INSTANCE;
     }
 }