多线程安全

已于 2022-04-09 15:21:31 修改
阅读量499 收藏 2
点赞数 1
文章标签： java 多线程
于 2021-07-20 23:52:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43374578/article/details/118937099
版权

一、线程不安全

1. 共享变量

  • 多个线程对共享变量的并发修改，导致结果并不像预期中那样
package com.nike.erick.d03;

public class Demo01 {
    private static int number = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread firstThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100000; i++) {
                    number++;
                }
            }
        });

        Thread secondThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100000; i++) {
                    number--;
                }
            }
        });

        firstThread.start();
        secondThread.start();

        firstThread.join();
        secondThread.join();

        System.out.println("number: " + number);
    }
}

2. 原因

2.1 字节码指令

  • 线程拥有自己的工作栈内存，读数据时会从主内存中拿，写完后会将数据写回主存
  • i++在实际执行的时候，是一系列指令，一系列指令就会导致指令交错

在这里插入图片描述

2.2 指令交错

  • 指令交错存在于多线程之间
  • 线程上下文切换，引发不同线程内指令交错，最终导致上述操作结果不会为0

在这里插入图片描述

2.3 概念

  • 线程不安全： 只会存在于多个线程共享的资源
  • 临界区： 对共享资源的多线程读写操作的代码块
  • 竞态条件： 多个线程在在临界区内，由于代码的指令交错，对共享变量资源的争抢
多线程  读    共享资源  没问题
多线程  读写  共享资源  可能线程不安全(指令交错)

二、synchronized

  • 一种阻塞式解决线程安全问题的方案，包含几种不同的写法

1. 同步代码块

1.1 基本语法

  • 对象锁，只要为同一个对象，为任意对象(除基本类型）
- synchronized： 一种阻塞式的，用来解决多线程访问共享资源引发的不安全的解决方案
- synchronized： 可在不同代码粒度进行控制
- synchronized： 保证了《临界区代码的原子性(字节码)》，不会因为线程的上下文切换而被打断
- synchronized： 必须保证对对同一个对象加锁(Integer.value(0))

package com.nike.erick.d03;

public class Demo01 {
    private static int number = 0;

    /*任何对象都可以，只要保证是引用类型*/
    private static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        /*粗粒度的锁
          细粒度的锁：也可以加在每个for循环中*/
        Thread firstThread = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    for (int i = 0; i < 100000; i++) {
                        number++;
                    }
                }
            }
        });

        Thread secondThread = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    for (int i = 0; i < 100000; i++) {
                        number--;
                    }
                }
            }
        });

        firstThread.start();
        secondThread.start();

        firstThread.join();
        secondThread.join();

        System.out.println("number: " + number);
    }
}

1. 2. 原理

1. a线程获取锁，执行代码
2. 其他线程这个时候要进入，无法获取锁资源，就会被block，进入  《等待队列》
   同时进入上下文切换
   
3. a线程执行完毕后，释放锁资源。唤醒其他线程，进行cpu的争夺

在这里插入图片描述

1.3 面向对象改进

package com.nike.erick.d03;

public class Demo03 {
    private static Room room = new Room();

    public static void main(String[] args) throws InterruptedException {

        Thread firstThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    room.decrement();
                }
            }
        });

        Thread secondThread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    room.increment();
                }
            }
        });

        firstThread.start();
        secondThread.start();
        firstThread.join();
        secondThread.join();

        System.out.println("result:" + room.getValue());
    }
}

class Room {
    private int counter;

    // 锁对象是当前对象
    public void increment() {
        synchronized (this) {
            counter++;
        }
    }

    public void decrement() {
        synchronized (this) {
            counter--;
        }
    }

    public int getValue() {
        synchronized (this) {
            return counter;
        }
    }
}

2. 同步方法

2.1 成员方法

  • 同步成员方法和同步代码块效果一样，必须保证同步代码块的锁对象是this对象
  • 可能锁粒度不太一样
  • 同步方法的锁对象是this，即当前对象
@Data
class Calculator {
    private int number;

    public void incr() {
        synchronized (this) {
            for (int i = 0; i < 10000; i++) {
                number++;
            }
        }
    }
    // 同步方法
    public synchronized void decr() {
        for (int i = 0; i < 10000; i++) {
            number--;
        }
    }
}

2.2 静态成员方法

  • 锁对象：锁用的是类的字节码对象: Calculator.class
@Data
class Calculator {
    private static int number;

    public int getNumber() {
        return number;
    }

    public static void incr() {
        for (int i = 0; i < 10000; i++) {
            synchronized (Calculator.class) {
                number++;
            }
        }
    }

    public static synchronized void decr() {
        for (int i = 0; i < 10000; i++) {
            number--;
        }
    }
}

3. 锁对象

  • 同步代码块，必须保证用的锁是同一个对象，但是不能为基本数据类型
  • 同步成员方法的锁对象是this
  • 同步静态成员方法的锁对象是当前类的字节码对象 .class
  • 如果多个线程对共享变量读写，但是部分线程没有加锁保护，依然线程不安全

三、线程安全场景

1. 成员变量/静态变量

1. 没被多线程共享：        则线程安全
2. 被多线程共享：
     2.1 如果只读，   则线程安全
     2.2 如果有读写， 则可能发生线程不安全问题

2. 局部变量

2.1 线程安全

每个线程的方法都会创建单独的栈内存，局部变量保存在自己当前方法的栈桢内
局部变量线程私有

1. 局部变量是基础数据类型时： 是线程安全的
2. 但局部变量是应用类型时：   可能不安全
  2.1 如果该对象没有逃离方法的作用访问，则线程安全
  2.2 如果该对象逃离方法的作用范围，则可能线程不安全 《引用逃离》

在这里插入图片描述

2.2 引用逃离

  • 如果一个类不是final类，那么就可能被继承
  • 被继承的时候发生方法覆盖，覆盖方法如果创建新的线程，就可能发生局部变量不安全
// 安全
package com.nike.erick.d01;

import java.util.ArrayList;
import java.util.List;

public class Demo05 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        SafeCounter safeCounter = new SafeCounter();
        safeCounter.operation(list);
        System.out.println(list);
    }
}

class SafeCounter {
    public void operation(List<String> list) {
        for (int i = 0; i < 10000; i++) {
            addElement(list);
            deleteElement(list);
        }
    }

    public void addElement(List<String> list) {
        list.add("HELLO");
    }

    public void deleteElement(List<String> list) {
        list.remove(0); // 移除元素
    }
}

package com.nike.erick.d01;

import java.util.ArrayList;
import java.util.List;

public class Demo05 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        UnsafeCounter unsafeCounter = new UnsafeCounter();
        unsafeCounter.operation(list);
        System.out.println(list);
    }
}

class SafeCounter {
    public void operation(List<String> list) {
        for (int i = 0; i < 10000; i++) {
            addElement(list);
            deleteElement(list);
        }
    }

    public void addElement(List<String> list) {
        list.add("HELLO");
    }

    public void deleteElement(List<String> list) {
        list.remove(0); // 移除元素
    }
}

class UnsafeCounter extends SafeCounter {
    @Override
    public void deleteElement(List<String> list) {
        /*开启了新的线程来改变*/
        // index out of bound
        // 相当于把删除的操作延迟或提前了
        new Thread(() -> list.remove(0)).start();
    }
}
  • 避免线程安全类变为不安全类： 不要让一个类的方法被重写
  • 具体做法：final修饰禁止继承，或对可能引起安全的方法加private

3. 线程安全类

3.1 JDK

  • 多个线程同时调用他们同一个实例的方法时，线程安全
  • 线程安全类中的方法的组合，不一定线程安全
- String
- Integer
- StringBuffer
- Random
- Vector
- Hashtable
- java.util.concurrent包下的类

package com.nike.erick.d03;

import java.util.Hashtable;
import java.util.concurrent.TimeUnit;

public class Demo04 {

    /*共享资源*/
    private static Hashtable<String, String> hashtable = new Hashtable<>();

    public static void main(String[] args) throws InterruptedException {

        Thread firstThread = new Thread(() -> combinedMethod(hashtable));

        Thread secondThread = new Thread(() -> combinedMethod(hashtable));

        firstThread.start();
        secondThread.start();
        firstThread.join();
        secondThread.join();
        System.out.println(hashtable.size());
    }

    // 方法的组合不是 线程安全的
    // 如果要线程安全，必须将组合方法也设置成 synchronized
    public static void combinedMethod(Hashtable<String, String> hashtable) {
        if (null == hashtable.get("name")) {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            hashtable.put("name", "erick");
            System.out.println(Thread.currentThread().getName());
            hashtable.put(Thread.currentThread().getName(), "00");
        }
    }
}

在这里插入图片描述

3.2 不可变类

  • 类中属性都是final，不能修改
  • 如 String，Integer
#  实现线程安全类的问题
- 无共享变量
- 共享变量不可变
- synchronized互斥修饰
飞翔荷兰号
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程(四）：线程安全
Kaiii的博客
05-09 926
多线程(四）：线程安全观察线程安全和线程不安全观察线程安全观察线程不安全线程安全概念导致线程不安全的原因 观察线程安全和线程不安全 观察线程安全 单线程是线程安全的，示例代码如下： public class ThreadDemo25 { static class Counter { //定义私有变量 private int num = 0; //定义任务执行次数 private final int maxSize = 100000;
多线程的线程安全
qq_40686180的博客
07-29 353
多线程的线程安全 多线程下线程的不安全的表现主要是:一个线程在对共享资源进行修改时，另一个线程也对此资源进行修改，扰乱了这个线程的修改；导致无法得到预期的结果。 出现线程不安全的原因 1.线程的非原子性操作 导致的问题:使线程正在操作的数据被其他线程再次操作。 非原子性操作和原子性操作： a.原子性(atomic)操作：指一个操作是不可分割和中断 b.非原子性操作:与原子性操作正好相反，指一个操作被分割和中断成多个部分。如inc++指令就被分割成三个部分。 2.缓存的不一致 导致的问题:使线程无法得到最新的
java-多线程安全-锁
刘望的博客
01-16 218
一 同步函数 1.1 一般的方法 同步的另一种体现形式：同步函数。 同步函数使用的锁是哪个？经过分析：大概猜的是this，因为函数必须被对象调用。 验证：写一个同步代码块，写一个同步函数，如果同步代码块中的锁对象和同步函数中的锁对象是同一个，就同步了，就没有错误的数据了。如果不是同一个锁对象，就不同步出现错误数据。 让两个线程，一个线程在同步代码块中执行，一个线程在同步函数中执...
Java多线程安全问题和锁
01-20
多线程安全问题和锁 文章目录多线程安全问题和锁线程在jvm中的特点锁的出现synchronized 关键字-监视器锁monitor lock死锁的产生和避免 什么是线程安全问题？ 当多个线程同时操作同一个数据是，可能会出现数据不一样...
易语言实现多线程安全Hook
05-27
该模块包含了小量编程时常用的函数集：。取变量栈指针、A2W、W2A，Call（任意数量参数，内部会维护栈平衡），取函数真实地址（可为Naked函数，需自己维护栈平衡），以及部分堆函数;...Tags：多线程安全Hook。
ArrayList源码和多线程安全问题分析
08-25
主要介绍了ArrayList源码和多线程安全问题，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，下面小编和大家一起来学习一下吧
Java多线程安全集合
03-17
Java的多种多线程安全集合的介绍和示例代码
java多线程安全性基础介绍.pptx
07-25
java多线程安全性基础介绍 线程安全 正确性 什么是线程安全性 原子性 竞态条件 i++ 读i ++ 值写回i 可见性 JMM 由于cpu和内存加载速度的差距，在两者之间增加了多级缓存导致，内存并不能直接对cpu可见。 ...
多线程线程安全
lipengzhong
12-03 132
这里是引用 12333555448845525
多线程-线程安全
FiveCode的博客
09-23 226
什么是线程安全？ 无论遇到怎么样的多个线程访问某对象或某方法的情况，不需要额外做任何的处理。程序也可以正常的运行，不会有因为多线程而出错，因此称为线程安全。 线程不安全：get同时set、额外同步。 全都线程安全？ 运行速度、设计成本、tradeoff 什么时候会出现线程安全问题 ...
多线程——线程安全
Sun_of_Rainy的博客
01-28 232
1、什么是线程安全问题? 答：当多个线程共享同一个全局变量，对这个变量同时进行写操作时，可能会受到其他线程的干扰，这种现象叫做线程安全问题。做读操作的时候，不会产生线程安全问题 2、当多个线程共享同一个局部变量时，会发生线程安全吗？答案是，不会 3、模拟两个窗口同时卖票，也就是两个线程公用同一个全局变量y，可是这样写就出问题了哦（虽然我一开始也是这么写的，尴尬又不失礼貌的微笑） 原因如下：...
多线程的安全性
qq_36361573的博客
03-17 767
多线程的安全性
多线程之线程安全
wang0907的博客
06-16 419
本文一起看下线程安全相关内容。
多线程——保证线程安全
小叮当不懒的博客
09-09 7927
目录多线程——保证线程安全含义如何保证线程安全具体方法volatile关键字保证可见性禁止重排序synchronized关键字保证原子性防止死锁原因后果检查死锁解决方法 不积跬步，无以至千里；不积小流，无以成江海。要沉下心来，诗和远方的路费真的很贵！ 多线程——保证线程安全 含义 线程安全：指在多线程对一个共享资源同时进行操作的时候，所得到的结果每次都是一样的。 如何保证线程安全 方法：要保证线程安全，就必须保证线程同步。保证线程的可见性，有序性和原子性。 线程同步 线程同步的含义和字面意义相反。同步
hashmap多线程安全问题
最新发布
09-24
在多线程环境下，HashMap是不安全的，可能会导致...为了解决HashMap的多线程安全问题，可以使用ConcurrentHashMap。ConcurrentHashMap使用了锁分段技术，在不同的段上进行操作，从而实现了更好的并发性能和线程安全。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值