35

你能解释一下这段java代码吗？我无法理解这种语法。

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

6 回答 6

52

这意味着这个代码块synchronized意味着只有一个线程能够访问该块内的代码。

也this意味着您可以在当前实例上同步（获得当前实例的锁定）。

这是我在 Kathy 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
   }
}

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

于 2012-11-07T07:05:56.150 回答
7 
synchronized (this)

是实现块级同步的语法。

这意味着仅在this对象上，并且一次只有一个线程可以执行封闭的块。

在此处查看更详细的答案：块级同步

于 2012-11-07T07:10:01.213 回答
1

第一行控制对封闭代码块的并发访问。一次只有一个线程可以执行代码块。阅读本教程的第 2.2 节了解更多信息

synchronized (this) {

下面封闭的代码块似乎使用了一种（非常糟糕的）方法来暂停执行线程一段给定的时间。

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

此外，它会“吞下”在等待过程中可能引发的任何异常，这确实很顽皮。

于 2012-11-07T07:16:34.187 回答
0 
synchronized (this) {
 }

它称为同步块，它可以选择在哪个对象上同步。同步方法只能使用'this'（或同步类方法的相应类实例）
看看这些链接可能会给你更好的答案。

  1. Java 同步块
  2. 同步块与同步方法？
于 2012-11-07T07:11:05.907 回答
0

synchronized(this) - 我们得到一个与指向“this”的对象关联的锁。当我们使用这个块时，我们的意思是我们愿意等到使用这个监视器的线程释放它。如果您更改数据对象（对象的变量），那么使用锁是有意义的。

wait - 导致当前正在执行的线程等待，直到另一个线程调用 notify 方法或指定的持续时间。

于 2012-11-07T07:12:31.340 回答
-2

在大多数情况下，一次只有一个线程可以访问“Synchronized(this)”。但这并不总是正确的！考虑下面的代码。在我的代码中，我将静态对象同步为锁，一切正常。当我更改代码以在（此）上同步时，多个线程同时访问代码并且它搞砸了一切。小心同步（this）。注意：代码递归地创建线程，然后以相反的顺序显示它们。

主要的

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();
    } 
}

线程2

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());
                }    
            }       
        }       
    }    
}
于 2018-01-17T22:09:19.480 回答