多线程（四）~数据操作的原子性，使用原子性操作AutomicInteger替换非原子性的i++的操作

这一章，我们要来验证volatile关键字不是原子性的，OK，还是用代码来说话。

①.线程类，操作i++ 500次

1. package com.multiThread.thread;
3. publicclassNumberThreadimplementsRunnable{
5. privatevolatileint num =0;
7. @Override
8. publicvoid run(){
9. for(int i =0;i<500;i++){
10. num++;
11. }
12. }
14. publicint getNum(){
15. return num;
16. }
17. publicvoid setNum(int num){
18. this.num = num;
19. }
20. }

②.测试类，创建5个线程同时执行

1. package com.multiThread.test.automic;
3. import com.multiThread.thread.NumberThread;
5. publicclassAutomicTest{
6. publicstaticvoid main(String[] args){
7. NumberThread numThread =newNumberThread();
8. for(int i =0;i<5;i++){
9. Thread t =newThread(numThread);
10. t.start();
11. }
12. try{
13. Thread.sleep(1000);
14. }catch(InterruptedException e){
15. e.printStackTrace();
16. }
17. System.out.println(numThread.getNum());
18. }
19. }

多次运行结果：（正常结果2500居多）

1. 2500
3. 2282
5. 2458

 

为什么造成这种现象？

首先我们要知道i++不是原子操作，是线程不安全的，它分为以下3步：

1.获取i的值

2.执行i+1的操作

3.将结果赋值给i

其次就算变量已经使用volatile关键字来修饰，只能保证读取全局变量num值的时候从主存拿到的是最新的值。

但是当多个线程同时操作自加的时候，如果之前取到的是同一个值，再自加后得到的值是相同的。

 

解决的方式如下两种：

1.可以使用synchronize关键字进行同步操作，这种情况需要把volatile去掉。因为synchronize本身就会操作工作内存和主内存直接的数据同步，此方式不再赘述。

2.将i++更改为线程安全的原子性操作，使用AtomicInteger替代i++

 

①.线程类

1. package com.multiThread.thread;
3. import java.util.concurrent.atomic.AtomicInteger;
5. publicclassNumberThread2implementsRunnable{
7. privateAtomicInteger num =newAtomicInteger();
9. @Override
10. publicvoid run(){
11. for(int i =0;i<500;i++){
12. num.incrementAndGet();
13. }
14. }
16. publicAtomicInteger getNum(){
17. return num;
18. }
20. publicvoid setNum(AtomicInteger num){
21. this.num = num;
22. }
23. }

②.测试类

1. package com.multiThread.test.automic;
3. import com.multiThread.thread.NumberThread;
4. import com.multiThread.thread.NumberThread2;
6. publicclassAutomicTest{
7. publicstaticvoid main(String[] args){
9. NumberThread2 numThread2 =newNumberThread2();
10. for(int i =0;i<5;i++){
11. Thread t =newThread(numThread2);
12. t.start();
13. }
14. try{
15. Thread.sleep(1000);
16. }catch(InterruptedException e){
17. e.printStackTrace();
18. }
19. System.out.println(numThread2.getNum());
21. }
22. }

运行结果

1. 2500

 

 

 

 

 

 

 

来自为知笔记(Wiz)