使用同步方法而不是同步块有优势吗？

Question

谁能用一个例子告诉我同步方法相对于同步块的优点？

Answer 1

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

Answer 2

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

Answer 3

正如这里已经说过的，当同步函数仅使用“this”时，同步块可以使用用户定义的变量作为锁定对象。 当然，您可以操纵应该同步的函数区域。
但每个人都说同步函数和使用“this”作为锁定对象覆盖整个函数的块之间没有区别。 事实并非如此，差异在于两种情况下都会生成的字节码。 在使用同步块的情况下，应分配保存对“this”的引用的局部变量。 因此，我们的函数大小会稍大一些（如果函数数量很少，则不相关）。

您可以在此处找到有关差异的更详细说明：
http://www.artima.com/insidejvm/ed2/threadsynchP.html

Answer 4

在同步方法的情况下，将在对象上获取锁。 但是，如果您使用同步块，您可以选择指定将获取锁的对象。

例子 ：

    Class Example {
    String test = "abc";
    // lock will be acquired on String  test object.
    synchronized (test) {
        // do something
    }

   lock will be acquired on Example Object
   public synchronized void testMethod() {
     // do some thing
   } 

   }

Answer 5

我知道这是一个老问题，但通过快速阅读这里的回复，我并没有看到有人提到有时同步方法可能是错误锁。
来自 Java 并发实践（第 72 页）：

public class ListHelper<E> {
  public List<E> list = Collections.syncrhonizedList(new ArrayList<>());
...

public syncrhonized boolean putIfAbsent(E x) {
 boolean absent = !list.contains(x);
if(absent) {
 list.add(x);
}
return absent;
}

上面的代码表面上是线程安全的。 然而，事实上并非如此。 在这种情况下，锁是在类的实例上获得的。 但是，列表可能会被不使用该方法的另一个线程修改。 正确的方法是使用

public boolean putIfAbsent(E x) {
 synchronized(list) {
  boolean absent = !list.contains(x);
  if(absent) {
    list.add(x);
  }
  return absent;
}
}

上面的代码将阻止所有线程尝试修改列表修改列表，直到同步块完成。

Answer 6

实际上，同步方法相对于同步块的优点是它们更不易被白痴使用。 因为您无法选择要锁定的任意对象，所以您不能滥用同步方法语法来执行愚蠢的操作，例如锁定字符串文字或锁定从线程下更改的可变字段的内容。

另一方面，使用同步方法，您无法保护锁不被任何可以获得对象引用的线程获取。

因此，使用synchronized作为方法的修饰符可以更好地保护你的牛人免受伤害，而将synchronized块与私有最终锁定对象结合使用可以更好地保护你自己的代码免受牛人的伤害。

Answer 7

来自 Java 规范摘要：
http://www.cs.cornell.edu/andru/javaspec/ 17.doc.html

synchronized 语句（第 14.17 节）计算对对象的引用；
然后它尝试对该对象执行锁定操作，但不会
继续操作，直到锁定操作成功完成。 ...

同步方法（第 8.4.3.5 节）自动执行锁定操作
当它被调用时； 它的主体在锁定操作完成之前不会被执行
成功完成。 如果该方法是实例方法，则
锁定与调用它的实例关联的锁
（也就是说，在执行期间将被称为 this 的对象
方法的主体）。 如果方法是静态的，它会锁定
与代表该类的 Class 对象关联的锁
该方法被定义。 ...

基于这些描述，我想说以前的大多数答案都是正确的，并且同步方法可能对于静态方法特别有用，否则您必须弄清楚如何获取“代表其中类的类对象”该方法已被定义。”

编辑：我最初认为这些是实际 Java 规范的引用。 澄清此页面只是规范的摘要/解释

Answer 8

TLDR; 既不要使用 synchronized 修饰符，也不要使用 synchronized(this){...} 表达式，而是使用 synchronized(myLock){。 ..} 其中 myLock 是保存私有对象的最终实例字段。

---

在方法声明上使用 synchronized 修饰符与在方法主体中使用 synchronized(..){ } 表达式之间的区别如下：

• synchronized 方法签名上指定的修饰符
  1. 在生成的 JavaDoc 中可见，
  2. 在测试反射以编程方式确定="https://docs.oracle.com/javase/7/docs/api/java/lang/reflect/Modifier.html#SYNCHRONIZED" rel="nofollow noreferrer">Modifier.SYNCHRONIZED，
  3. 与 synchronized(this) { .... } 相比，需要更少的打字和缩进，并且
  4. （取决于您的 IDE）在类大纲和代码完成中可见，
  5. 在非静态方法上声明时，使用 this 对象作为锁；在静态方法上声明时，使用封闭类作为锁。
• synchronized(...){...} 表达式允许您
  1. 仅同步方法主体部分的执行，
  2. 在构造函数或 (static) 初始化块，
  3. 选择控制同步访问的锁对象。

但是，使用 synchronized 修饰符或 synchronized(...) {...} 以及 this 作为锁定对象（如 >synchronized(this) {...})，也有同样的缺点。 两者都使用它自己的实例作为要同步的锁对象。 这是危险的，因为不仅对象本身，任何持有该对象引用的其他外部对象/代码也可以将其用作同步锁，从而带来潜在的严重副作用（性能下降和死锁）。

因此，最佳实践是既不要使用 synchronized 修饰符，也不将 synchronized(...) 表达式与 this 结合使用作为锁对象，而是使用锁该对象私有的对象。 例如：

public class MyService {
    private final lock = new Object();

    public void doThis() {
       synchronized(lock) {
          // do code that requires synchronous execution
        }
    }

    public void doThat() {
       synchronized(lock) {
          // do code that requires synchronous execution
        }
    }
}

您还可以使用多个锁对象，但需要特别注意以确保嵌套使用时不会导致死锁。

public class MyService {
    private final lock1 = new Object();
    private final lock2 = new Object();

    public void doThis() {
       synchronized(lock1) {
          synchronized(lock2) {
              // code here is guaranteed not to be executes at the same time
              // as the synchronized code in doThat() and doMore().
          }
    }

    public void doThat() {
       synchronized(lock1) {
              // code here is guaranteed not to be executes at the same time
              // as the synchronized code in doThis().
              // doMore() may execute concurrently
        }
    }

    public void doMore() {
       synchronized(lock2) {
              // code here is guaranteed not to be executes at the same time
              // as the synchronized code in doThis().
              // doThat() may execute concurrently
        }
    }
}

Answer 9

我想这个问题是关于线程安全单例和使用双重检查锁定的延迟初始化之间的区别。 当我需要实现一些特定的单例时，我总是参考这篇文章。

嗯，这是一个线程安全单例：

// Java program to create Thread Safe 
// Singleton class 
public class GFG  
{ 
  // private instance, so that it can be 
  // accessed by only by getInstance() method 
  private static GFG instance; 

  private GFG()  
  { 
    // private constructor 
  } 

 //synchronized method to control simultaneous access 
  synchronized public static GFG getInstance()  
  { 
    if (instance == null)  
    { 
      // if instance is null, initialize 
      instance = new GFG(); 
    } 
    return instance; 
  } 
} 

优点：

1. 可以进行延迟初始化。

2. 它是线程安全的。

缺点：

1. getInstance() 方法是同步的，因此会导致性能下降，因为多个线程无法同时访问它。

这是一个带有双重检查锁定的延迟初始化：

// Java code to explain double check locking 
public class GFG  
{ 
  // private instance, so that it can be 
  // accessed by only by getInstance() method 
  private static GFG instance; 

  private GFG()  
  { 
    // private constructor 
  } 

  public static GFG getInstance() 
  { 
    if (instance == null)  
    { 
      //synchronized block to remove overhead 
      synchronized (GFG.class) 
      { 
        if(instance==null) 
        { 
          // if instance is null, initialize 
          instance = new GFG(); 
        } 

      } 
    } 
    return instance; 
  } 
} 

优点：

1. 可以进行延迟初始化。

2. 它也是线程安全的。

3. 克服了由于synchronized关键字导致的性能下降。

缺点：

1. 第一次，它会影响性能。

2. 作为缺点。 双重检查锁定方法是可以忍受的，所以它可以
   用于高性能多线程应用程序。

请参阅这篇文章了解更多详细信息：

https://www. geeksforgeeks.org/java-singleton-design-pattern-practices-examples/

Answer 10

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

以下代码显示了这些要点。 它还包含线程安全的 Vector，它将替代 ArrayList，以表明添加到 Vector 的许多线程不会丢失任何信息，而使用 ArrayList 则可能会丢失信息。
0) 当前代码显示由于竞争条件导致信息丢失
A）注释当前标记的A行，并取消注释上面的A行，然后运行，方法会丢失数据，但它不应该丢失。
B) 反转步骤 A，取消注释 B 和 // 结束块 }。 然后运行查看结果没有数据丢失
C) 注释掉 B，取消注释 C。运行，请参阅同步（此）丢失数据，正如预期的那样。
没有时间完成所有变体，希望这会有所帮助。
如果同步（此）或方法同步有效，请说明您测试的 Java 和操作系统版本。 谢谢。

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

Answer 11

谁能用一个例子告诉我同步方法相对于同步块的优点？ 谢谢。

使用同步方法相对于块并没有明显的优势。

也许唯一的一个（但我不会称其为优点）是您不需要包含对象引用 this。

方法：

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

块：

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

看到了吗？ 一点优势都没有。

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

比较：

// 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
}

Answer 12

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

synchronized void foo() {
  ...
}

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

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

Answer 13

同步方法的

优点：

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

缺点：

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

同步块

优点：

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

缺点：

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

---

就我个人而言，我更喜欢将同步方法与仅关注需要同步的事物的类一起使用。 这样的类应该尽可能小，这样应该很容易检查同步。 其他人不需要关心同步。

Answer 14

主要区别在于，如果您使用同步块，您可以锁定除 this 之外的对象，这样可以更加灵活。

假设您有一个消息队列和多个消息生产者和消费者。 我们不希望生产者相互干扰，但消费者应该能够检索消息而不必等待生产者。
因此，我们只需创建一个对象

Object writeLock = new Object();

，从现在开始，每当生产者想要添加新消息时，我们只需锁定它：

synchronized(writeLock){
  // do something
}

因此消费者仍然可以读取，而生产者将被锁定。

Answer 15

同步方法

同步方法有两个作用。
首先，当一个线程正在执行对象的同步方法时，调用同一对象的同步方法的所有其他线程都会阻塞（挂起执行），直到第一个线程完成该对象。

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

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

同步语句

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

问：本质锁和同步
同步是围绕称为内在锁或监视器锁的内部实体构建的。 （API 规范通常将此实体简单地称为“监视器”。）内在锁在同步的两个方面都发挥着作用：强制对对象状态进行独占访问并建立对可见性至关重要的发生前关系。

每个对象都有一个与其关联的内在锁。 按照惯例，需要对对象字段进行独占和一致访问的线程必须在访问对象字段之前获取对象的内在锁，然后在访问完这些字段后释放内在锁。 线程在获取锁和释放锁之间被称为拥有固有锁。 只要一个线程拥有固有锁，其他线程就无法获取相同的锁。 当另一个线程尝试获取锁时，它将被阻塞。

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

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

Answer 16

注意：静态同步方法和块作用于 Class 对象。

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

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

Answer 17

当java编译器将源代码转换为字节代码时，它对同步方法和同步块的处理方式非常不同。

当JVM执行synchronized方法时，执行线程识别出该方法的method_info结构设置了ACC_SYNCHRONIZED标志，然后它自动获取该对象的锁，调用该方法，并释放该锁。 如果发生异常，线程会自动释放锁。

另一方面，同步方法块绕过了 JVM 对获取对象锁和异常处理的内置支持，并要求以字节代码显式编写该功能。 如果您阅读带有同步块的方法的字节代码，您将看到十多个附加操作来管理此功能。

这显示了生成同步方法和同步块的调用：

public class SynchronizationExample {
    private int i;

    public synchronized int synchronizedMethodGet() {
        return i;
    }

    public int synchronizedBlockGet() {
        synchronized( this ) {
            return i;
        }
    }
}

synchronizedMethodGet() 方法生成以下字节代码：

0:  aload_0
1:  getfield
2:  nop
3:  iconst_m1
4:  ireturn

以下是来自 synchronizedBlockGet() 方法的字节代码：

0:  aload_0
1:  dup
2:  astore_1
3:  monitorenter
4:  aload_0
5:  getfield
6:  nop
7:  iconst_m1
8:  aload_1
9:  monitorexit
10: ireturn
11: astore_2
12: aload_1
13: monitorexit
14: aload_2
15: athrow

---

同步方法和块之间的一个显着区别是，同步块通常会缩小锁的范围。 由于锁定范围与性能成反比，因此仅锁定代码的关键部分总是更好。 使用同步块的最佳示例之一是单例模式中的双重检查锁定 我们只锁定用于创建 Singleton 实例的关键代码部分，而不是锁定整个 getInstance() 方法。 这极大地提高了性能，因为只需要锁定一两次。

使用同步方法时，如果混合使用静态同步方法和非静态同步方法，则需要格外小心。

Answer 18

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

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

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

Answer 19

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

Answer 20

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

以下代码片段打印了 Hashtable 的所有同步方法：

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

Answer 21

使用同步块的重要注意事项：小心使用锁对象！

上面 user2277816 的代码片段说明了这一点，因为对字符串文字的引用被用作锁定对象。
意识到字符串文字在 Java 中是自动驻留的，您应该开始看到问题：在文字“锁”上同步的每一段代码都共享同一个锁！ 这很容易导致完全不相关的代码片段出现死锁。

您需要小心的不仅仅是 String 对象。 装箱基元也是一种危险，因为自动装箱和 valueOf 方法可以重用相同的对象，具体取决于值。

欲了解更多信息，请参阅：
https:// /www.securecoding.cert.org/confluence/display/java/LCK01-J.+Do+not+synchronize+on+objects+that+may+be+reused

Answer 22

通常在方法级别使用锁太粗鲁了。 为什么要通过锁定整个方法来锁定一段不访问任何共享资源的代码。 由于每个对象都有一个锁，因此您可以创建虚拟对象来实现块级同步。
块级别更有效，因为它不会锁定整个方法。

这里有一些示例

方法级别

class MethodLevel {

  //shared among threads
SharedResource x, y ;

public void synchronized method1() {
   //multiple threads can't access
}
public void synchronized method2() {
  //multiple threads can't access
}

 public void method3() {
  //not synchronized
  //multiple threads can access
 }
}

块级别

class BlockLevel {
  //shared among threads
  SharedResource x, y ;

  //dummy objects for locking
  Object xLock = new Object();
  Object yLock = new Object();

    public void method1() {
     synchronized(xLock){
    //access x here. thread safe
    }

    //do something here but don't use SharedResource x, y
    // because will not be thread-safe
     synchronized(xLock) {
       synchronized(yLock) {
      //access x,y here. thread safe
      }
     }

     //do something here but don't use SharedResource x, y
     //because will not be thread-safe
    }//end of method1
 }

[编辑]< /strong>

对于Collection，如Vector和Hashtable，它们在ArrayList或HashMap时同步> 不是，您需要设置同步关键字或调用集合同步方法：

Map myMap = Collections.synchronizedMap (myMap); // single lock for the entire map
List myList = Collections.synchronizedList (myList); // single lock for the entire list

Answer 23

唯一的区别：与同步方法不同，同步块允许粒度锁定

基本上，同步块或方法已用于通过避免内存不一致来编写线程安全代码错误。

这个问题很老了，在过去 7 年里很多事情都发生了变化。
为了线程安全引入了新的编程结构。

您可以通过使用高级并发 API 而不是 synchronied 块来实现线程安全。 本文档页面提供了良好的编程结构来实现线程安全。

锁定对象 支持锁定惯用法，可简化许多并发应用程序。

执行器定义了一个高用于启动和管理线程的级别 API。 java.util.concurrent 提供的 Executor 实现提供了适合大型应用程序的线程池管理。

并发集合让一切变得更容易来管理大量数据集合，并且可以大大减少同步的需要。

原子变量具有以下功能：最大限度地减少同步并有助于避免内存一致性错误。

ThreadLocalRandom< /strong>（在 JDK 7 中）提供从多个线程高效生成伪随机数的功能。

同步的更好替代品是 ReentrantLock，使用Lock API

可重入互斥锁，与使用同步方法和语句访问的隐式监视器锁具有相同的基本行为和语义，但具有扩展功能。

带锁的示例：

class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() {
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
 }

请参阅 java.lang. util.concurrent 和 java.util.concurrent.atomic 也适用于其他编程结构。

也请参考此相关问题：

同步与锁定