这里已经说过，同步块可以使用用户定义的变量作为锁对象，当同步函数只使用“this”时。当然，你也可以对函数中需要同步的部分进行操作。

但是每个人都说synchronized函数和block之间没有区别，block覆盖了使用“this”作为锁对象的整个函数。这是不对的，不同的是字节码，将在这两种情况下产生。在同步块使用的情况下，应该分配本地变量，其中包含引用“this”。因此，我们会得到一个更大的函数(如果你只有几个函数，这就无关紧要了)。

你可以在这里找到更详细的解释: http://www.artima.com/insidejvm/ed2/threadsynchP.html

同步块的使用也不好，原因如下:

synchronized关键字在一个方面非常有限:当退出一个同步块时，所有等待该锁的线程都必须被解除阻塞，但只有其中一个线程可以获得锁;所有其他人都看到锁已被占用，并返回阻塞状态。这不仅仅是浪费了大量的处理周期:为解除线程阻塞而进行的上下文切换通常还涉及从磁盘调出内存，这是非常非常昂贵的。

关于这方面的更多细节，我建议你阅读这篇文章: http://java.dzone.com/articles/synchronized-considered

这要视情况而定。 如果只有一个或多个共享实体。

在这里查看完整的工作示例

简单介绍一下。

线程和可共享实体 多个线程可以访问同一个实体，例如多个connectionThreads共享一个messageQueue。由于线程并发运行，可能会有一个数据被另一个覆盖的机会，这可能是一个混乱的情况。 因此，我们需要某种方法来确保可共享实体一次只能被一个线程访问。(并发)。

同步块 Synchronized()块是一种确保可共享实体并发访问的方法。 首先，打个小比方 假设有两个人P1, P2(线程)一个盥洗室(可共享实体)，有一扇门(锁)。 现在我们想让一个人一次使用脸盆。 一种方法是在P1锁门的时候P2等待P1完成他的工作 P1打开门 那么只有p1可以使用脸盆。

语法。

synchronized(this)
{
  SHARED_ENTITY.....
}

"this" provided the intrinsic lock associated with the class (Java developer designed Object class in such a way that each object can work as monitor). Above approach works fine when there are only one shared entity and multiple threads (1: N). N shareable entities-M threads Now think of a situation when there is two washbasin inside a washroom and only one door. If we are using the previous approach, only p1 can use one washbasin at a time while p2 will wait outside. It is wastage of resource as no one is using B2 (washbasin). A wiser approach would be to create a smaller room inside washroom and provide them one door per washbasin. In this way, P1 can access B1 and P2 can access B2 and vice-versa.

washbasin1;  
washbasin2;

Object lock1=new Object();
Object lock2=new Object();

  synchronized(lock1)
  {
    washbasin1;
  }

  synchronized(lock2)
  {
    washbasin2;
  }

在这里查看更多关于Threads---->的信息

不，你不应该总是这样。但是，当一个特定对象上有多个关注点时，我倾向于避免它，而这些关注点只需要对它们本身是线程安全的。例如，你可能有一个可变数据对象，它有“label”和“parent”字段;它们需要是线程安全的，但是改变其中一个不需要阻止另一个被写入/读取。(在实践中，我将通过声明字段为volatile和/或使用java.util来避免这种情况。concurrent的AtomicFoo包装器)。

一般来说，同步有点笨拙，因为它只是一个大的锁定，而不是仔细考虑如何允许线程相互工作。使用synchronized(this)更加笨拙和反社会，因为它表示“当我持有锁时，没有人可以更改这个类的任何内容”。你需要多久做一次?

I would much rather have more granular locks; even if you do want to stop everything from changing (perhaps you're serialising the object), you can just acquire all of the locks to achieve the same thing, plus it's more explicit that way. When you use synchronized(this), it's not clear exactly why you're synchronizing, or what the side effects might be. If you use synchronized(labelMonitor), or even better labelLock.getWriteLock().lock(), it's clear what you are doing and what the effects of your critical section are limited to.

concurrent包极大地降低了线程安全代码的复杂性。我只有一些轶事证据，但我所见过的大多数synchronized(x)工作似乎都是重新实现Lock、Semaphore或Latch，但使用的是较低级别的监视器。

考虑到这一点，使用这些机制中的任何一种进行同步都类似于对内部对象进行同步，而不是泄露锁。这是非常有益的，因为您可以绝对确定通过两个或多个线程控制进入监视器的条目。

首先需要指出的是:

public void blah() {
  synchronized (this) {
    // do stuff
  }
}

语义上等价于:

public synchronized void blah() {
  // do stuff
}

这是不使用synchronized(this)的一个原因。您可能会说，您可以围绕synchronized(this)块做一些事情。通常的原因是试图避免必须进行同步检查，这将导致各种并发问题，特别是双重检查锁定问题，这表明要使一个相对简单的检查具有线程安全性是多么困难。

私有锁是一种防御机制，这从来都不是一个坏主意。

另外，正如您所提到的，私有锁可以控制粒度。一个对象上的一组操作可能与另一组完全无关，但同步(这)将相互排除对所有这些操作的访问。

同步(这个)真的不能给你任何东西。

我认为第一点(其他人使用您的锁)和第二点(所有方法不必要地使用相同的锁)可能发生在任何相当大的应用程序中。特别是当开发人员之间没有良好的沟通时。

这不是一成不变的，这主要是一个良好的实践和防止错误的问题。