程序博客网 > ubuntu 安装类型

黑马程序员__java基础之线程间通信

来源：互联网 发布：ubuntu 安装类型 编辑：程序博客网 时间：2024/05/01 13:58

------- android培训、java培训、期待与您交流！ ----------

线程间通信：

学习思路：
要实现线程间通信，首先要明确的明白通信之间如何连接。也就是说线程之间需要有共享的资源
那如何实现数据共享呢？
实现共享可以有3种方式：
（1）静态；（2）单例设计模式；（3）通过参数传递，这里通过构造函数实现
因为静态存在的时间过长，所以不建议。单例设计模式是允许的，这里的话，我们通过第三种方式进行讲解。

举例如下：

[java] view plaincopyprint?
  1. class ThreadTest
  2. {
  3. public staticvoid main(String[] args)
  4. {
  5. Res r = new Res();
  7. new Thread(new Input(r)).start();
  8. new Thread(new Output(r)).start();
  9. }
  10. }
  12. class Res
  13. {
[java] view plaincopyprint?
  1. /*
  2. 优化前：
  3. String name = name;
  4. String sex = sex;
  5. boolean flag =flag;
  7. */
  8. //优化后
  9. private String name;
  10. private String sex;
  11. private boolean flag =false;
  13. public synchronizedvoid set(String name,String sex)
  14. {
  15. if(this.flag)
  16. try{this.wait();}catch(Exception e){}
  18. this.name = name;
  19. this.sex = sex;
  21. this.flag = true;
  22. try{this.notify();}catch(Exception e){}
  24. }
  25. public synchronizedvoid out()
  26. {
  27. if(!this.flag)
  28. try{this.wait();}catch(Exception e){}
  30. System.out.println(name+"…………"+sex);
  31. this.flag = false;
  32. try{this.notify();}catch(Exception e){}
  33. }
  34. }
  36. class Input implements Runnable
  37. {
  38. private Res r;
  39. Input(Res r)
  40. {
  41. this.r = r;
  42. }
  43. public void run()
  44. {
  45. int x = 0;
  47. while(true)//为了实现连续多次打印，可以开始的用循环的形式进行输出
  48. {
  49. //给变量赋值
  50. /*
  51. 优化前的：
  52. synchronized(r)
  53. {
  54. if(r.flag)
  55. try{r.wait();}catch(Exception e){}
  56. if(x == 0)
  57. {
  58. r.name = "mike";
  59. r.sex = "man";
  60. }
  61. else
  62. {
  63. r.name = "丽丽";
  64. r.sex = "女女女女女";
  65. }
  66. x = (x+1)%2;
  67. r.flag = true;
  68. r.notify();
  69. }
  70. */
  71. //优化后
  72. if(x==0)
  73. r.set("mike","man");
  74. else
  75. r.set("丽丽","女女女女女");
  76. x = (x+1)%2;
  77. }
  78. }
  79. }
  81. class Output implements Runnable
  82. {
  83. private Res r;
  85. Output(Res r)
  86. {
  87. this.r = r;
  88. }
  89. public void run()
  90. {
  91. while(true)
  92. {
  93. //输出结果
  94. /*优化前
  95. synchronized(r)
  96. {
  97. if(!r.flag)
  98. try{r.wait();}catch(Exception e){}
  100. System.out.println(r.name+"…………"+r.sex);
  101. r.flag = false;
  103. try{r.notify();}catch(Exception e){}
  104. }
  105. */
  106. //优化后
  108. r.out();
  110. }
  111. }
  112. }
  113. /*


按上面的输出结果出现"mike 女女女女""丽丽 man"的情况，出现安全问题;
当出现安全问题的时候，首先要分析为什么会这样输出，什么原因呢？显然，这是由于输入输出不同步造成的
即输出的时候还进行到一半的时候，设置的值已经改变。因此，要解决这个问题，我们要做的，就是使
输入输出同步！注意，是输入输出都要同步,而不是其中之一同步。这点要注意。
同步时要注意，为了保证使用同一把锁，要把同步代码块的锁，使用同一对象。这里可以使用r。

完成以上步骤后，就实现了同步。但是有一个问题就是输入输出时总是连续的输出相同的，而我们想要的是：
输入一个，输出一个。为了达到这个目的，我们可以通过使用标记的方式。
开始的时候，我们可以初始化标记为false，如果开始的时候为真，则等待。假的话，就设置值。
当设置完后，标记的flag的真假要改变。顺便说一下，等待多线程放在线程池里，唤醒的时候（notify），
一定要指明唤醒的对象，最先唤醒的，是最近要执行的那一个!任意对象只能被同一对象的锁唤醒。
代码：

因为notify，wai方法哪个都可以调用，所以为Object类型。因为在run方法中，不能抛，只能解决

对程序优化后（见上面优化后代码）

这个线程是输入输出只有一个的情况，而现实中多是多个线程同时运行，这就是生产者消费者问题：

[java] view plaincopyprint?
  1. class ProductConsumerDemo
  2. {
  3. public staticvoid main(String[] args)
  4. {
  5. Resource r = new Resource();
  7. new Thread(new Producer(r)).start();
  8. new Thread(new Producer(r)).start();
  9. new Thread(new Consumer(r)).start();
  10. new Thread(new Consumer(r)).start();
  12. //创建并启动线程
  13. }
  14. }
  15. class Resource
  16. {
  17. private String name;
  18. private int count =1;
  19. private boolean flag;
  21. //生产商品
  22. public synchronizedvoid set(String name)
  23. {
  24. /*
  25. 优化前：
  26. if(flag)
  27. */
  28. //优化后
  29. while(flag)
  30. try{this.wait();}catch(Exception e){}
  31. this.name = name+"--"+count++;
  32. System.out.println(Thread.currentThread().getName()+"生产者-----"+this.name);
  33. flag = true;
  34. /*
  35. 优化前：
  36. try{this.notify();}catch(Exception e){}
  37. */
  38. //优化后：
  39. try{this.notifyAll();}catch(Exception e){}
  41. }
  43. public synchronizedvoid out()
  44. {
  45. /*
  46. 优化前：
  47. if(!flag)
  48. */
  49. //优化后
  50. while(!flag)
  51. try{this.wait();}catch(Exception e){}
  52. System.out.println(Thread.currentThread().getName()+"消费者____________"+this.name);
  53. flag = false;
  54. try{this.notify();}catch(Exception e){}
  55. }
  57. }
  58. //生产者
  59. class Producer implements Runnable
  60. {
  61. private Resource res;
  63. Producer(Resource res)
  64. {
  65. this.res = res;
  66. }
  67. public void run()
  68. {
  69. while(true)
  70. {
  71. res.set("商品");
  72. }
  73. }
  74. }
  76. //消费者
  77. class Consumer implements Runnable
  78. {
  79. private Resource con;
  81. Consumer(Resource con)
  82. {
  83. this.con = con;
  84. }
  85. public void run()
  86. {
  87. while(true)
  88. con.out();
  89. }
  90. }


但是按上面的代码操作时，会出现安全问题。这是因为当多个线程同时运行时，原来的等待唤醒机制出现局限性
因为notify在唤醒的过程中，只唤醒线程池中当前最近要执行的那个线程，如生产者t1,t2,当某一次刚好执行完t1
时，线程t2也处于唤醒状态，而t1在判断完后，刚好处于wait状态，而t2运行后，则不再判断flag的真假性，
这个是引起问题原因之一，如果把if改为while之后，因为notify就出现局限性，导致所有的线程进入等待状态。
要使程序继续执行，则需要用notifyAll方法，改动部分，如下代码：

[java] view plaincopyprint?
  1. //生产商品
  2. public synchronizedvoid set(String name)
  3. {
  4. //优化前：
  5. //if(flag)
  7. //优化后
  8. while(flag)
  9. try{this.wait();}catch(Exception e){}
  10. this.name = name+"--"+count++;
  11. System.out.println(Thread.currentThread().getName()+"生产者-----"+this.name);
  12. flag = true;
  14. //优化前：
  15. //try{this.notify();}catch(Exception e){}
  17. //优化后：
  18. try{this.notifyAll();}catch(Exception e){}
  20. }
  22. public synchronizedvoid out()
  23. {
  25. //优化前：
  26. //if(!flag)
  28. //优化后
  29. while(!flag)
  30. try{this.wait();}catch(Exception e){}
  31. System.out.println(Thread.currentThread().getName()+"消费者____________"+this.name);
  32. flag = false;
  33. try{this.notify();}catch(Exception e){}
  34. }


在这个程序中，notifyAll会同时唤醒本方和对象的线程，那是否可以直接唤醒对方的线程呢？
jdk 5.0之后，对这个问题进行了解决，出现了新的加锁解锁机制。
加锁--解锁：lock---unlock；
对象唤醒机制
condition.await();condition.signal();
将上上述代码转化为升级后的代码为：

[java] view plaincopyprint?
  2. //Jdk 1.5升级后，生产消费者问题
  4. import java.util.concurrent.locks.*;
  6. class ProductConsumerDemo2
  7. {
  8. public static void main(String[] args)
  9. {
  10. Resource r = new Resource();
  12. //创建并启动线程
  13. new Thread(new Producer(r)).start();
  14. new Thread(new Producer(r)).start();
  15. new Thread(new Consumer(r)).start();
  16. new Thread(new Consumer(r)).start();
  19. }
  20. }
  21. class Resource
  22. {
  23. private String name;
  24. private int count =1;
  25. private boolean flag;
  27. //创建使用锁对象
  28. private Lock lock = new ReentrantLock();
  29. private Condition condition_pro = lock.newCondition();
  30. private Condition condition_con = lock.newCondition();
  32. //生产商品
  33. public void set(String name)throws InterruptedException
  34. {
  35. //加锁
  36. lock.lock();
  37. try
  38. {
  39. while(flag)
  40. condition_pro.await();
  41. this.name = name+"--"+count++;
  43. System.out.println(Thread.currentThread().getName()+"生产者---"+this.name);
  44. flag = true;
  45. condition_con.signal();
  46. }
  47. finally
  48. {
  49. lock.unlock(); //解锁
  50. }
  52. }
  54. public void out()throws InterruptedException
  55. {
  56. lock.lock();
  57. try
  58. {
  59. while(!flag)
  60. condition_con.await();
  61. System.out.println(Thread.currentThread().getName()+"消费者-------------"+this.name);
  62. flag = false;
  63. condition_pro.signal();
  64. }
  65. finally
  66. {
  67. lock.unlock(); //解锁
  68. }
  69. }
  71. }
  72. //生产者
  73. class Producer implements Runnable
  74. {
  75. private Resource res;
  77. Producer(Resource res)
  78. {
  79. this.res = res;
  80. }
  81. public void run()
  82. {
  84. while(true)
  85. {
  86. try
  87. {
  88. res.set("商品");
  89. }
  90. catch (InterruptedException e)
  91. {
  92. }
  94. }
  96. }
  97. }
  99. //消费者
  100. class Consumer implements Runnable
  101. {
  102. private Resource con;
  104. Consumer(Resource con)
  105. {
  106. this.con = con;
  107. }
  108. public void run()
  109. {
  110. while(true)
  111. {
  112. try
  113. {
  114. con.out();
  115. }
  116. catch (InterruptedException e)
  117. {
  118. }
  119. }
  120. }
  121. }


jdk1.5版本以后，对锁机制的改正在于使用lock与unlock方法，使加锁解锁更直观；
同时，使用Condition接口子类的方式，在lock接口的子类中可以使用多个Condition接口子类对象，
可以使本方对象唤醒对方。而原来一个同步只能一个对象，多个对象嵌套的话，容易造成死锁。改正后就
避免了这个问题。

在上面对线程操作后，我们都是通过直接在控制台上使用ctrl+c强制结束，那到底该怎么结束运行的线程呢？
在java中只有一种方式，那就是使run中的方法运行结束。结束的关键就是控制循环条件。
如下所示：

[java] view plaincopyprint?
  1. class StopThreadDemo
  2. {
  3. public staticvoid main(String[] args)
  4. {
  5. StopThread t = new StopThread();
  7. Thread t1 = new Thread(t);
  8. Thread t2 = new Thread(t);
  10. t1.start();
  11. t2.start();
  13. int num = 0;
  15. while(true)
  16. {
  17. if(num++ == 60)
  18. {
  19. t.changeFlag();
  20. break;
  21. }
  22. System.out.println(Thread.currentThread().getName()+"………………"+num);
  23. }
  24. }
  25. }
  27. class StopThread implements Runnable
  28. {
  29. private boolean flag =true;
  31. public void run()
  32. {
  33. while(flag)
  34. System.out.println(Thread.currentThread().getName()+"………………Thread run");
  35. }
  37. public void changeFlag()
  38. {
  39. flag = false;
  40. }
  41. }


但是，还有一种情况，就是当多个运行时,如果都处于等待状态，可以使用Thread类的interrupt方法停止
等待状态，使程序继续运行。只是都会抛出异常（注意抛出异常是wait出现异常，而不是中断位置出现
异常），代码如下：

[java] view plaincopyprint?
  1. class StopThreadDemo
  2. {
  3. public staticvoid main(String[] args)
  4. {
  5. StopThread t = new StopThread();
  7. Thread t1 = new Thread(t);
  8. Thread t2 = new Thread(t);
  10. t1.start();
  11. t2.start();
  13. int num = 0;
  15. while(true)
  16. {
  17. if(num++ == 60)
  18. {
  19. //t.changeFlag();
  20. t1.interrupt();
  21. t2.interrupt();
  22. break;
  23. }
  24. System.out.println(Thread.currentThread().getName()+"………………"+num);
  25. }
  26. }
  27. }
  29. class StopThread implements Runnable
  30. {
  31. private boolean flag =true;
  33. public synchronizedvoid run()
  34. {
  35. while(flag)
  36. {
  37. try
  38. {
  39. wait();
  40. }
  41. catch (InterruptedException e)
  42. {
  43. System.out.println(Thread.currentThread().getName()+"………………Exception");
  44. flag = false;
  45. }
  46. System.out.println(Thread.currentThread().getName()+"………………Thread run");
  47. }
  48. }
  50. public void changeFlag()
  51. {
  52. flag = false;
  53. }
  54. }


另外，在多线程中还有这样的方法setDaemo()，守护线程，也可以理解为后台线程。这个线程特点是：
守护的对象结束，这些守护线程也就结束了。如我们可以把上面的interrupt或者同时也把wait取消，
只要把t1，t2，设置为主线程的守护线程，主线程结束，守护线程也就自动停止。

多线程中还有一个join方法，该方法的特点是：直接向cpu索要执行权，如果join在主线程中，那么主线程要
等待该调用join的线程结束，主线程才会执行。
toString在多线程输出有所不同，格式是线程名称，所属线程。setPriority()方法可以设置线程的优先级。
Thread还有yield方法停止当前线程，运行其他线程。

多线程总结（最优选择）：
在多线程安全问题控制方面，选择的是lock接口与Condition接口的子类对象，这样可以实现同一把锁，使用
多把锁，因此在唤醒的时候可以直接唤醒对方的线程，在一定程度上也避免了死锁等情况的发生频率。
线程的结束的话，一种方法是通过控制循环条件，让线程自己运行完结束。或者通过"线程名.interrupt()"调用
结束。
此外，还有一种是通过守护线程的形式，当被守护的线程结束，守护线程也就结束了。
如果使用join方法的话，如果在主线程中执行，则必须等调用join的线程执行完，主线程才会执行。
toString方法和setPriority（）以及yield方法也是需要注意的对象。

ubuntu 安装类型 ubuntu 安装类型
原创粉丝点击
热门IT博客
宝宝拍照换装的软件宝宝拍照换装的软件
软件学院课程网站软件学院课程网站
网络用语uc是什么意思
js九宫格拼图代码
sonarqube 80端口
日本洗面奶推荐知乎
淘宝返利平台哪个好
英雄联盟for mac国服
复读软件
茉莉兔兔淘宝
淘宝索尼旗舰店
nginx伪静态规则写法
淘宝网法院拍卖确认书
大富豪5.2.1最新源码
淘宝宝贝主图怎么修改
bulkrequest java
大道争锋 知乎
淘宝已买到宝贝提取器
我国网络犯罪原因分析
新开淘宝网店怎么装修
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 生意人会喜欢买14楼 为什么很少人买复式楼 工程师说买房不买7楼和14楼 为什么买房忌讳买14楼 买房为什么都不能买9楼 为什么买房不能买板楼 买房为什么都不买七楼 买菜歌儿歌 二手歌诗图值得买吗 歌诗图为什么买的人少 我给阎王买包烟是什么歌 买几件纯白色的vlone是什么歌 只要你乖给你买条街什么歌 富贵竹怎么水养 涉水险有必要买吗 买水 自己打蜡买水蜡还是固体蜡 富贵竹水养 被困机舱5小时还被迫自费买水 迷烟哪里买 烟网 我出去买包烟都能碰到九个 平常小超市买的女士烟 那个app能买外烟 我去买包烟都能碰上九个 慢慢买手机版 买个相公来种田完整版 平板买wifi版好还是全网通 mate30买4g版还是5g版 有锁版iphone值得买吗 怀旧服版符文布包图纸哪里买 ps4破解版值得买吗 ipad有必要买4g版吗 买蓝宝石590极光版后悔 新帝豪2019款领军版值得买吗 比亚迪秦pro燃油版值得买吗 买狗狗 买小狗 买狗狗去哪个网站 买小狗去哪个网站 买宠物去哪个网站

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