使用同步方法而不是同步块有什么优势吗?

使用同步块，您可以有多个同步器，因此多个同时但不冲突的事情可以同时进行。

唯一真正的区别是同步块可以选择在哪个对象上同步。同步方法只能使用'this'(或同步类方法的对应Class实例)。例如，它们在语义上是等价的:

synchronized void foo() {
...
}


void foo() {
synchronized (this) {
...
}
}

后者更灵活，因为它可以竞争任何对象的关联锁，通常是成员变量。它也更细粒度，因为您可以在块之前和块之后执行并发代码，但仍然在方法中。当然，您也可以通过将并发代码重构为单独的非同步方法来轻松地使用同步方法。使用任何使代码更容易理解的方法。

注意:静态同步方法和块工作在Class对象上。

public class MyClass {
// locks MyClass.class
public static synchronized void foo() {
// do something
}


// similar
public static void foo() {
synchronized(MyClass.class) {
// do something
}
}
}

主要的区别是，如果你使用同步块，你可以锁定一个对象，而不是这，这允许更灵活。

Object writeLock = new Object();

从现在开始，每当制作人想要添加一条新信息时，我们就会锁定它:

synchronized(writeLock){
// do something
}

因此，消费者可能仍会阅读，而生产者将被锁定。

谁能告诉我同步方法比同步块的优势与一个例子?谢谢。

与块相比，使用同步方法并没有明显的优势。

也许唯一的一个(但我不认为它是一个优势)是你不需要包括对象引用this。

方法:

public synchronized void method() { // blocks "this" from here....
...
...
...
} // to here

布洛克:

public void method() {
synchronized( this ) { // blocks "this" from here ....
....
....
....
}  // to here...
}

看到了吗?一点好处都没有。

块做比方法有优势，主要是灵活性，因为你可以使用另一个对象作为锁，而同步方法将锁定整个对象。

比较:

// locks the whole object
...
private synchronized void someInputRelatedWork() {
...
}
private synchronized void someOutputRelatedWork() {
...
}

vs。

// Using specific locks
Object inputLock = new Object();
Object outputLock = new Object();


private void someInputRelatedWork() {
synchronized(inputLock) {
...
}
}
private void someOutputRelatedWork() {
synchronized(outputLock) {
...
}
}

另外，如果方法增长了，你仍然可以保持同步段的分离:

 private void method() {
... code here
... code here
... code here
synchronized( lock ) {
... very few lines of code here
}
... code here
... code here
... code here
... code here
}

大多数情况下，我使用它来同步对列表或映射的访问，但我不想阻止对对象的所有方法的访问。

在下面的代码中，修改列表的线程不会阻塞等待正在修改映射的线程。如果方法在对象上是同步的，那么每个方法都必须等待，即使它们所做的修改不会冲突。

private List<Foo> myList = new ArrayList<Foo>();
private Map<String,Bar) myMap = new HashMap<String,Bar>();


public void put( String s, Bar b ) {
synchronized( myMap ) {
myMap.put( s,b );
// then some thing that may take a while like a database access or RPC or notifying listeners
}
}


public void hasKey( String s, ) {
synchronized( myMap ) {
myMap.hasKey( s );
}
}


public void add( Foo f ) {
synchronized( myList ) {
myList.add( f );
// then some thing that may take a while like a database access or RPC or notifying listeners
}
}


public Thing getMedianFoo() {
Foo med = null;
synchronized( myList ) {
Collections.sort(myList);
med = myList.get(myList.size()/2);
}
return med;
}

同步的方法

优点:

• 您的IDE可以指示同步方法。
• 语法更加紧凑。
• 强制将同步块分割为单独的方法。

缺点:

• 与此同步，因此外部人员也可以与之同步。
• 将代码移到同步块之外更加困难。

同步块

优点:

• 允许为锁使用私有变量，从而将锁强制留在类内部。
• 同步块可以通过搜索变量的引用来找到。

缺点:

• 语法更复杂，因此使代码更难阅读。

就我个人而言，我更喜欢使用同步方法，类只关注需要同步的东西。这样的类应该尽可能小，所以应该很容易检查同步。其他人不需要关心同步。

一般来说，除了显式显示对象的监视器和隐式this对象之外，这些基本是相同的。同步方法的一个缺点，我认为有时被忽视的是，在使用“this”引用进行同步时，你会打开外部对象锁定同一对象的可能性。如果你遇到了，这可能是一个非常微妙的错误。在内部显式Object或其他现有字段上同步可以避免这个问题，完全封装了同步。

Synchronized方法用于锁定所有对象 Synchronized块用于锁定特定对象

同步的方法

同步方法有两个作用 首先，当一个线程正在为一个对象执行同步方法时，所有为同一对象调用同步方法的其他线程将阻塞(暂停执行)，直到第一个线程处理完该对象。< / p >

其次，当同步方法退出时，它自动与同一对象的同步方法的任何后续调用建立happens-before关系。这保证了对对象状态的更改对于所有线程都是可见的。

注意，构造函数不能同步——在构造函数中使用synchronized关键字是一个语法错误。同步构造函数没有意义，因为只有创建对象的线程才能在构造对象时访问它。

同步语句

与同步方法不同，同步语句必须指定提供内在锁的对象:大多数情况下，我使用它来同步对列表或映射的访问，但我不想阻塞对对象的所有方法的访问。

Q:内在锁和同步 同步是围绕一个称为内在锁或监视器锁的内部实体构建的。(API规范通常将此实体简单地称为“监视器”)内在锁在同步的两个方面都发挥作用:强制独占访问对象的状态，并建立对可见性至关重要的happens-before关系。< / p >

每个对象都有一个与之相关的内在锁。按照惯例，需要独占和一致访问对象字段的线程必须在访问对象字段之前获得对象的内在锁，然后在使用完对象字段时释放内在锁。线程在获得锁和释放锁之间拥有内在锁。只要一个线程拥有一个内在锁，其他线程就不能获得相同的锁。另一个线程在试图获取锁时将阻塞。

package test;


public class SynchTest implements Runnable {
private int c = 0;


public static void main(String[] args) {
new SynchTest().test();
}


public void test() {
// Create the object with the run() method
Runnable runnable = new SynchTest();
Runnable runnable2 = new SynchTest();
// Create the thread supplying it with the runnable object
Thread thread = new Thread(runnable,"thread-1");
Thread thread2 = new Thread(runnable,"thread-2");
//      Here the key point is passing same object, if you pass runnable2 for thread2,
//      then its not applicable for synchronization test and that wont give expected
//      output Synchronization method means "it is not possible for two invocations
//      of synchronized methods on the same object to interleave"


// Start the thread
thread.start();
thread2.start();
}


public synchronized  void increment() {
System.out.println("Begin thread " + Thread.currentThread().getName());
System.out.println(this.hashCode() + "Value of C = " + c);
//      If we uncomment this for synchronized block, then the result would be different
//      synchronized(this) {
for (int i = 0; i < 9999999; i++) {
c += i;
}
//      }
System.out.println("End thread " + Thread.currentThread().getName());
}


//    public synchronized void decrement() {
//        System.out.println("Decrement " + Thread.currentThread().getName());
//    }


public int value() {
return c;
}


@Override
public void run() {
this.increment();
}
}

用同步方法，块和不同步交叉检查不同的输出。

同步方法可以使用反射API进行检查。这对于测试一些合约很有用，比如模型中的所有方法都是同步的。

下面的代码段打印哈希表的所有同步方法:

for (Method m : Hashtable.class.getMethods()) {
if (Modifier.isSynchronized(m.getModifiers())) {
System.out.println(m);
}
}

同步线程。 1)永远不要在线程中使用synchronized(this)，它不起作用。与(this)同步使用当前线程作为锁定线程对象。由于每个线程都独立于其他线程，因此不存在同步协调。 2)代码测试表明，在Mac上的Java 1.6中，方法同步不起作用。 3) synchronized(lockObj)，其中lockObj是所有线程同步的公共共享对象。 4) ReenterantLock.lock()和.unlock()工作。

import java.util.*;


/** RaceCondition - Shows that when multiple threads compete for resources
thread one may grab the resource expecting to update a particular
area but is removed from the CPU before finishing.  Thread one still
points to that resource.  Then thread two grabs that resource and
completes the update.  Then thread one gets to complete the update,
which over writes thread two's work.
DEMO:  1) Run as is - see missing counts from race condition, Run severa times, values change
2) Uncomment "synchronized(countLock){ }" - see counts work
Synchronized creates a lock on that block of code, no other threads can
execute code within a block that another thread has a lock.
3) Comment ArrayList, unComment Vector - See no loss in collection
Vectors work like ArrayList, but Vectors are "Thread Safe"
May use this code as long as attribution to the author remains intact.
/mf
*/


public class RaceCondition {
private ArrayList<Integer> raceList = new ArrayList<Integer>(); // simple add(#)
//  private Vector<Integer> raceList = new Vector<Integer>(); // simple add(#)


private String countLock="lock";    // Object use for locking the raceCount
private int raceCount = 0;        // simple add 1 to this counter
private int MAX = 10000;        // Do this 10,000 times
private int NUM_THREADS = 100;    // Create 100 threads


public static void main(String [] args) {
new RaceCondition();
}


public RaceCondition() {
ArrayList<Thread> arT = new ArrayList<Thread>();


// Create thread objects, add them to an array list
for( int i=0; i<NUM_THREADS; i++){
Thread rt = new RaceThread( ); // i );
arT.add( rt );
}


// Start all object at once.
for( Thread rt : arT ){
rt.start();
}


// Wait for all threads to finish before we can print totals created by threads
for( int i=0; i<NUM_THREADS; i++){
try { arT.get(i).join(); }
catch( InterruptedException ie ) { System.out.println("Interrupted thread "+i); }
}


// All threads finished, print the summary information.
// (Try to print this informaiton without the join loop above)
System.out.printf("\nRace condition, should have %,d. Really have %,d in array, and count of %,d.\n",
MAX*NUM_THREADS, raceList.size(), raceCount );
System.out.printf("Array lost %,d. Count lost %,d\n",
MAX*NUM_THREADS-raceList.size(), MAX*NUM_THREADS-raceCount );
}   // end RaceCondition constructor






class RaceThread extends Thread {
public void run() {
for ( int i=0; i<MAX; i++){
try {
update( i );
}    // These  catches show when one thread steps on another's values
catch( ArrayIndexOutOfBoundsException ai ){ System.out.print("A"); }
catch( OutOfMemoryError oome ) { System.out.print("O"); }
}
}


// so we don't lose counts, need to synchronize on some object, not primitive
// Created "countLock" to show how this can work.
// Comment out the synchronized and ending {, see that we lose counts.


//    public synchronized void update(int i){   // use A
public void update(int i){                  // remove this when adding A
//      synchronized(countLock){            // or B
//      synchronized(this){             // or C
raceCount = raceCount + 1;
raceList.add( i );      // use Vector
//          }           // end block for B or C
}   // end update


}   // end RaceThread inner class




} // end RaceCondition outter class

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

关于使用同步块的重要提示:小心你使用的锁对象!

您需要注意的不仅仅是String对象。装箱的原语也是一种危险，因为autoboxing和valueOf方法可以重用相同的对象，这取决于值。

更多信息见: https://www.securecoding.cert.org/confluence/display/java/LCK01-J.+Do+not+synchronize+on+objects+that+may+be+reused < / p >