java的语法：“同步（这）”(java syntax: “synchronized (this)”

可以请你给我解释一下这段java代码？我无法理解这样的语法。

synchronized (this) {
              try {
                  wait(endTime - System.currentTimeMillis());
              } catch (Exception e) {
              }
}

Answer 1:

这意味着，这个代码块被synchronized含义没有一个以上的线程将能够访问该块内的代码。

此外this意味着你可以在当前实例（获取当前实例锁）进行同步。

这是我在凯西Sierra的Java认证书找到。

由于不同步并发伤，你不希望同步任何代码比是必要的保护您的数据。 所以，如果一个方法的范围超过需要，您可以同步部分的范围缩小到东西不到一个完整的方法，只是一个块。

请看下面的代码片段：

public synchronized void doStuff() {
    System.out.println("synchronized");
}

这可以改变这一点：

public void doStuff() {
   //do some stuff for which you do not require synchronization
   synchronized(this) {
     System.out.println("synchronized");
     // perform stuff for which you require synchronization
   }
}

在第二片段中，同步锁仅被应用于代码块，而不是整个方法。

Answer 2:

synchronized (this)

是语法来实现块级同步。

这意味着，在this目的之用，只有一个线程可以在同一时间EXCUTE封闭块。

在这里寻找更详细的解答：块级同步

Answer 3:

synchronized (this) {
 }

其所谓的synchronized块，它可以选择它的同步哪些对象。一个同步方法只可以使用“这”（或相应的类实例为同步类方法）
看看这些链接可能是它会给你更好的答案。

Java的synchronized块
同步块VS同步的方法？

Answer 4:

同步（这） - 我们获得与对象相关联的锁指出，“本”。当我们使用这个块，我们的意思是，我们都愿意等到使用这种显示器的线，将其释放。这是有道理的使用锁，如果你改变了数据对象（该对象的变量）。

等待 - 使当前执行的线程等待，直到另一个线程调用notify方法或指定的时间。

Answer 5:

此第一线控制到代码的封闭块的并行访问。一次只能有一个线程可以同时执行的代码块。阅读的第2.2节本教程以获取更多信息

synchronized (this) {

下面所附的代码块似乎使用暂停执行的线程的给定时间量的（非常差）方法。

    try {
        wait(endTime - System.currentTimeMillis());
    } catch (Exception e) {
    }

另外它是“吞噬”可能在观望，这是非常确实调皮的过程中抛出的异常。

Answer 6:

在大多数情况下，只有一个线程可以在同一时间访问“同步（本）”。但是，这并不总是正确的！考虑下面的代码。在我的代码同步的静态对象作为锁，一切工作正常。当我改变的代码在（这）多个线程同时访问代码同步，它搅乱一切。上（这）仔细同步。注：该代码创建线程递归然后将它们显示顺序相反。

主要

public class Project2 
{
    public static void main(String[] args) throws InterruptedException 
    {
        Object lock = new Object();
        Threads2 t1 = new Threads2(1);
        t1.setName("Thread 1");
        t1.start();
        Threads2.que.add(t1);
        t1.join();
    } 
}

Threads2

public class Threads2 extends Thread
{
    //private final ArrayBlockingQueue<Threads> que = new ArrayBlockingQueue<>(5);
    public static ArrayList<Thread> que = new ArrayList<>(5);
    private volatile int i;
    private static volatile boolean locked = true;
    private static final Object lock = new Object();

    public Threads2(int i) 
    {        
        this.i = i;
    }
    @Override
    public void run()
    {   
        try
        {
            System.out.println("Thread " + i + ": created");       
            synchronized(lock)
            {
                i++;
            }       
            if(i <= 50)
            {
                Threads2 t = new Threads2(i);
                t.setName("Thread " + i);
                t.start();  
                que.add(Thread.currentThread());
            }
            else
            {
                Thread.currentThread().interrupt();
            }
            while(locked)
            {
                Thread.sleep(10000);
            }
        }
        catch(InterruptedException ex)
        {   
            synchronized(lock)
            {
                if(i >= 0)
                {
                    que.get(i-2).interrupt();
                    i--;
                    System.out.println(Thread.currentThread().getName());
                }    
            }       
        }       
    }    
}

文章来源: java syntax: “synchronized (this)”