带有等待/通知且没有它们的同步块之间的区别？

Question

如果我只是使用synchronized，而不是wait/notify方法，它会保持线程安全吗？

有什么区别？

Thx提前。

Answer 1

使用​​使一个方法/块一次只能在线程上访问。所以，是的，它是线程安全的。

这两个概念是结合在一起的，而不是相互排斥的。当您使用wait()时，您需要拥有该对象上的显示器。所以你在这之前需要有synchronized(..)。使用.wait()使当前线程停止，直到另一个线程在其等待的对象上调用.notify()。这是​​的补充，它只确保只有一个线程将进入块/方法。

Answer 2

有效的Java项目69：“考虑使用等待的难度和 通知正确的，你应该使用更高级别的并发性工具，而不是”。

尽可能避免使用wait（）和notify（）：使用​​或其他来自java.util.concurrent的实用程序。

Answer 3

因此，在面试中遇到困难之后，我决定再次查找并理解第10亿次。

同步块使代码线程安全。毫无疑问。当wait（）和notify（）或notifyAll（）进来时，就是你试图编写更高效代码的地方。例如，如果你有一个多线程共享的项目列表，那么如果你把它放在一个监视器的同步块中，那么线程线程将不断跳转，并在上下文切换过程中来回运行代码。 。甚至有一个空的列表！

因此wait（）在监视器（synchronized（..）中的对象）上用作一种机制来告诉所有线程冷静并停止使用cpu周期，直到进一步通知或notifyAll（）为止。

所以像：

synchronized(monitor) { 

    if(list.isEmpty()) 
     monitor.wait(); 
} 


...somewhere else... 

synchronized(monitor){ 

    list.add(stuff); 
    monitor.notifyAll(); 

} 

Answer 4

同步块被使用，如果“相同的对象”的2个线程试图accquire锁。由于对象类持有锁，它知道该给谁。然而，如果2个对象（obj1的t1 & t2和obj2的t3 & t4）的2个线程（比如t2和t4）尝试获取该锁，obj1将不知道obj2的锁，并且obj2将不知道obj1的锁。因此使用等待和通知方法。

如：

//example of java synchronized method 
class Table{ 
synchronized void printTable(int n){//synchronized method 
    for(int i=1;i<=5;i++){ 
    System.out.println(n*i); 
    try{ 
     Thread.sleep(400); 
    }catch(Exception e){System.out.println(e);} 
    } 

} 
} 

class MyThread1 extends Thread{ 
Table t; 
MyThread1(Table t){ 
this.t=t; 
} 
public void run(){ 
t.printTable(5); 
} 

} 
class MyThread2 extends Thread{ 
Table t; 
MyThread2(Table t){ 
this.t=t; 
} 
public void run(){ 
t.printTable(100); 
} 
} 

public class TestSynchronization2{ 
public static void main(String args[]){ 
Table obj = new Table();//only one object 
MyThread1 t1=new MyThread1(obj); 
MyThread2 t2=new MyThread2(obj); 
t1.start(); 
t2.start(); 
} 
} 

两个线程T1和T2属于同一个对象，因此同步工作在这里很好。 然而，

class Table{ 
synchronized void printTable(int n){//synchronized method 
    for(int i=1;i<=5;i++){ 
    System.out.println(n*i); 
    try{ 
     Thread.sleep(400); 
    }catch(Exception e){System.out.println(e);} 
    } 

} 
} 

class MyThread1 extends Thread{ 
Table t; 
MyThread1(Table t){ 
this.t=t; 
} 
public void run(){ 
t.printTable(5); 
} 

} 
class MyThread2 extends Thread{ 
Table t; 
MyThread2(Table t){ 
this.t=t; 
} 
public void run(){ 
t.printTable(100); 
} 
} 

public class TestSynchronization2{ 
public static void main(String args[]){ 
Table obj = new Table(); 
Table obj1 = new Table(); 
MyThread1 t1=new MyThread1(obj); 
MyThread2 t2=new MyThread2(obj1); 
t1.start(); 
t2.start(); 
} 
} 

当你运行上面的程序，同步不会因为每个线程的工作属于不同的对象，因此，你应该使用wait和notify这里。

Answer 5

等待/通知是需要等待一些条件（例如，用户输入）INSIDE一个同步块。

典型用途：

synchronized(obj) { 
    // do something 

    while(some condition is not met) { 
     obj.wait(); 
    } 
    // do something other 
} 

让我们假设你不使用的等待（）。然后，您必须实现繁忙循环轮询所需的条件，这对性能不利。

synchronized(obj) { 
    // do something 

    while(some condition is not met) { // busy loop } 

    // do something other 
} 

重要提示：即使一个线程被唤醒通知（）或notifyAll的（）其他线程，觉醒的线程做不保证立即恢复执行。如果有其他线程在等待在同一个对象上执行同步块，那么唤醒线程应该与线程竞争。

Answer 6

制作方法synchronized有两个作用：

首先，它是不可能的同一对象来交织上同步方法的两个调用。当一个线程正在执行的对象同步方法，来调用同步对于相同的对象块（暂停执行）的方法，直到第一线程中的所有其他线程与对象

其次，当同步方法退出完成，它会自动建立与同一对象的任何后续同步方法调用之间的前后关系。这保证了对所有线程都可见的对象状态的更改。

同步帮助您保护关键代码。

如果你想多线程之间建立通信，则必须使用wait()和notify()/notifyAll()

wait()：造成当前线程等待，直到其他线程调用notify（）方法或notifyAll（）方法为这个对象。

notify()：唤醒正在等待该对象监视器的单个线程。如果任何线程正在等待这个对象，则选择其中一个线程来唤醒。

notifyAll()：唤醒在该对象监视器上等待的所有线程。线程通过调用其中一个等待方法来等待对象的监视器。

使用wait（）和notify（）的简单用例：生产者和消费者问题。

消费者线程必须等到生产者线程产生数据。 wait（）和notify（）在上面的场景中很有用。在一段时间内，引入了更好的替代方案。请参阅此high level concurrency教程页面。

简单来说：

使用​​守卫保护您的数据的关键部分，并保护您的代码。

使用wait()和notify()以及同步如果你想以安全的方式建立多个线程之间的通信，它们是相互依赖的。

相关SE问题：

What does 'synchronized' mean?

A simple scenario using wait() and notify() in java