2.变量的并发访问

最新推荐文章于 2023-10-23 21:57:06 发布
最新推荐文章于 2023-10-23 21:57:06 发布
阅读量316 收藏
点赞数
分类专栏： 并发 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mylinchi/article/details/106604218
版权

前记：师夷长技以自强

1.问题背景

在上一篇文章中我们已经讨论了线程具有异步运行的特性，因此当多线程同时访问同一个实例变量时就会引发脏读的问题。而这显然不是我们愿意看到的，解决办法也很简单，就是给访问该变量的程序部分加锁。多线程并发在一些追求效率的系统中常存在变量不可见的问题，由于变量的不可见也会导致程序运行的结果不是我们想要的。一句话，同步性和可见性问题是多线程中的两大重点内容，他们分别对应于synchronized和volitle关键字的使用。本文主要围绕了在各种情况下如何使用这两个关键字而展开的。

2.synchronized同步方法

2.1方法内变量是线程安全的

ex1：

class HasSelfPrivateNum{
    public void addI(String username){
        try {
            int num = 0;
            if(username.equals("a")){
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            }else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username+" num="+num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadA extends Thread{
    private HasSelfPrivateNum numRef;

    public ThreadA(HasSelfPrivateNum numRef) {
        this.numRef = numRef;
    }

    @Override
    public void run() {
        numRef.addI("a");
    }
}

class ThreadB extends Thread{
    private HasSelfPrivateNum numRef;

    public ThreadB(HasSelfPrivateNum numRef) {
        this.numRef = numRef;
    }

    @Override
    public void run() {
        numRef.addI("b");
    }
}
public class Test{
    public static void main(String[] args) {
        HasSelfPrivateNum numRef = new HasSelfPrivateNum();
        ThreadA threadA = new ThreadA(numRef);
        threadA.start();
        ThreadB threadB = new ThreadB(numRef);
        threadB.start();
    }
}

output:
a set over!
b set over!
b num=200
a num=100
可以看到b的写覆盖对a是完全没有影响的。

2.2实例变量非线程安全

把上面的num变量改为实例变量
ex2:

class HasSelfPrivateNum{
    private int num = 0;
    public void addI(String username){
        try {
            if(username.equals("a")){
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            }else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username+" num="+num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadA extends Thread{
    private HasSelfPrivateNum numRef;

    public ThreadA(HasSelfPrivateNum numRef) {
        this.numRef = numRef;
    }

    @Override
    public void run() {
        numRef.addI("a");
    }
}

class ThreadB extends Thread{
    private HasSelfPrivateNum numRef;

    public ThreadB(HasSelfPrivateNum numRef) {
        this.numRef = numRef;
    }

    @Override
    public void run() {
        numRef.addI("b");
    }
}
public class Test{
    public static void main(String[] args) {
        HasSelfPrivateNum numRef = new HasSelfPrivateNum();
        ThreadA threadA = new ThreadA(numRef);
        threadA.start();
        ThreadB threadB = new ThreadB(numRef);
        threadB.start();
    }
}

output:
a set over!
b set over!
b num=200
a num=200
当然，解决办法也就是在addI函数前加synchronized，这里不再演示。

2.3给非静态方法加对象锁

如果同步方法属于多个对象，则每个方法属于不同的锁，因此其运行也是异步的。synchronized关键字加到static静态方法上是给Class类上锁，而synchronized关键字加到非static静态方法上是给对象上锁。
ex3：

class HasSelfPrivateNum{
    private int num = 0;
    synchronized public void addI(String username){
        try {
            if(username.equals("a")){
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            }else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username+" num="+num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadA extends Thread{
    private HasSelfPrivateNum numRef;

    public ThreadA(HasSelfPrivateNum numRef) {
        this.numRef = numRef;
    }

    @Override
    public void run() {
        numRef.addI("a");
    }
}

class ThreadB extends Thread{
    private HasSelfPrivateNum numRef;

    public ThreadB(HasSelfPrivateNum numRef) {
        this.numRef = numRef;
    }

    @Override
    public void run() {
        numRef.addI("b");
    }
}
public class Test{
    public static void main(String[] args) {
        HasSelfPrivateNum numRefA = new HasSelfPrivateNum();
        HasSelfPrivateNum numRefB = new HasSelfPrivateNum();
        ThreadA threadA = new ThreadA(numRefA);
        threadA.start();
        ThreadB threadB = new ThreadB(numRefB);
        threadB.start();
    }
}

output:
a set over!
b set over!
b num=200
a num=100
可见，addI被两个线程调用运行时都是异步交叉运行的。

2.4synchronized锁可重入

也就是说，当一个线程得到一个对象锁后，再次请求此对象时是可以再次得到该对象的锁的。因此，一个synchronized方法/块的内部调用本类的其他synchronized方法/块时，是永远可以得到锁的。
ex4:

class Service{
    synchronized public void service1(){
        System.out.println("service1");
        service2();
    }
    synchronized public void service2(){
        System.out.println("service2");
        service3();
    }
    synchronized public void service3(){
        System.out.println("service3");
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        Service service = new Service();
        service.service1();
    }
}

public class Test{
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

output:
service1
service2
service3
假如不允许锁重入，那么程序将会进入死锁。
除此之外，子类的同步函数也可以重入从父类继承的函数。如下：
ex5:

class Main {
    public int i = 10;

    synchronized public void operateIMainMethod() {
        try {
            i--;
            System.out.println("main print i=" + i);
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


class Sub extends Main {
    synchronized public void operateISubMethod() {
        try {
            while (i > 0) {
                i--;
                System.out.println("sub print i=" + i);
                Thread.sleep(100);
                this.operateIMainMethod();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        Sub sub = new Sub();
        sub.operateISubMethod();
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

2.4异常自动释放锁

线程即使获得了锁，但在运行的过程中如果遇到异常就会自动释放锁。如下：
ex6:

class Service{
    synchronized public void testMethod(){
        if(Thread.currentThread().getName().equals("a")){
            System.out.println("ThreadName = "+Thread.currentThread().getName()+" run beginTime="+ System.currentTimeMillis());
            int i = 1;
            while (i==1){
                if((""+Math.random()).substring(0,8).equals("0.123456")){
                    System.out.println("ThreadName="+Thread.currentThread().getName()+" run exceptionTime="+System.currentTimeMillis());
                    Integer.parseInt("a");
                }
            }
        }else {
            System.out.println("Thread B run Time="+System.currentTimeMillis());
        }
    }
}

class ThreadA extends Thread{
    private Service service;

    public ThreadA(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.testMethod();
    }
}

class ThreadB extends Thread{
    private Service service;

    public ThreadB(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.testMethod();
    }
}

public class Test {
    public static void main(String[] args) {
        try {
            Service service = new Service();
            ThreadA a = new ThreadA(service);
            a.setName("a");
            a.start();
            Thread.sleep(500);
            ThreadB b = new ThreadB(service);
            b.setName("b");
            b.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

output:
ThreadName = a run beginTime=1591535415742
ThreadName=a run exceptionTime=1591535416623
Exception in thread “a” Thread B run Time=1591535416624
java.lang.NumberFormatException: For input string: “a”
at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.base/java.lang.Integer.parseInt(Integer.java:652)
at java.base/java.lang.Integer.parseInt(Integer.java:770)
at Service.testMethod(Test.java:9)
at ThreadA.run(Test.java:27)
可以看到，在线程a最先获得了对象锁，但因为异常而释放锁，由线程b获得。

3.synchronized同步代码块

当同步方法执行耗时很长时，其他线程都要等待其运行完毕，因此总体的运行时间将会很长。这个时候就要同步代码块来解决了。同步代码块是作用于一个语句块而不是整个方法，同步代码块提供多线程间的互斥访问。
**synchronized（this）**以当前对象为对象监视器。
**synchronized（非this）**当一个类中有很多synchronized方法时，虽然能实现同步，但会受阻塞而影响运行效率。使用同步代码块非this对象不与其他锁this同步方法争抢this锁，可大大提高运行效率。
synchronized（非this）的三个结论：
1）.多个线程同时执行synchronized(x){}同步代码块呈同步效果。
2）当其他线程执行x对象中的synchronized同步代码块呈同步效果。
3）当其他线程执行x对象方法里面的synchronized（this）代码块时也呈同步效果。
多线程死锁
当线程相互等待对方释放锁时就会产生死锁。
ex7:

class DealThread implements Runnable{
    public String username;
    public Object lock1 = new Object();
    public Object lock2 = new Object();
    public void setFlag(String username){
        this.username = username;
    }
    @Override
    public void run() {
        if(username.equals("a")){
            synchronized (lock1){
                try{
                    System.out.println("username = "+username);
                    Thread.sleep(3000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }

                synchronized (lock2){
                    System.out.println("按lock1->lock2代码顺序执行了");
                }
            }
        }
        if(username.equals("b")){
            synchronized (lock2){
                try {
                    System.out.println("username = "+username);
                    Thread.sleep(3000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                synchronized (lock1){
                    System.out.println("按lock2->lock1代码顺序执行了");
                }
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        try {
            DealThread t1 = new DealThread();
            t1.setFlag("a");
            Thread thread1 = new Thread(t1);
            thread1.start();
            Thread.sleep(100);
            t1.setFlag("b");
            Thread thread2 = new Thread(t1);
            thread2.start();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

output:
username = a
username = b
可以看到此时程序进入了死锁状态。

4.volatile

volatile关键字是为了强制编译器从主内存中访问数据，其与synchronized的区别主要如下：
1)从性能来看volatitle更好。
2）从修饰的对象来看，volatile只能修饰于变量，而synchronized可以修饰方法以及代码块。
3）多线程访问volatile不会发生阻塞，而synchronized会，也即volatile不支持原子性。

5.总结

本文对synchronized和volatile关键字都做了讲解，volatile演示部分较少，但因为其功能简单所以略去。学过操作系统我们都知道，线程之间不仅有竞争，还有同步，那么下一篇文章讲介绍线程间的通信。
在这里插入图片描述

MyLinChi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java多线程系列(二)对象变量并发访问.docx
06-21
线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全就是不提供数据...
接口并发测试常见的并发问题
qq_24381917的博客
05-26 2469
这里写自定义目录标题接口并发测试常见的并发问题新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 接口并发测试常见的并发问题 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdow
并发访问（一）
lionway
06-16 1063
HubbleDotNet 推出一年多来，得到了大量用户的支持和使用，其中有些用户的搜索访问量较大，在使用过程中有时会因为同时并发访问过大，出现 Too many connects on server 这个错误，为了缓解这个问题，HubbleDotNet 的 V1.0.4.0 版本做了一些改进，本文将介绍这个改进即相关原理。 这篇文章写的比较早，现在解决Too many connects on
你开发的系统到底可以支撑多少并发访问？
未来大佬
05-12 2171
你开发的系统到底可以支撑多少并发访问？
Web开发中，什么级别才算是高并发
程序员闪充宝
05-07 263
点击　　免费订阅本账号！作者:边鹏_尛爺鑫原文:http://h5ip.cn/T3zX（点击阅读全文）大家心里仔细想想，当你们听到高并发网站时，心里对这个网站是个什么概念？首先想到的是淘...
Spring并发访问的线程安全性问题.docx
06-19
springmvc的controller是singleton的（非线程安全的），这也许就是他和struts2的区别吧和Struts一样，Spring的Controller默认是Singleton的，这意味着每个request过来，系统都会用原有的instance去处理，这样导致了...
c#编写的高并发数据库控制访问代码
01-21
修改内存变量需要耗时：0.001ms; 那么： 每秒最终访问的数据库的请求数量 < 1000 其他的9,900,000个请求会返回到其他页面。这就是为啥很多抢单网站有人可以访问，而有人得到繁忙中页面的原因。 微观到1ms来看，在...
线程并发时 本地变量和Lock锁的效率比较
08-13
多线程下访问公共变量时，一般lock和 启用线程本地变量 两者的效率比较。
在Vue mounted方法中使用data变量详解
01-21
如下所示： data: { certificates: null }, mounted: function () { var __this = this; __this.certificates = ...以上这篇在Vue mounted方法中使用data变量详解就是小编分享给大家的全部内容了，希望能给大
什么是并发？
weixin_55008454的博客
12-17 1415
并发就是同时访问的意思。 必须是同时访问； 在这0.1秒中有400访问。 例如：我现在有一台服务器，期间有400人访问。这叫并发量400；
【并发编程】多线程读写同一变量的并发问题（并发编程启动）
最新发布
小明的Java问道之路
10-23 1282
通过下单链路扣减库存引出了多线程并发访问共享变量的问题，接着简单介绍了一下计算机CPU内存模型、Java的内存模型，并基于Java的内存模型一步一图分析线程安全问题产生的原因。
对象及变量的并发访问
KEEP CODING
03-01 101
一个操作或者多个操作，要么全部执行并且执行过程不会被任何因素打断，要么就都不执行。
并发同时访问_实践篇（09）Redis如何应对并发访问？
weixin_29098367的博客
01-11 2305
我们在使用 Redis 时，不可避免地会遇到并发访问的问题，比如说如果多个用户同时下单，就会对缓存在 Redis 中的商品库存并发更新。一旦有了并发写操作，数据就会被修改，如果我们没有对并发写请求做好控制，就可能导致数据被改错，影响到业务的正常使用（例如库存数据错误，导致下单异常）。为了保证并发访问的正确性，Redis 提供了两种方法，分别是加锁和原子操作。看上去好像是一种很好的方案，但是，其实这...
学习Java多年 却回答不出面试官Java 并发模型？教你一网打尽
weixin_49723683的博客
12-02 2404
前言 本篇文章我们来探讨一下并发设计模型。 可以使用不同的并发模型来实现并发系统，并发模型说的是系统中的线程如何协作完成并发任务。不同的并发模型以不同的方式拆分任务，线程可以以不同的方式进行通信和协作。 并发模型和分布式系统很相似 并发模型其实和分布式系统模型非常相似，在并发模型中是线程彼此进行通信，而在分布式系统模型中是进程彼此进行通信。然而本质上，进程和线程也非常相似。这也就是为什么并发模型和分布式模型非常相似的原因。 分布式系统通常要比并发系统面临更多的挑战和问题比如进程通信、网络可能出..
Java并发编程(03)：多线程并发访问，同步控制
【积累】，是一个长期持续的过程。
03-29 493
多线程学习的时候，要面对的第一个复杂问题就是，并发模式下变量的访问，如果不理清楚内在流程和原因，经常会出现这样一个问题线程处理后的变量值不是自己想要的，可能还会一脸懵的说这不合逻辑吧？...
第二章：对象及变量的并发访问
weixin_42198596的博客
12-29 332
第二章1.synchronized在字节码指令中的原理 1.synchronized在字节码指令中的原理 方法中的变量不存在非线程安全的问题，永远都是线程安全的，这是因为方法内部的变量具有私有特性。
使用共享变量实现并发
wymyimeng的博客
07-15 498
竞态 竞态是指在多个 goroutine 按某些交错顺序执行时程序无法给出正确的结果。 一种避免数据竞态的方法是避免从多个 goroutine 访问同一个变量。由于其他 goroutine 无法直接访问相关变量，因此它们就必须使用通道来向受阻 goroutine 发送查询请求或者更新变量。这也是 Go 箴言的含义：不用通过共享内存来通信，而应该通过通信来共享内存。 另一种避免数据竞态的方法是允许多...
Cookie 的并发访问 编写
06-02
要实现 Cookie 的并发访问，可以使用多线程技术来实现。具体步骤如下： 1. 定义一个 Cookie 对象，用于存储 Cookie 信息。 2. 定义一个共享变量，用于存储所有的 Cookie 对象。 3. 创建多个线程，每个线程都可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值