Java学习笔记---多线程同步的五种方法

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java学习笔记---多线程同步的五种方法相关的知识，希望对你有一定的参考价值。

一、引言

前几天面试，被大师虐残了，好多基础知识必须得重新拿起来啊。闲话不多说，进入正题。

二、为什么要线程同步

因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不成功，账户余额是100.取钱成功了，账户余额是0.那到底是哪个呢？很难说清楚。因此多线程同步就是要解决这个问题。

三、不同步时的代码

Bank.java

  1. packagethreadTest;
  2.  
  3. /**
  4. *@authorww
  5. *
  6. */
  7. publicclassBank{
  8.  
  9. privateintcount=0;//账户余额
  10.  
  11. //存钱
  12. publicvoidaddMoney(intmoney){
  13. count+=money;
  14. System.out.println(System.currentTimeMillis()+"存进："+money);
  15. }
  16.  
  17. //取钱
  18. publicvoidsubMoney(intmoney){
  19. if(count-money<0){
  20. System.out.println("余额不足");
  21. return;
  22. }
  23. count-=money;
  24. System.out.println(+System.currentTimeMillis()+"取出："+money);
  25. }
  26.  
  27. //查询
  28. publicvoidlookMoney(){
  29. System.out.println("账户余额："+count);
  30. }
  31. }

SyncThreadTest.java

  1. packagethreadTest;
  2.  
  3.  
  4. publicclassSyncThreadTest{
  5.  
  6. publicstaticvoidmain(Stringargs[]){
  7. finalBankbank=newBank();
  8.  
  9. Threadtadd=newThread(newRunnable(){
  10.  
  11. @Override
  12. publicvoidrun(){
  13. //TODOAuto-generatedmethodstub
  14. while(true){
  15. try{
  16. Thread.sleep(1000);
  17. }catch(InterruptedExceptione){
  18. //TODOAuto-generatedcatchblock
  19. e.printStackTrace();
  20. }
  21. bank.addMoney(100);
  22. bank.lookMoney();
  23. System.out.println("n");
  24.  
  25. }
  26. }
  27. });
  28.  
  29. Threadtsub=newThread(newRunnable(){
  30.  
  31. @Override
  32. publicvoidrun(){
  33. //TODOAuto-generatedmethodstub
  34. while(true){
  35. bank.subMoney(100);
  36. bank.lookMoney();
  37. System.out.println("n");
  38. try{
  39. Thread.sleep(1000);
  40. }catch(InterruptedExceptione){
  41. //TODOAuto-generatedcatchblock
  42. e.printStackTrace();
  43. }
  44. }
  45. }
  46. });
  47. tsub.start();
  48.  
  49. tadd.start();
  50. }
  51.  
  52.  
  53.  
  54. }

代码很简单，我就不解释了，看看运行结果怎样呢？截取了其中的一部分，是不是很乱，有写看不懂。

  1. 余额不足
  2. 账户余额：0
  3.  
  4.  
  5. 余额不足
  6. 账户余额：100
  7.  
  8.  
  9. 1441790503354存进：100
  10. 账户余额：100
  11.  
  12.  
  13. 1441790504354存进：100
  14. 账户余额：100
  15.  
  16.  
  17. 1441790504354取出：100
  18. 账户余额：100
  19.  
  20.  
  21. 1441790505355存进：100
  22. 账户余额：100
  23.  
  24.  
  25. 1441790505355取出：100
  26. 账户余额：100

四、使用同步时的代码

（1）同步方法：

即有synchronized关键字修饰的方法。由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

修改后的Bank.java

  1. packagethreadTest;
  2.  
  3. /**
  4. *@authorww
  5. *
  6. */
  7. publicclassBank{
  8.  
  9. privateintcount=0;//账户余额
  10.  
  11. //存钱
  12. publicsynchronizedvoidaddMoney(intmoney){
  13. count+=money;
  14. System.out.println(System.currentTimeMillis()+"存进："+money);
  15. }
  16.  
  17. //取钱
  18. publicsynchronizedvoidsubMoney(intmoney){
  19. if(count-money<0){
  20. System.out.println("余额不足");
  21. return;
  22. }
  23. count-=money;
  24. System.out.println(+System.currentTimeMillis()+"取出："+money);
  25. }
  26.  
  27. //查询
  28. publicvoidlookMoney(){
  29. System.out.println("账户余额："+count);
  30. }
  31. }

再看看运行结果：

  1. 余额不足
  2. 账户余额：0
  3.  
  4.  
  5. 余额不足
  6. 账户余额：0
  7.  
  8.  
  9. 1441790837380存进：100
  10. 账户余额：100
  11.  
  12.  
  13. 1441790838380取出：100
  14. 账户余额：0
  15. 1441790838380存进：100
  16. 账户余额：100
  17.  
  18.  
  19.  
  20.  
  21. 1441790839381取出：100
  22. 账户余额：0

瞬间感觉可以理解了吧。

注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

（2）同步代码块

即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

Bank.java代码如下：

  1. packagethreadTest;
  2.  
  3. /**
  4. *@authorww
  5. *
  6. */
  7. publicclassBank{
  8.  
  9. privateintcount=0;//账户余额
  10.  
  11. //存钱
  12. publicvoidaddMoney(intmoney){
  13.  
  14. synchronized(this){
  15. count+=money;
  16. }
  17. System.out.println(System.currentTimeMillis()+"存进："+money);
  18. }
  19.  
  20. //取钱
  21. publicvoidsubMoney(intmoney){
  22.  
  23. synchronized(this){
  24. if(count-money<0){
  25. System.out.println("余额不足");
  26. return;
  27. }
  28. count-=money;
  29. }
  30. System.out.println(+System.currentTimeMillis()+"取出："+money);
  31. }
  32.  
  33. //查询
  34. publicvoidlookMoney(){
  35. System.out.println("账户余额："+count);
  36. }
  37. }

运行结果如下：

  1. 余额不足
  2. 账户余额：0
  3.  
  4.  
  5. 1441791806699存进：100
  6. 账户余额：100
  7.  
  8.  
  9. 1441791806700取出：100
  10. 账户余额：0
  11.  
  12.  
  13. 1441791807699存进：100
  14. 账户余额：100

效果和方法一差不多。

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

（3）使用特殊域变量(volatile)实现线程同步

a.volatile关键字为域变量的访问提供了一种免锁机制
b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新
c.因此每次使用该域就要重新计算，而不是使用寄存器中的值
d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量

Bank.java代码如下：

  1. packagethreadTest;
  2.  
  3. /**
  4. *@authorww
  5. *
  6. */
  7. publicclassBank{
  8.  
  9. privatevolatileintcount=0;//账户余额
  10.  
  11. //存钱
  12. publicvoidaddMoney(intmoney){
  13.  
  14. count+=money;
  15. System.out.println(System.currentTimeMillis()+"存进："+money);
  16. }
  17.  
  18. //取钱
  19. publicvoidsubMoney(intmoney){
  20.  
  21. if(count-money<0){
  22. System.out.println("余额不足");
  23. return;
  24. }
  25. count-=money;
  26. System.out.println(+System.currentTimeMillis()+"取出："+money);
  27. }
  28.  
  29. //查询
  30. publicvoidlookMoney(){
  31. System.out.println("账户余额："+count);
  32. }
  33. }

运行效果怎样呢？

  1. 余额不足
  2. 账户余额：0
  3.  
  4.  
  5. 余额不足
  6. 账户余额：100
  7.  
  8.  
  9. 1441792010959存进：100
  10. 账户余额：100
  11.  
  12.  
  13. 1441792011960取出：100
  14. 账户余额：0
  15.  
  16.  
  17. 1441792011961存进：100
  18. 账户余额：100

是不是又看不懂了，又乱了。这是为什么呢？就是因为volatile不能保证原子操作导致的，因此volatile不能代替synchronized。此外volatile会组织编译器对代码优化，因此能不使用它就不适用它吧。它的原理是每次要线程要访问volatile修饰的变量时都是从内存中读取，而不是存缓存当中读取，因此每个线程访问到的变量值都是一样的。这样就保证了同步。

（4）使用重入锁实现线程同步

在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁，它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。
ReenreantLock类的常用方法有：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁
注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用
Bank.java代码修改如下：

  1. packagethreadTest;
  2.  
  3. importjava.util.concurrent.locks.Lock;
  4. importjava.util.concurrent.locks.ReentrantLock;
  5.  
  6. /**
  7. *@authorww
  8. *
  9. */
  10. publicclassBank{
  11.  
  12. privateintcount=0;//账户余额
  13.  
  14. //需要声明这个锁
  15. privateLocklock=newReentrantLock();
  16.  
  17. //存钱
  18. publicvoidaddMoney(intmoney){
  19. lock.lock();//上锁
  20. try{
  21. count+=money;
  22. System.out.println(System.currentTimeMillis()+"存进："+money);
  23.  
  24. }finally{
  25. lock.unlock();//解锁
  26. }
  27. }
  28.  
  29. //取钱
  30. publicvoidsubMoney(intmoney){
  31. lock.lock();
  32. try{
  33.  
  34. if(count-money<0){
  35. System.out.println("余额不足");
  36. return;
  37. }
  38. count-=money;
  39. System.out.println(+System.currentTimeMillis()+"取出："+money);
  40. }finally{
  41. lock.unlock();
  42. }
  43. }
  44.  
  45. //查询
  46. publicvoidlookMoney(){
  47. System.out.println("账户余额："+count);
  48. }
  49. }

运行效果怎么样呢？

  1. 余额不足
  2. 账户余额：0
  3.  
  4.  
  5. 余额不足
  6. 账户余额：0
  7.  
  8.  
  9. 1441792891934存进：100
  10. 账户余额：100
  11.  
  12.  
  13. 1441792892935存进：100
  14. 账户余额：200
  15.  
  16.  
  17. 1441792892954取出：100
  18. 账户余额：100

效果和前两种方法差不多。

如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 。如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁

（5）使用局部变量实现线程同步

Bank.java代码如下：

  1. packagethreadTest;
  2.  
  3.  
  4. /**
  5. *@authorww
  6. *
  7. */
  8. publicclassBank{
  9.  
  10. privatestaticThreadLocal<Integer>count=newThreadLocal<Integer>(){
  11.  
  12. @Override
  13. protectedIntegerinitialValue(){
  14. //TODOAuto-generatedmethodstub
  15. return0;
  16. }
  17.  
  18. };
  19.  
  20.  
  21. //存钱
  22. publicvoidaddMoney(intmoney){
  23. count.set(count.get()+money);
  24. System.out.println(System.currentTimeMillis()+"存进："+money);
  25.  
  26. }
  27.  
  28. //取钱
  29. publicvoidsubMoney(intmoney){
  30. if(count.get()-money<0){
  31. System.out.println("余额不足");
  32. return;
  33. }
  34. count.set(count.get()-money);
  35. System.out.println(+System.currentTimeMillis()+"取出："+money);
  36. }
  37.  
  38. //查询
  39. publicvoidlookMoney(){
  40. System.out.println("账户余额："+count.get());
  41. }
  42. }

运行效果：

  1. 余额不足
  2. 账户余额：0
  3.  
  4.  
  5. 余额不足
  6. 账户余额：0
  7.  
  8.  
  9. 1441794247939存进：100
  10. 账户余额：100
  11.  
  12.  
  13. 余额不足
  14. 1441794248940存进：100
  15. 账户余额：0
  16.  
  17.  
  18. 账户余额：200
  19.  
  20.  
  21. 余额不足
  22. 账户余额：0
  23.  
  24.  
  25. 1441794249941存进：100
  26. 账户余额：300

看了运行效果，一开始一头雾水，怎么只让存，不让取啊？看看ThreadLocal的原理：

如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。现在明白了吧，原来每个线程运行的都是一个副本，也就是说存钱和取钱是两个账户，知识名字相同而已。所以就会发生上面的效果。

ThreadLocal与同步机制
a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题

b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式

现在都明白了吧。各有优劣，各有适用场景。手工，吃饭去了。

问啊-定制化IT教育平台，牛人一对一服务，有问必答，开发编程社交头条 官方网站：www.wenaaa.com

QQ群290551701 聚集很多互联网精英，技术总监，架构师，项目经理！开源技术研究，欢迎业内人士，大牛及新手有志于从事IT行业人员进入！

以上是关于Java学习笔记---多线程同步的五种方法的主要内容，如果未能解决你的问题，请参考以下文章

Java 多线程同步的五种方法

多线程同步的五种方法

Java多线程的五种状态

面试常考：C#用两个线程交替打印1-100的五种方法

Java多线程

Java学习笔记—多线程（同步容器和并发容器）