怎么建立自己的网站域名,荣茂网站建设,aspx网站模板,网站开发的总结原子性是多线程程序中的关键概念之一。 我们说一组动作是原子的#xff0c;如果它们都以不可分割的方式作为一个单一的操作执行。 认为多线程程序中的一组操作将被串行执行是理所当然的#xff0c;可能会导致错误的结果。 原因是由于线程干扰#xff0c;这意味着如果两个线程… 原子性是多线程程序中的关键概念之一。 我们说一组动作是原子的如果它们都以不可分割的方式作为一个单一的操作执行。 认为多线程程序中的一组操作将被串行执行是理所当然的可能会导致错误的结果。 原因是由于线程干扰这意味着如果两个线程对同一数据执行多个步骤则它们可能会重叠。 以下交织示例显示了两个线程执行多个操作循环中的打印以及它们如何重叠 public class Interleaving {public void show() {for (int i 0; i 5; i) {System.out.println(Thread.currentThread().getName() - Number: i);}}public static void main(String[] args) {final Interleaving main new Interleaving();Runnable runner new Runnable() {Overridepublic void run() {main.show();}};new Thread(runner, Thread 1).start();new Thread(runner, Thread 2).start();}
} 执行时将产生不可预测的结果。 举个例子 Thread 2 - Number: 0
Thread 2 - Number: 1
Thread 2 - Number: 2
Thread 1 - Number: 0
Thread 1 - Number: 1
Thread 1 - Number: 2
Thread 1 - Number: 3
Thread 1 - Number: 4
Thread 2 - Number: 3
Thread 2 - Number: 4 在这种情况下不会发生任何错误因为它们只是打印数字。 但是当您需要在不同步的情况下共享对象的状态其数据时这会导致竞争条件的存在。 比赛条件 如果由于线程交织而有可能产生不正确的结果则您的代码将处于竞争状态。 本节描述了两种竞争条件 先检查后行动 读-修改-写 为了消除竞争条件并增强线程安全性我们必须通过使用同步使这些操作成为原子操作。 以下各节中的示例将显示这些竞争条件的影响。 先行动后竞赛状态 当您有一个共享字段并希望依次执行以下步骤时会出现此竞争条件 从字段中获取值。 根据上一次检查的结果来做一些事情。 这里的问题是当第一个线程在上次检查后要执行操作时另一个线程可能已经插入并更改了字段的值。 现在第一个线程将基于不再有效的值执行操作。 通过示例更容易看到这一点。 UnsafeCheckThenAct应该一次更改字段号 。 在对changeNumber方法的调用之后应导致执行else条件 public class UnsafeCheckThenAct {private int number;public void changeNumber() {if (number 0) {System.out.println(Thread.currentThread().getName() | Changed);number -1;}else {System.out.println(Thread.currentThread().getName() | Not changed);}}public static void main(String[] args) {final UnsafeCheckThenAct checkAct new UnsafeCheckThenAct();for (int i 0; i 50; i) {new Thread(new Runnable() {Overridepublic void run() {checkAct.changeNumber();}}, T i).start();}}
} 但是由于此代码未同步因此无法保证可能会导致对该字段进行多次修改 T13 | Changed
T17 | Changed
T35 | Not changed
T10 | Changed
T48 | Not changed
T14 | Changed
T60 | Not changed
T6 | Changed
T5 | Changed
T63 | Not changed
T18 | Not changed 这种竞争条件的另一个示例是延迟初始化 。 解决此问题的一种简单方法是使用同步。 SafeCheckThenAct是线程安全的因为它已通过同步对共享字段的所有访问来消除竞争条件。 public class SafeCheckThenAct {private int number;public synchronized void changeNumber() {if (number 0) {System.out.println(Thread.currentThread().getName() | Changed);number -1;}else {System.out.println(Thread.currentThread().getName() | Not changed);}}public static void main(String[] args) {final SafeCheckThenAct checkAct new SafeCheckThenAct();for (int i 0; i 50; i) {new Thread(new Runnable() {Overridepublic void run() {checkAct.changeNumber();}}, T i).start();}}
} 现在执行此代码将始终产生相同的预期结果。 只有一个线程会更改该字段 T0 | Changed
T54 | Not changed
T53 | Not changed
T62 | Not changed
T52 | Not changed
T51 | Not changed
... 在某些情况下还有其他机制会比同步整个方法更好但我不会在本文中讨论它们。 读-修改-写竞争条件 在这里当执行以下一组操作时会出现另一种竞争条件 从字段中获取值。 修改值。 将新值存储到该字段。 在这种情况下还有另一种危险的可能性那就是丢失了对该字段的某些更新。 一种可能的结果是 Field’s value is 1.
Thread 1 gets the value from the field (1).
Thread 1 modifies the value (5).
Thread 2 reads the value from the field (1).
Thread 2 modifies the value (7).
Thread 1 stores the value to the field (5).
Thread 2 stores the value to the field (7). 如您所见值5的更新已丢失。 让我们看一个代码示例。 UnsafeReadModifyWrite共享一个数字字段每次都会递增 public class UnsafeReadModifyWrite {private int number;public void incrementNumber() {number;}public int getNumber() {return this.number;}public static void main(String[] args) throws InterruptedException {final UnsafeReadModifyWrite rmw new UnsafeReadModifyWrite();for (int i 0; i 1_000; i) {new Thread(new Runnable() {Overridepublic void run() {rmw.incrementNumber();}}, T i).start();}Thread.sleep(6000);System.out.println(Final number (should be 1_000): rmw.getNumber());}
} 您能发现引起比赛状况的复合动作吗 我敢肯定你做到了但是为了完整起见我还是会解释一下。 问题出在增量 number 中。 这似乎是一个动作但实际上它是三个动作的序列get-increment-write。 执行此代码时我们可能会看到丢失了一些更新 2014-08-08 09:59:18,859|UnsafeReadModifyWrite|Final number (should be 10_000): 9996 由于无法保证线程如何交织因此取决于您的计算机将很难重现此更新丢失。 如果无法重现上面的示例请尝试UnsafeReadModifyWriteWithLatch 它使用CountDownLatch来同步线程的开始并重复测试一百次。 您可能应该在所有结果中看到一些无效值 Final number (should be 1_000): 1000
Final number (should be 1_000): 1000
Final number (should be 1_000): 1000
Final number (should be 1_000): 997
Final number (should be 1_000): 999
Final number (should be 1_000): 1000
Final number (should be 1_000): 1000
Final number (should be 1_000): 1000
Final number (should be 1_000): 1000
Final number (should be 1_000): 1000
Final number (should be 1_000): 1000 这个例子可以通过使所有三个动作原子化来解决。 SafeReadModifyWriteSynchronized在对共享字段的所有访问中使用同步 public class SafeReadModifyWriteSynchronized {private int number;public synchronized void incrementNumber() {number;}public synchronized int getNumber() {return this.number;}public static void main(String[] args) throws InterruptedException {final SafeReadModifyWriteSynchronized rmw new SafeReadModifyWriteSynchronized();for (int i 0; i 1_000; i) {new Thread(new Runnable() {Overridepublic void run() {rmw.incrementNumber();}}, T i).start();}Thread.sleep(4000);System.out.println(Final number (should be 1_000): rmw.getNumber());}
} 让我们看另一个删除此竞争条件的示例。 在这种特定情况下由于字段号与其他变量无关因此我们可以使用原子变量。 SafeReadModifyWriteAtomic使用原子变量来存储字段的值 public class SafeReadModifyWriteAtomic {private final AtomicInteger number new AtomicInteger();public void incrementNumber() {number.getAndIncrement();}public int getNumber() {return this.number.get();}public static void main(String[] args) throws InterruptedException {final SafeReadModifyWriteAtomic rmw new SafeReadModifyWriteAtomic();for (int i 0; i 1_000; i) {new Thread(new Runnable() {Overridepublic void run() {rmw.incrementNumber();}}, T i).start();}Thread.sleep(4000);System.out.println(Final number (should be 1_000): rmw.getNumber());}
} 以下帖子将进一步说明机制如锁定或原子变量。 结论 这篇文章解释了在非同步多线程程序中执行复合操作时隐含的一些风险。 为了强制执行原子性并防止线程交织必须使用某种类型的同步。 您可以在github上查看源代码。 翻译自: https://www.javacodegeeks.com/2014/08/java-concurrency-tutorial-atomicity-and-race-conditions.html
