devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java实现多线程操作多账户_多线程转账问题

作者：不正经 | 2024-05-15 19:15:02

赞

踩

多线程转账问题

前言

某公司一个面试题：

1.有二十个账户，每个账户初始余额10000元。

2.有十个转账线程，对二十个账户中的两个随机选取账户进行转账，转账额度100以内正整数随机数。

3.每个线程执行100次转账操作。

4.最后请打印出二十个账户的余额。

正好很久没有做这类型题了，拿来练练手，结果碰到了一些问题。

正文

方案一：

首先描述下思路，首先用一个List数组存20个账户，然后对每个账户赋初值10000，在新建10个转账线程，对List数组中20个账户进行并发操作，每个线程分别获取两个账户进行随机额度转账。那么最简单的方式就是对List数组进行加锁就可以了。代码实现如下：

  1. public class test {
  2.     static int num;
  3.     public static void main(String[] args) {
  4.         List<Integer> accountList = new ArrayList<Integer>();
  5.         for (int i = 0;i < 20;i++){
  6.             accountList.add(10000);
  7.         }
  8.         System.out.println(num);
  9.  
  10.         MulThreadTest mulThreadTest = new MulThreadTest(accountList);
  11.         ThreadGroup threadGroup =new ThreadGroup("ThreadGroup1");
  12.         for (int i = 0;i < 10;i++){
  13.             Thread thread = new Thread(mulThreadTest);
  14.             thread.setName("thread="+i);
  15.             thread.start();
  16.         }
  17.         try{
  18.             Thread.sleep(5000);
  19.         }catch(Exception e){
  20.             e.printStackTrace();
  21.         }
  22.         int sum = 0;
  23.         for (int i = 0;i < 20;i++){
  24.             sum = sum + accountList.get(i);
  25.             System.out.println(accountList.get(i));
  26.         }
  27.         System.out.println(sum);
  28.     }
  29. }
  1. public class MulThreadTest implements Runnable{
  2.     private List<Integer> accountList;
  3.     private  int first;
  4.     private  int second;
  5.     private  int num;
  6.  
  7.     public MulThreadTest(List accountList){
  8.         this.accountList = accountList;
  9.     }
  10.     @Override
  11.     public void run() {
  12.         synchronized (accountList){
  13.             for(int i = 0;i < 100;i ++) {
  14.                 first = new Random().nextInt(20);
  15.                 second = new Random().nextInt(20);
  16.                 if(first == second){
  17.                     if(second < 19){
  18.                         second += 1;
  19.                     }else {
  20.                         second = 1;
  21.                     }
  22.  
  23.                 }
  24.                 num = new Random().nextInt(100);
  25.                 if(accountList.get(first) - num < 0){
  26.                     i --;
  27.                     continue;
  28.                 }
  29.                 System.out.println(Thread.currentThread().getName()+",操作前："+"账户："+first+"="+accountList.get(first)+"账户："+second+"="+accountList.get(second));
  30.                 accountList.set(first,accountList.get(first) -  num);
  31.                 accountList.set(second,accountList.get(second) +  num);
  32.                 System.out.println(Thread.currentThread().getName()+",操作："+"账户："+first+"="+accountList.get(first)+"=>"+num+"=>"+"账户："+second+"="+accountList.get(second));
  33.             }
  34.         }
  35.  
  36.     }
  37. }

以下是20个账户的金额以及总金额

  1. 10114
  2. 10046
  3. 10268
  4. 10676
  5. 10250
  6. 10344
  7. 9899
  8. 10120
  9. 9629
  10. 10145
  11. 9211
  12. 9761
  13. 9903
  14. 10187
  15. 9374
  16. 10508
  17. 10046
  18. 10005
  19. 9529
  20. 9985
  21. 200000

以上可以解决这个转账并发问题，但是锁的粒度还是有点大了，在一个线程操作List时其它线程是没法操作的，那么如何减小锁的粒度，实现更高的效率呢？

方案二：

在方案一的基础上，把锁的对象修改为List中的某个账户，这样当其中一个线程在操作某个账户时，其它线程就仅仅无法操作该账户，影响范围能减小很多。代码实现如下：

  1. public class test {
  2.     static int num;
  3.     public static void main(String[] args) {
  4.         List<Account> accountList = new ArrayList<Account>();
  5.         for (int i = 0;i < 20;i++){
  6.             accountList.add(new Account(10000));
  7.         }
  8.         System.out.println(num);
  9.  
  10.         MulThreadTest1 mulThreadTest = new MulThreadTest1(accountList);
  11.         ThreadGroup threadGroup =new ThreadGroup("ThreadGroup1");
  12.         for (int i = 0;i < 10;i++){
  13.             Thread thread = new Thread(mulThreadTest);
  14.             thread.setName("thread="+i);
  15.             thread.start();
  16.         }
  17.         try{
  18.             Thread.sleep(5000);
  19.         }catch(Exception e){
  20.             e.printStackTrace();
  21.         }
  22.         int sum = 0;
  23.         for (int i = 0;i < 20;i++){
  24.             sum = sum + accountList.get(i).getNum();
  25.             System.out.println(accountList.get(i).getNum());
  26.         }
  27.         System.out.println(sum);
  28.     }
  29. }
  1. public class MulThreadTest1 implements Runnable{
  2.     private List<Account> accountList;
  3.     Account firstInteger;
  4.     Account secondInteger;
  5.  
  6.  
  7.     public MulThreadTest1(List accountList){
  8.         this.accountList = accountList;
  9.     }
  10.     @Override
  11.     public void run() {
  12.          int first;
  13.          int second;
  14.          int num;
  15.          
  16.             for(int i = 0;i < 100;i ++) {
  17.                 first = new Random().nextInt(20);
  18.                 second = new Random().nextInt(20);
  19.                 if(first == second){
  20.                     if(second < 19){
  21.                         second += 1;
  22.                     }else {
  23.                         second = 1;
  24.                     }
  25.  
  26.                 }
  27.                 firstInteger = accountList.get(first);
  28.  
  29.                     synchronized (firstInteger) {
  30.  
  31.                         num = new Random().nextInt(100);
  32.                         if (firstInteger.getNum() - num < 0) {
  33.                             i--;
  34.                             continue;
  35.                         }
  36.                         System.out.println(Thread.currentThread().getName() + ",操作前：" + "账户：" + first + "=" + accountList.get(first).getNum() + "账户：" + second + "=" + accountList.get(second).getNum());
  37.  
  38.                         firstInteger.setNum(firstInteger.getNum() - num);
  39.  
  40.                         accountList.set(first, firstInteger);
  41.  
  42.                     secondInteger = accountList.get(second);
  43.  
  44.                         synchronized (secondInteger) {
  45.                             secondInteger.setNum(secondInteger.getNum() + num);
  46.                             accountList.set(second, secondInteger);
  47.                             //accountList.set(first,accountList.get(first) -  num);
  48.                             //accountList.set(second,accountList.get(second) +  num);
  49.                             System.out.println(Thread.currentThread().getName() + ",操作：" + "账户：" + first + "=" + accountList.get(first).getNum() + "=>" + num + "=>" + "账户：" + second + "=" + accountList.get(second).getNum());
  50.                         }
  51.                 
  52.                 }
  53.  
  54.                    
  55.  
  56.             }
  57.  
  58.     }
  59. }

部分结果如下：

  1. thread=4,操作前：账户：15=10037账户：16=10307
  2. thread=4,操作：账户：15=9972=>65=>账户：16=10372
  3. thread=4,操作前：账户：10=10012账户：16=10372
  4. thread=4,操作：账户：10=9958=>54=>账户：16=10426
  5. thread=4,操作前：账户：3=9854账户：19=9845
  6. thread=6,操作前：账户：14=9842账户：19=9998
  7. thread=0,操作前：账户：19=9845账户：14=9842
  8. thread=5,操作前：账户：2=9821账户：17=10387
  9. thread=5,操作：账户：2=9786=>35=>账户：17=10422
  10. thread=5,操作前：账户：0=9574账户：14=9822
  11. thread=8,操作前：账户：15=9972账户：16=10426
  12. thread=8,操作：账户：15=9962=>10=>账户：16=10436
  13. thread=7,操作前：账户：18=10367账户：19=9760
  14. thread=8,操作前：账户：17=10422账户：10=9958
  15. thread=8,操作：账户：17=10414=>8=>账户：10=9966
  16. thread=8,操作前：账户：1=10552账户：10=9966
  17. thread=8,操作：账户：1=10487=>65=>账户：10=10031
  18. 9528
  19. 10487
  20. 9786
  21. 9763
  22. 10109
  23. 9916
  24. 9162
  25. 9803
  26. 10237
  27. 10276
  28. 10031
  29. 10163
  30. 9987
  31. 9686
  32. 9822
  33. 9962
  34. 10436
  35. 10414
  36. 10359
  37. 9760
  38. 199687

使用jps和jstack即可看到线程状态

  1. Found one Java-level deadlock:
  2. =============================
  3.  
  4. "thread=2":
  5.   waiting to lock Monitor@0x00000000192b2598 (Object@0x00000000d5ea31b8, a com/xxx/testdemo/multhreadtest/Account),
  6.   which is held by "thread=7"
  7. "thread=7":
  8.   waiting to lock Monitor@0x00000000192b1038 (Object@0x00000000d5ea30a8, a com/xxx/testdemo/multhreadtest/Account),
  9.   which is held by "thread=9"
  10. "thread=9":
  11.   waiting to lock Monitor@0x00000000192b3cf8 (Object@0x00000000d5ea31a0, a com/xxx/testdemo/multhreadtest/Account),
  12.   which is held by "thread=2"
  13.  
  14. Found a total of 1 deadlock.
  15.  
  16. Thread 1: (state = BLOCKED)
  17.  
  18.  
  19. Thread 26: (state = BLOCKED)
  20.  - com.rain.testdemo.multhreadtest.MulThreadTest1.run() @bci=270, line=56 (Interpreted frame)
  21.  - java.lang.Thread.run() @bci=11, line=745 (Interpreted frame)
  22.  
  23.  
  24. Thread 25: (state = BLOCKED)
  25.  - com.rain.testdemo.multhreadtest.MulThreadTest1.run() @bci=91, line=41 (Interpreted frame)
  26.  - java.lang.Thread.run() @bci=11, line=745 (Interpreted frame)
  27.  
  28.  
  29. Thread 24: (state = BLOCKED)
  30.  - com.rain.testdemo.multhreadtest.MulThreadTest1.run() @bci=270, line=56 (Interpreted frame)
  31.  - java.lang.Thread.run() @bci=11, line=745 (Interpreted frame)
  32.  
  33.  
  34. Thread 23: (state = BLOCKED)
  35.  - com.rain.testdemo.multhreadtest.MulThreadTest1.run() @bci=91, line=41 (Interpreted frame)
  36.  - java.lang.Thread.run() @bci=11, line=745 (Interpreted frame)
  37.  
  38.  
  39. Thread 22: (state = BLOCKED)
  40.  - com.rain.testdemo.multhreadtest.MulThreadTest1.run() @bci=91, line=41 (Interpreted frame)
  41.  - java.lang.Thread.run() @bci=11, line=745 (Interpreted frame)
  42.  
  43.  
  44. Thread 21: (state = BLOCKED)
  45.  - com.rain.testdemo.multhreadtest.MulThreadTest1.run() @bci=270, line=56 (Interpreted frame)
  46.  - java.lang.Thread.run() @bci=11, line=745 (Interpreted frame)
  47.  
  48.  
  49. Thread 20: (state = BLOCKED)
  50.  - com.rain.testdemo.multhreadtest.MulThreadTest1.run() @bci=270, line=56 (Interpreted frame)
  51.  - java.lang.Thread.run() @bci=11, line=745 (Interpreted frame)
  52.  
  53.  
  54. Thread 19: (state = BLOCKED)
  55.  - com.rain.testdemo.multhreadtest.MulThreadTest1.run() @bci=270, line=56 (Interpreted frame)
  56.  - java.lang.Thread.run() @bci=11, line=745 (Interpreted frame)
  57.  
  58.  
  59. Thread 18: (state = BLOCKED)
  60.  - com.rain.testdemo.multhreadtest.MulThreadTest1.run() @bci=270, line=56 (Interpreted frame)
  61.  - java.lang.Thread.run() @bci=11, line=745 (Interpreted frame)
  62.  
  63.  
  64. Thread 17: (state = BLOCKED)
  65.  - com.rain.testdemo.multhreadtest.MulThreadTest1.run() @bci=91, line=41 (Interpreted frame)
  66.  - java.lang.Thread.run() @bci=11, line=745 (Interpreted frame)
  67.  
  68.  
  69. Thread 11: (state = IN_NATIVE)
  70.  - java.net.SocketInputStream.socketRead0(java.io.FileDescriptor, byte[], int, int, int) @bci=0 (Interpreted frame)
  71.  - java.net.SocketInputStream.socketRead(java.io.FileDescriptor, byte[], int, int, int) @bci=8, line=116 (Interpreted frame)
  72.  - java.net.SocketInputStream.read(byte[], int, int, int) @bci=117, line=171 (Interpreted frame)
  73.  - java.net.SocketInputStream.read(byte[], int, int) @bci=11, line=141 (Interpreted frame)
  74.  - sun.nio.cs.StreamDecoder.readBytes() @bci=135, line=284 (Interpreted frame)
  75.  - sun.nio.cs.StreamDecoder.implRead(char[], int, int) @bci=112, line=326 (Interpreted frame)
  76.  - sun.nio.cs.StreamDecoder.read(char[], int, int) @bci=180, line=178 (Interpreted frame)
  77.  - java.io.InputStreamReader.read(char[], int, int) @bci=7, line=184 (Interpreted frame)
  78.  - java.io.BufferedReader.fill() @bci=145, line=161 (Interpreted frame)
  79.  - java.io.BufferedReader.readLine(boolean) @bci=44, line=324 (Interpreted frame)
  80.  - java.io.BufferedReader.readLine() @bci=2, line=389 (Interpreted frame)
  81.  - com.intellij.rt.execution.application.AppMainV2$1.run() @bci=36, line=47 (Interpreted frame)
  82.  
  83.  
  84. Thread 10: (state = BLOCKED)
  85.  
  86.  
  87. Thread 9: (state = BLOCKED)
  88.  
  89.  
  90. Thread 8: (state = BLOCKED)
  91.  - java.lang.Object.wait(long) @bci=0 (Interpreted frame)
  92.  - java.lang.ref.ReferenceQueue.remove(long) @bci=59, line=143 (Interpreted frame)
  93.  - java.lang.ref.ReferenceQueue.remove() @bci=2, line=164 (Interpreted frame)
  94.  - java.lang.ref.Finalizer$FinalizerThread.run() @bci=36, line=209 (Interpreted frame)
  95.  
  96.  
  97. Thread 7: (state = BLOCKED)
  98.  - java.lang.Object.wait(long) @bci=0 (Interpreted frame)
  99.  - java.lang.Object.wait() @bci=2, line=502 (Interpreted frame)
  100.  - java.lang.ref.Reference.tryHandlePending(boolean) @bci=54, line=191 (Interpreted frame)
  101.  - java.lang.ref.Reference$ReferenceHandler.run() @bci=1, line=153 (Interpreted frame)

发现已经deadlock了 

修改如下：

  1. public class MulThreadTest1 implements Runnable{
  2.     private List<Account> accountList;
  3.     Account firstInteger;
  4.     Account secondInteger;
  5.     volatile int flag1 = 0;
  6.     volatile int flag2 = 0;
  7.  
  8.  
  9.     public MulThreadTest1(List accountList){
  10.         this.accountList = accountList;
  11.     }
  12.     @Override
  13.     public void run() {
  14.          int first;
  15.          int second;
  16.          int num;
  17.  
  18.             for(int i = 0;i < 100;i ++) {
  19.                 first = new Random().nextInt(20);
  20.                 second = new Random().nextInt(20);
  21.                 if(first == second){
  22.                     if(second < 19){
  23.                         second += 1;
  24.                     }else {
  25.                         second = 1;
  26.                     }
  27.  
  28.                 }
  29.                 firstInteger = accountList.get(first);
  30.                 if(flag1 == 0) {
  31.                     flag1 = 1;
  32.                     synchronized (firstInteger) {
  33.  
  34.                         num = new Random().nextInt(100);
  35.                         if (firstInteger.getNum() - num < 0) {
  36.                             i--;
  37.                             continue;
  38.                         }
  39.                         System.out.println(Thread.currentThread().getName() + ",操作前：" + "账户：" + first + "=" + accountList.get(first).getNum() + "账户：" + second + "=" + accountList.get(second).getNum());
  40.  
  41.                         firstInteger.setNum(firstInteger.getNum() - num);
  42.  
  43.                         accountList.set(first, firstInteger);
  44.  
  45.                     }
  46.                     flag1 = 0;
  47.                     secondInteger = accountList.get(second);
  48.                     if(flag2 == 0) {
  49.                         flag2 = 1;
  50.                         synchronized (secondInteger) {
  51.                             secondInteger.setNum(secondInteger.getNum() + num);
  52.                             accountList.set(second, secondInteger);
  53.                             //accountList.set(first,accountList.get(first) -  num);
  54.                             //accountList.set(second,accountList.get(second) +  num);
  55.                             System.out.println(Thread.currentThread().getName() + ",操作：" + "账户：" + first + "=" + accountList.get(first).getNum() + "=>" + num + "=>" + "账户：" + second + "=" + accountList.get(second).getNum());
  56.                         }
  57.                     }
  58.                 }
  59.  
  60.                     flag2 = 0;
  61.  
  62.             }
  63.  
  64.     }
  65. }

输出结果发现最终所有账户金额总额不是200000。

以上代码存在几个问题：

问题一：假如线程1对该对象进行操作时，从List中获取账户对象后，线程2也会从List中获取账户对象，然后当线程1抢到锁之前，线程2把线程1中的账户对象覆盖了，这样操作就有问题了。

问题二：假如线程1抢到了锁，并对账户1进行了操作，即将对账户2进行操作，此时发现flag2为1，那么此时线程1就会结束本次操作，这样线程1只对账户1进行了金额扣除，并没有回退操作，总金额就减少了。

问题三：设置两个flag值并不能防止死锁。当线程1锁了账户1，线程2锁了账户2，假设线程1和线程2同时制行了if(flag1==0),那么此时flag1并没有起到作用，之后线程1和线程2再次同时执行了if(flag2==0)，线程1去对账户2操作，线程2去对账户1操作，发现都是锁着的，这就导致了死锁。

那么应该如何来防止以上死锁的情况呢？

只要打破造成死锁的条件即可，以上方案造成死锁的原因是同一个线程同时去抢占两个锁，这样很容易死锁，所以只要保证同一个线程同一个时刻只能获取一个锁这样就能避免死锁。

  1. public class MulThreadTest3 implements Runnable{
  2.     private List<Account> accountList;
  3.     //Account firstInteger;
  4.     //Account secondInteger;
  5.  
  6.     public MulThreadTest3(List accountList){
  7.         this.accountList = accountList;
  8.     }
  9.     @Override
  10.     public void run() {
  11.          int first;
  12.          int second;
  13.          int num;
  14.  
  15.          for(int i = 0;i < 100;i ++) {
  16.              first = new Random().nextInt(20);
  17.              second = new Random().nextInt(20);
  18.              if(first == second){
  19.                  if(second < 19){
  20.                      second += 1;
  21.                  }else {
  22.                      second = 1;
  23.                  }
  24.              }
  25.              //System.out.println(Thread.currentThread().getStackTrace()+Thread.currentThread().getName());
  26.              Account firstInteger = accountList.get(first);
  27.              synchronized (firstInteger) {
  28.  
  29.                  num = new Random().nextInt(100);
  30.                  if (firstInteger.getNum() - num < 0) {
  31.                      i--;
  32.                      continue;
  33.                  }
  34.                  System.out.println(Thread.currentThread().getStackTrace()[0].getMethodName()+Thread.currentThread().getName() + ",操作前：" + "账户：" + first + "=" + accountList.get(first).getNum() + "账户：" + second + "=" + accountList.get(second).getNum());
  35.  
  36.                  firstInteger.setNum(firstInteger.getNum() - num);
  37.                  firstInteger.setThreadName(Thread.currentThread().getName());
  38.                  accountList.set(first, firstInteger);
  39.              }
  40.  
  41.              Account secondInteger = accountList.get(second);
  42.              synchronized (secondInteger) {
  43.                  secondInteger.setNum(secondInteger.getNum() + num);
  44.                  firstInteger.setThreadName(Thread.currentThread().getName());
  45.                  accountList.set(second, secondInteger);
  46.                  //accountList.set(first,accountList.get(first) -  num);
  47.                  //accountList.set(second,accountList.get(second) +  num);
  48.                  System.out.println(Thread.currentThread().getStackTrace()[0].getMethodName()+Thread.currentThread().getName() + ",操作：" + "账户：" + first + "=" + accountList.get(first).getNum() + "=>" + num + "=>" + "账户：" + second + "=" + accountList.get(second).getNum());
  49.              }
  50.  
  51.          }
  52.  
  53.     }
  54. }

部分运行结果如下

  1. getStackTracethread=0,操作前：账户：5=11323账户：19=9676
  2. getStackTracethread=1,操作：账户：16=10083=>10=>账户：10=9543
  3. getStackTracethread=0,操作：账户：5=11299=>24=>账户：19=9700
  4. getStackTracethread=1,操作前：账户：11=10993账户：9=10525
  5. getStackTracethread=0,操作前：账户：18=9344账户：1=9939
  6. getStackTracethread=1,操作：账户：11=10983=>10=>账户：9=10535
  7. getStackTracethread=0,操作：账户：18=9324=>20=>账户：1=9959
  8. getStackTracethread=1,操作前：账户：10=9543账户：19=9700
  9. getStackTracethread=0,操作前：账户：18=9324账户：10=9543
  10. getStackTracethread=1,操作：账户：10=9522=>21=>账户：19=9721
  11. getStackTracethread=0,操作：账户：18=9307=>17=>账户：10=9539
  12. getStackTracethread=1,操作前：账户：19=9721账户：15=10155
  13. getStackTracethread=1,操作：账户：19=9689=>32=>账户：15=10187
  14. getStackTracethread=1,操作前：账户：3=10113账户：5=11299
  15. getStackTracethread=1,操作：账户：3=10097=>16=>账户：5=11315
  16. getStackTracethread=1,操作前：账户：13=9419账户：11=10983
  17. getStackTracethread=1,操作：账户：13=9398=>21=>账户：11=11004
  18. getStackTracethread=1,操作前：账户：5=11315账户：3=10097
  19. getStackTracethread=1,操作：账户：5=11251=>64=>账户：3=10161
  20. 9280
  21. 9959
  22. 10004
  23. 10161
  24. 10641
  25. 11251
  26. 10040
  27. 8710
  28. 9800
  29. 10535
  30. 9539
  31. 11004
  32. 10635
  33. 9398
  34. 9814
  35. 10187
  36. 10083
  37. 9963
  38. 9307
  39. 9689
  40. 200000

总结

本题考察了多线程，以及多线程场景中锁的应用，如何避免死锁是关键，方案一虽然能很快解决本地，但是应该不是最理想的方案。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/574586
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号