java线程深度解析(二)——线程互斥技术与线程间通信

2024-09-09 03:48

本文主要是介绍java线程深度解析(二)——线程互斥技术与线程间通信,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

http://blog.csdn.net/daybreak1209/article/details/51307679


     在java多线程——线程同步问题中,对于多线程下程序启动时出现的线程安全问题的背景和初步解决方案已经有了详细的介绍。本文将再度深入解析对线程代码块和方法的同步控制和多线程间通信的实例。

一、再现多线程下安全问题

先看开启两条线程,分别按序打印字符串的实验

1、创建一个Output内部类,并给出根据参数name,循环打印出传入字符串

2、new 两个线程,分别传入zhongailing、max两个name,调用同一个output对象的output方法

[html]  view plain copy
在CODE上查看代码片 派生到我的代码片
  1.     public static void main(String[] args) throws InterruptedException {  
  2.                 Output output=new Output();    
  3.         new Thread(new Runnable(){   
  4.              @Override  
  5.             public void run() {  
  6.                  while(true)  
  7.                  {  
  8.                      try {  
  9.                         Thread.sleep(1000);//休息1s  
  10.                     } catch (InterruptedException e) {  
  11.                         e.printStackTrace();  
  12.                     }  
  13.                      output.output("zhongailing");  
  14.                  }  
  15.                   
  16.             }  
  17.          }).start();  
  18.           
  19.         new Thread(new Runnable(){  
  20.              @Override  
  21.             public void run() {  
  22.                  while(true)  
  23.                  {  
  24.                      try {  
  25.                         Thread.sleep(1000);//休息1s  
  26.                     } catch (InterruptedException e) {  
  27.                         e.printStackTrace();  
  28.                     }  
  29.                      output.output("max");  
  30.                  }  
  31.                   
  32.             }  
  33.          }).start();  
  34.     }  
  35. //内部类  
  36. class Output  
  37.     {  
  38.         public void output(String name)  
  39.         {  
  40.             for(int i=0;i<name.length();i++)  
  41.             synchronized (name)  
  42.             {  
  43.                 System.out.print(name.charAt(i));  
  44.             }  
  45.             System.out.println();  
  46.         }  
  47.     }  
摘取部分输入结果如下:

[html]  view plain copy
在CODE上查看代码片 派生到我的代码片
  1. zhonmaxgailing  
  2. max  
  3. zhongailing  
  4. zhongailing  
  5. max  
  6. mazhongax  
  7. iling  
  8. max  
  9. zhongailing  
  10. zhonmgax  
  11. ailing  
  12. mzhax  
  13. ongailing  
  14. zmhaoxngailing  
  15. max  
  16. zhongailing  
      可以看出,打印出来的name名除了zhongailing 和max之外,还出现iling、mzhax之类字样,这是肿么回事?

     这是因为两条线程同时调用同一个output对象的output方法,当第一个线程的打印循环还未走完时,下一个线程又进入传入另一个参数继续循环,使得打印出的结果出现iling、mzhax这些非正常字样。


二、解决线程安全问题——设置线程互斥
     在java多线程——线程同步问题中已经介绍了使用synchronized关键字对代码块或者整个方法体进行设置,使得该段代码享有排他性,独立占用资源,完成打印循环之后,下个线程再进入。

[html]  view plain copy
在CODE上查看代码片 派生到我的代码片
  1. class Output  
  2. {  
  3.     public void output(String name)  
  4.     {  
  5.         for(int i=0;i<name.length();i++)  
  6.         synchronized (this)   //代码块同步,指定加锁对象为this,指向当前传入的output  
  7.         {  
  8.             System.out.print(name.charAt(i));  
  9.         }  
  10.         System.out.println();  
  11.     }  
  12.       
  13.     public synchronized void output2(String name) //在方法体上执行synchronized,把整个方法都保护起来。  
  14.     {  
  15.         for(int i=0;i<name.length();i++)  
  16.         {  
  17.             System.out.print(name.charAt(i));  
  18.         }  
  19.         System.out.println();  
  20.     }  

     题外话:客户端使用main方法进行调用时:

[html]  view plain copy
在CODE上查看代码片 派生到我的代码片
  1. public static void main(String[] args) throws InterruptedException {  
  2.         Output output=new Output();    
  3.         new Thread(new Runnable(){  
  4.              @Override  
  5.             public void run() {  
  6.                  while(true)  
  7.                  {  
  8.                      try {  
  9.                         Thread.sleep(1000);//休息1s  
  10.                     } catch (InterruptedException e) {  
  11.                         e.printStackTrace();  
  12.                     }  
  13.                      output.output("zhongailing");//内部类不能访问局部变量??  
  14.                  }  
  15.                   
  16.             }  
  17.          }).start();  
  18.     }  
      在new 内部类 Output是报错,这是因为在静态方法中不能实例化内部类。因为内部类的特点就是可以访问外部类的成员变量,又因为对象创建完了才为成员变量分配空间,所以在使用变量之前,这个类已经实例化了。而静态方法执行时,可以不用创建这个对象就使用而矛盾。并且main这个静态方法在运行时没有使用任何外部类的成员变量,所以要创建内部类的实例对象,必须已经存在外部类的实例对象来创建。代码改造为:

[html]  view plain copy
在CODE上查看代码片 派生到我的代码片
  1. public static void main(String[] args) throws InterruptedException {  
  2.     new SynchronizationApp().init();  
  3. }  
  4.   
  5. public void init()//初始化-调用这个非静态方法时,一定是某个类已经被实例化了,该方法才能被调用。  
  6. {  
  7.     Output output=new Output();    
  8.     new Thread(new Runnable(){//线程0  
  9.          @Override  
  10.         public void run() {  
  11.              while(true)  
  12.              {  
  13.                  try {  
  14.                     Thread.sleep(1000);//休息1s  
  15.                 } catch (InterruptedException e) {  
  16.                     e.printStackTrace();  
  17.                 }  
  18.                  output.output("zhongailing");  
  19.              }  
  20.               
  21.         }  
  22.      }).start();  
  23.       
  24.     new Thread(new Runnable(){//线程1  
  25.          @Override  
  26.         public void run() {  
  27.              while(true)  
  28.              {  
  29.                  try {  
  30.                     Thread.sleep(1000);//休息1s  
  31.                 } catch (InterruptedException e) {  
  32.                     e.printStackTrace();  
  33.                 }  
  34.                  output.output("max");  
  35.              }            
  36.         }  
  37.      }).start();  
  38. }  
  39. //内部类,用于循环字母,挨个输出传入的name字符。  
  40. class Output  
  41. {  
  42.     public void output(String name)  
  43.     {  
  44.         for(int i=0;i<name.length();i++)  
  45.         synchronized (this)    //或者在方法上加同步关键字  
  46.         {  
  47.             System.out.print(name.charAt(i));  
  48.         }  
  49.         System.out.println();  
  50.     }  
  51. }}  
使用synchronized需谨慎:

1、对于多个线程的执行对象一定是同一个。例如这里new 同一个Output对象,执行方法,只是方法传入的参数不同。这个应该比较好理解,如果你为当前线程加上互斥方案,但多个线程启用的并不是同一个对象,那无论做多少不同步方案都是无用功,因为压根就没在一个对象中进行多线程处理。

2、该关键字在一段代码里一般只使用一次。打个比方,如果将方法和方法内部的代码块同时加上synchronized关键字,就类似于原本只有一把锁,钥匙给了方法,而代码块也需要这把钥匙开锁执行自己的代码,双方谁也不释放,容易产生死锁问题。


三、多线程间通信

一个实例:两条线程-主线程、子线程,要求子线程先执行10次,主线程再执行100次,整体反复执行50次。

代码思路:

1、首先两条线程互斥,各不影响

2、创建标识,让子线程先执行,主线程等待;当子线程执行完第一个10次循环,改变标识,唤醒主线程执行。

[html]  view plain copy
在CODE上查看代码片 派生到我的代码片
  1. package it.synchronization;  
  2.   
  3. public class ThreadCommunication {   
  4.     public static void main(String[] args) {  
  5.         new ThreadCommunication().init();   
  6.     }  
  7.     public void init()  
  8.     {  
  9.         innerBusiness inner=new innerBusiness();  
  10.         new Thread(new Runnable(){   //线程1  
  11.             @Override  
  12.             public void run() {  
  13.                 for(int i=1;i<=50;i++) //再循环50次  
  14.                 {  
  15.                     try {  
  16.                         inner.sub(i);  
  17.                     } catch (InterruptedException e) {  
  18.                         // TODO Auto-generated catch block  
  19.                         e.printStackTrace();  
  20.                     }  
  21.                 }                             
  22.             }             
  23.         }).start();  
  24.           
  25.           
  26.         new Thread(new Runnable(){//线程2  
  27.             @Override  
  28.             public void run() {  
  29.                 for(int i=1;i<=50;i++)  
  30.                 {  
  31.                 /*synchronized (ThreadCommunication.class) {//多组线程呢,这个范围有点太大。如果该类中有多个线程组,这种方式就会出问题。           
  32.                 }*/  
  33.                     try {  
  34.                         inner.main(i);  
  35.                     } catch (InterruptedException e) {  
  36.                         // TODO Auto-generated catch block  
  37.                         e.printStackTrace();  
  38.                     }     
  39.                 }  
  40.   
  41.             }  
  42.         }).start();  
  43.     }  
  44.     class innerBusiness //创建内部类  
  45.     {  
  46.         private boolean bShouldSub=true;//约定sub线程先执行  
  47.         public synchronized void  sub(int i) throws InterruptedException  
  48.         {  
  49.             if(!bShouldSub)//如果没到子线程执行,子线程wait  
  50.             {  
  51.                 this.wait();  
  52.             }  
  53.             for(int j=1;j<=10;j++)  
  54.             {  
  55.                 System.out.println("子线程运行第"+j+"次");  
  56.             }  
  57.             bShouldSub=false;  
  58.             this.notify();//唤醒等待线程-main  
  59.         }  
  60.           
  61.         public synchronized void main(int i) throws InterruptedException  
  62.         {  
  63.             if(bShouldSub)//如果该子线程执行,主线程wait  
  64.             {  
  65.                 this.wait();  
  66.             }  
  67.             for(int j=0;j<100;j++)  
  68.             {  
  69.                 System.out.println("主线程运行第"+j+"次");  
  70.             }  
  71.             bShouldSub=true;  
  72.             this.notify();//唤醒等待线程-sub  
  73.         }  
  74.     }  
  75. }  
亮点:

           将互斥约束到线程资源上,而非线程代码块中将两条线程代码写到一个innerclass中,在方法上进行同步约束和线程执行等待逻辑操作,而不是直接在main方法new Thread时,对代码块进行互斥。这样无论谁调用线程逻辑,直接调用innerclass(资源的)的sub 和main方法就可满足线程安全要求,更符合面向对象的思想。同时免去了对同对象参数的考虑。


四、总结

一)synchronized是Java语言级别内置的同步机制,根据作用的对象分为:类锁、实例锁;

对于类锁的应用:只能应用到类的静态方法上,形如:staticsynchronized method();

对于实例锁应用:

1、非静态方法:synchronized method();

2、代码块:synchronized{}或synchronized(this){}

3、指定实例:synchronized(Object obj);

      非静态方法和代码块使用synchronized的实质都一样,对当前所属类的实例枷锁。而指定实例是对括号里传入的obj对象加锁。如同上面的例子,使用的就是代码块和指定实例对象加锁方式。另外synchronized不能被直接继承。

      笔者体会而言, 对于多线程中synchronized的使用,除了它的作用范围定在类上、方法上、对象、代码块这些point之外,还需要注意加锁的对象是否是同一个。例如上面例子如果不加this,哪怕使用了synchronized对于线程安全还是无法保障的。因为线程调用同一对象的output方法,琐是加了,but并未作用于该对象上。

二)多线程间通信wait,notify方法的合理使用,也是线程的重要部分。本文仅提供了一个线程间通信的实例,在接下来的博文将详细介绍线程间通信应用。


这篇关于java线程深度解析(二)——线程互斥技术与线程间通信的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1150076

相关文章

网页解析 lxml 库--实战

lxml库使用流程 lxml 是 Python 的第三方解析库,完全使用 Python 语言编写,它对 XPath表达式提供了良好的支 持,因此能够了高效地解析 HTML/XML 文档。本节讲解如何通过 lxml 库解析 HTML 文档。 pip install lxml lxm| 库提供了一个 etree 模块,该模块专门用来解析 HTML/XML 文档,下面来介绍一下 lxml 库

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时,有没有考虑过 JVM 是如何把静态的字节码(byte code)转化为运行时对象的呢,这个问题看似简单,但清楚的同学相信也不会太多,这篇文章首先介绍 JVM 类初始化的机制,然后给出几个易出错的实例来分析,帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段,分别是:loading 、Linking、initialization

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权,允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true (Spring security默认会带有ROLE_前缀),去

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程,特意画了如下的类图,包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口,接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类,它们之间的依赖,构建起了整个框架。想要理解整个架构,最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文(security context)的信息。当前操作的用户是谁,该用户是否已经被认证,他拥有哪些角色权限…这些都被保

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明(认真看哦) AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证,则会调用 #attemptAuthentica

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门(一):登录与退出》 《Spring-Security-入门(二):基于数据库验证》 《Spring-Security-入门(三):密码加密》 《Spring-Security-入门(四):自定义-Filter》 《Spring-Security-入门(五):在 Sprin

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来,一站式有声阅读平台听书系统 🌟&nbsp;开篇:遇见未来,从“智听”开始 在这个快节奏的时代,你是否渴望在忙碌的间隙,找到一片属于自己的宁静角落?是否梦想着能随时随地,沉浸在知识的海洋,或是故事的奇幻世界里?今天,就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统,它正悄悄改变着我们的阅读方式,让未来触手可及! 📚&nbsp;第一站:海量资源,应有尽有 走进“智听