文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

Java并发编程(03):多线程并发访问,同步控制

2023-06-02 11:23

关注

本文源码:GitHub·点这里 || GitEE·点这里

一、并发问题

多线程学习的时候,要面对的第一个复杂问题就是,并发模式下变量的访问,如果不理清楚内在流程和原因,经常会出现这样一个问题:线程处理后的变量值不是自己想要的,可能还会一脸懵的说:这不合逻辑吧?

1、成员变量访问

多个线程访问类的成员变量,可能会带来各种问题。

public class AccessVar01 {    public static void main(String[] args) {        Var01Test var01Test = new Var01Test() ;        VarThread01A varThread01A = new VarThread01A(var01Test) ;        varThread01A.start();        VarThread01B varThread01B = new VarThread01B(var01Test) ;        varThread01B.start();    }}class VarThread01A extends Thread {    Var01Test var01Test = new Var01Test() ;    public VarThread01A (Var01Test var01Test){        this.var01Test = var01Test ;    }    @Override    public void run() {        var01Test.addNum(50);    }}class VarThread01B extends Thread {    Var01Test var01Test = new Var01Test() ;    public VarThread01B (Var01Test var01Test){        this.var01Test = var01Test ;    }    @Override    public void run() {        var01Test.addNum(10);    }}class Var01Test {    private Integer num = 0 ;    public void addNum (Integer var){        try {            if (var == 50){                num = num + 50 ;                Thread.sleep(3000);            } else {                num = num + var ;            }            System.out.println("var="+var+";num="+num);        } catch (Exception e){            e.printStackTrace();        }    }}

这里案例的流程就是并发下运算一个成员变量,程序的本意是:var=50,得到num=50,可输出的实际结果是:

var=10;num=60var=50;num=60

VarThread01A线程处理中进入休眠,休眠时num已经被线程VarThread01B进行一次加10的运算,这就是多线程并发访问导致的结果。

2、方法私有变量

修改上述的代码逻辑,把num变量置于方法内,作为私有的方法变量。

class Var01Test {    // private Integer num = 0 ;    public void addNum (Integer var){        Integer num = 0 ;        try {            if (var == 50){                num = num + 50 ;                Thread.sleep(3000);            } else {                num = num + var ;            }            System.out.println("var="+var+";num="+num);        } catch (Exception e){            e.printStackTrace();        }    }}

方法内部的变量是私有的,且和当前执行方法的线程绑定,不会存在线程间干扰问题。

二、同步控制

1、Synchronized关键字

使用方式:修饰方法,或者以控制同步块的形式,保证多个线程并发下,同一时刻只有一个线程进入方法中,或者同步代码块中,从而使线程安全的访问和处理变量。如果修饰的是静态方法,作用的是这个类的所有对象。

独占锁属于悲观锁一类,synchronized就是一种独占锁,假设处于最坏的情况,只有一个线程执行,阻塞其他线程,如果并发高,处理耗时长,会导致多个线程挂起,等待持有锁的线程释放锁。

2、修饰方法

这个案例和第一个案例原理上是一样的,不过这里虽然在修改值的地方加入的同步控制,但是又挖了一个坑,在读取的时候没有限制,这个现象俗称脏读。

public class AccessVar02 {    public static void main(String[] args) {        Var02Test var02Test = new Var02Test ();        VarThread02A varThread02A = new VarThread02A(var02Test) ;        varThread02A.start();        VarThread02B varThread02B = new VarThread02B(var02Test) ;        varThread02B.start();        var02Test.readValue();    }}class VarThread02A extends Thread {    Var02Test var02Test = new Var02Test ();    public VarThread02A (Var02Test var02Test){        this.var02Test = var02Test ;    }    @Override    public void run() {        var02Test.change("my","name");    }}class VarThread02B extends Thread {    Var02Test var02Test = new Var02Test ();    public VarThread02B (Var02Test var02Test){        this.var02Test = var02Test ;    }    @Override    public void run() {        var02Test.change("you","age");    }}class Var02Test {    public String key = "cicada" ;    public String value = "smile" ;    public synchronized void change (String key,String value){        try {            this.key = key ;            Thread.sleep(2000);            this.value = value ;            System.out.println("key="+key+";value="+value);        } catch (InterruptedException e) {            e.printStackTrace();        }    }    public void readValue (){        System.out.println("读取:key="+key+";value="+value);    }}

在线程中,逻辑上已经修改了,只是没执行到,但是在main线程中读取的value毫无意义,需要在读取方法上也加入同步的线程控制。

3、同步控制逻辑

同步控制实现是基于Object的监视器。

  • 线程对Object的访问,首先要先获得Object的监视器 ;
  • 如果获取成功,则会独占该对象 ;
  • 其他线程会掉进同步队列,线程状态变为阻塞 ;
  • 等Object的持有线程释放锁,会唤醒队列中等待的线程,尝试重启获取对象监视器;

4、修饰代码块

说明一点,代码块包含方法中的全部逻辑,锁定的粒度和修饰方法是一样的,就写在方法上吧。同步代码块一个很核心的目的,减小锁定资源的粒度,就如同表锁和行级锁。

public class AccessVar03 {    public static void main(String[] args) {        Var03Test var03Test1 = new Var03Test() ;        Thread thread1 = new Thread(var03Test1) ;        thread1.start();        Thread thread2 = new Thread(var03Test1) ;        thread2.start();        Thread thread3 = new Thread(var03Test1) ;        thread3.start();    }}class Var03Test implements Runnable {    private Integer count = 0 ;    public void countAdd() {        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        synchronized(this) {            count++ ;            System.out.println("count="+count);        }    }    @Override    public void run() {        countAdd() ;    }}

这里就是锁定count处理这个动作的核心代码逻辑,不允许并发处理。

5、修饰静态方法

静态方法属于类层级的方法,对象是不可以直接调用的。但是synchronized修饰的静态方法锁定的是这个类的所有对象。

public class AccessVar04 {    public static void main(String[] args) {        Var04Test var04Test1 = new Var04Test() ;        Thread thread1 = new Thread(var04Test1) ;        thread1.start();        Var04Test var04Test2 = new Var04Test() ;        Thread thread2 = new Thread(var04Test2) ;        thread2.start();    }}class Var04Test implements Runnable {    private static Integer count ;    public Var04Test (){        count = 0 ;    }    public synchronized static void countAdd() {        System.out.println(Thread.currentThread().getName()+";count="+(count++));    }    @Override    public void run() {        countAdd() ;    }}

如果不是使用同步控制,从逻辑和感觉上,输出的结果应该如下:

Thread-0;count=0Thread-1;count=0

加入同步控制之后,实际测试输出结果:

Thread-0;count=0Thread-1;count=1

6、注意事项

  • 继承中子类覆盖父类方法,synchronized关键字特性不能继承传递,必须显式声明;
  • 构造方法上不能使用synchronized关键字,构造方法中支持同步代码块;
  • 接口中方法,抽象方法也不支持synchronized关键字 ;

三、Volatile关键字

1、基本描述

Java内存模型中,为了提升性能,线程会在自己的工作内存中拷贝要访问的变量的副本。这样就会出现同一个变量在某个时刻,在一个线程的环境中的值可能与另外一个线程环境中的值,出现不一致的情况。

使用volatile修饰成员变量,不能修饰方法,即标识该线程在访问这个变量时需要从共享内存中获取,对该变量的修改,也需要同步刷新到共享内存中,保证了变量对所有线程的可见性。

2、使用案例

class Var05Test {    private volatile boolean myFlag = true ;    public void setFlag (boolean myFlag){        this.myFlag = myFlag ;    }    public void method() {        while (myFlag){            try {                System.out.println(Thread.currentThread().getName()+myFlag);                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}

3、注意事项

  • 可见性只能确保每次读取的是最新的值,但不支持变量操作的原子性;
  • volatile并不会阻塞线程方法,但是同步控制会阻塞;
  • Java同步控制的根本:保证并发下资源的原子性和可见性;

四、源代码地址

GitHub·地址https://github.com/cicadasmile/java-base-parentGitEE·地址https://gitee.com/cicadasmile/java-base-parent

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 资料下载
  • 历年真题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯