程序博客网 > 如何生成短信淘宝链接

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

来源：互联网 发布：如何生成短信淘宝链接 编辑：程序博客网 时间：2024/06/11 04:55

一、引言

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

二、为什么要线程同步

因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取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行业人员进入！

0 0
如何生成短信淘宝链接 如何生成短信淘宝链接
原创粉丝点击
热门IT博客
云计算三层架构云计算三层架构
自学plc编程怎么学自学plc编程怎么学
java开源商城源码
万网域名如何解析
小学生作文辅导书 知乎
下载全球直播软件
标准化 知乎
淘宝假酒处罚规定
暗黑破坏神3淘宝
网络杀手是什么意思啊
qq苹果在线软件
约翰克利斯朵夫 知乎
易云网络人气
好的动漫知乎
豆浆机哪款好用 知乎
网页源文件提取数据
数据恢复多少钱
mt7603数据手册
网络互动直播节目
php echo
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 异维a酸凝胶 用凝胶排出脏东西原理 用凝胶排出脏东西图解 卡波姆凝胶 凝胶几天能排干净 欧迪玛抑菌凝胶 甲硝唑凝胶妇科 生长因子凝胶 避孕凝胶 凝胶是什么 眼用凝胶怎么用 妇科凝胶哪个品牌好 凝胶怎么用 阴道凝胶 妇炎洁妇科凝胶 凝胶枕头危害 妇炎洁凝胶 凝胶枕 凝胶的使用方法 妇科千金凝胶 抑菌凝胶 什么是凝胶 草本凝胶 李医生妇科凝胶 妇用抑菌凝胶 芦荟凝胶价格 凝胶电泳 透明质酸凝胶多少钱 芦荟修护凝胶 纳米凝胶 芦荟修复凝胶 外用凝胶 凝胶缩阴 纳米银妇科凝胶 食用凝胶 熊果苷凝胶 消痘凝胶 茶树凝胶 注射凝胶 脸部凝胶 凝胶眼膜

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里