线程安全

最新推荐文章于 2022-04-13 17:17:53 发布
最新推荐文章于 2022-04-13 17:17:53 发布
阅读量61 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45630711/article/details/114884765
版权
线程安全概念

如果多线程环境下运行的结果符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的

线程不安全
  • 举例
    在这里插入图片描述

客户端检查还有1张票，将票卖出，还没有执行更新数据库，客户端B检查了票数发现大于0于是又卖了一次票然后A将票数更新到数据库这就出现了同一张票卖了两次

  • 原子性

提供互斥访问同一时刻只能有一个线程对数据进行操作
(多行指令(一行代码可能会分解为多条指令执行)，如果指令前后有依赖关系，不能插入影响我执行结果的指令，如果能狗插入就是没有原子性不能插入就是有原子性)

举例:n++有三条指令操作

  1. 从内存把数据读到CPU
  2. 进行数据更新
  3. 把数据写会到CPU

举例:我们把一段代码想象成一个房间，每个线程就是要进入这个房间的人。如果没有任何机制保证，A进入房间之后，还
没有出来；B 是不是也可以进入房间，打断 A 在房间里的隐私。这个就是不具备原子性的。
给房间加一把锁，A 进去就把门锁上，其他人是不是就进不来了。这样
就保证了这段代码的原子性了。
有时也把这个现象叫做同步互斥，表示操作是互相排斥的。

  • 可见性

一个主内存的线程被修改可以及时被其他线程观察到
(主内存:线程共享；工作内存:线程私有内存+CPU高速缓存/寄存器；主存共享数据的操作：从主存读取到工作内存，工作内存修改，然后写回主存)

举例:为了提高效率，JVM在执行过程中，会尽可能的将数据在工作内存中执行，但这样会造成一个问题，共享变量在多线
程之间不能及时看到改变，这个就是可见性问题。

  • 有序性

如果两个线程不能从happens-before原则观察出来。那么就不能观察他们的有序性，虚拟机可以随意对他们进行重排序，导致其观察结果杂乱无序

happens-before原则

重排序:

代码是这样的：

  1. 去前台取下 U 盘
  2. 去教室写 10 分钟作业
  3. 去前台取下快递
    如果是在单线程情况下，JVM、CPU指令集会对其进行优化，比如，按 1->3->2的方式执行，也是没问题，可以少跑一次前台。这种叫做指令重排序

代码重排序会给多线程带来什么问题

刚才那个例子中，单线程情况是没问题的，优化是正确的，但在多线程场景下就有问题了，什么问题呢。可能快递是
在你写作业的10分钟内被另一个线程放过来的，或者被人变过了，如果指令重排序了，代码就会是错误的。

线程不安全讲解
public class Test4 {
    private static int COUNT = 0;
    public static void main(String[] args) throws InterruptedException {
    //有一个变量COUNT=0;同时启动20个线程，每个线程循环1000次，每次循环COUNT++
    //等着20个子线程执行完毕之后，在main线程打印COUNT（预期20000）
            Thread[] threads = new Thread[20];
            for(int i=0; i<20; i++){
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0; j<1000; j++){
                            COUNT++;
                        }
                    }
                });
            }
            for(Thread t : threads){
                t.start();
            }
            //让main线程阻塞等待所有的20个子线程执行完毕
            for(Thread t : threads){
                t.join();
            }

            System.out.println(COUNT);
        }
}

预期是20000
实际：小于20000

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

线程不安全解决

synchronized关键字: 同步锁或重量级锁(JAVA SE1.6之后胡引入l偏向锁和轻量级锁)，具有可重入性

作用： 对某段代码加锁，让某段代码满足原子性，可见性有序性
synchronized的原子性，有序性，可见性

原理: 多个线程间同步互斥(一段代码在任意一个时间点只有一个线程执行:加锁，释放锁)

锁的对象不同分为对象锁和类锁

  • 对象锁:
    1. 对于普通的同步方法锁的就是当前实例的对象
    2. 对于同步方法块，如果synchronized括号里配置的是类的实例对象,则锁的是配置的对象
  • 类锁:(class 对象锁)
    1. 对于静态同步方法,锁的是当前类
    2. 对于同步方法块，如果synchronized括号里配置的是类的Class对象，则锁的是当前类
public class Test4 {
    private static int COUNT = 0;
    public static void main(String[] args) throws InterruptedException {
    //有一个变量COUNT=0;同时启动20个线程，每个线程循环1000次，每次循环COUNT++
    //等着20个子线程执行完毕之后，在main线程打印COUNT（预期20000）
            Thread[] threads = new Thread[20];
            for(int i=0; i<20; i++){
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0; j<1000; j++){
                                //加锁后结果就是20000
                                synchronized (Test4.class){
                                    COUNT++;
                                }

                        }
                    }
                });
            }
            for(Thread t : threads){
                t.start();
            }
            //让main线程阻塞等待所有的20个子线程执行完毕
            for(Thread t : threads){
                t.join();
            }

            System.out.println(COUNT);
        }
}

synchronized加锁后20个线程同步互斥执行，有一个线程加锁执行时，剩余19个线程处于阻塞状态，当前运行线程执行完毕后解锁，剩余线程竞争抢占执行。

synchronized只有对同一个对象加锁才会产生同步互斥的作用
可重入性:同一个对象可以对同一个对象锁多次申请，基于重入计数器来实现

  • synchronized 传入类对象-类名.class获取类对象
public class Test4 {
    private static int COUNT = 0;
    public static void main(String[] args) throws InterruptedException {
    //有一个变量COUNT=0;同时启动20个线程，每个线程循环1000次，每次循环COUNT++
    //等着20个子线程执行完毕之后，在main线程打印COUNT（预期20000）
        Class clazz=Test4.class;
            Thread[] threads = new Thread[20];
            for(int i=0; i<20; i++){
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0; j<1000; j++){
                                //加锁后结果就是20000
                                synchronized (clazz){
                                    COUNT++;
                                }

                        }
                    }
                });
            }
            for(Thread t : threads){
                t.start();
            }
            //让main线程阻塞等待所有的20个子线程执行完毕
            for(Thread t : threads){
                t.join();
            }

            System.out.println(COUNT);
        }
}
  • synchronized方法传入实例对象
public class Test4 {
    private static int COUNT = 0;

    public static void main(String[] args) throws InterruptedException {
    //有一个变量COUNT=0;同时启动20个线程，每个线程循环1000次，每次循环COUNT++
    //等着20个子线程执行完毕之后，在main线程打印COUNT（预期20000）
            Class clazz=Test4.class;
            Test4 st=new Test4();
            Thread[] threads = new Thread[20];
            for(int i=0; i<20; i++){
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0; j<1000; j++){
                           synchronized (st){
                               COUNT++;
                           }

                        }
                    }
                });
            }
            for(Thread t : threads){
                t.start();
            }
            //让main线程阻塞等待所有的20个子线程执行完毕
            for(Thread t : threads){
                t.join();
            }

            System.out.println(COUNT);
        }
}
  • 静态同步方法
public class Test4 {
    private static int COUNT = 0;

    //静态同步方法
    public synchronized static void decrement(){
        COUNT++;
    }
    public static void main(String[] args) throws InterruptedException {
    //有一个变量COUNT=0;同时启动20个线程，每个线程循环1000次，每次循环COUNT++
    //等着20个子线程执行完毕之后，在main线程打印COUNT（预期20000）
        Class clazz=Test4.class;
            Thread[] threads = new Thread[20];
            for(int i=0; i<20; i++){
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0; j<1000; j++){
                            //静态同步方法
                            decrement();

                        }
                    }
                });
            }
            for(Thread t : threads){
                t.start();
            }
            //让main线程阻塞等待所有的20个子线程执行完毕
            for(Thread t : threads){
                t.join();
            }

            System.out.println(COUNT);
        }
}
  • 实例同步方法
public class Test4 {
    private static int COUNT = 0;

    //实例同步方法
    public synchronized  void decrement(){
        COUNT++;
    }
    public static void main(String[] args) throws InterruptedException {
    //有一个变量COUNT=0;同时启动20个线程，每个线程循环1000次，每次循环COUNT++
    //等着20个子线程执行完毕之后，在main线程打印COUNT（预期20000）
            Class clazz=Test4.class;
            Test4 st=new Test4();
            Thread[] threads = new Thread[20];
            for(int i=0; i<20; i++){
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0; j<1000; j++){
                            //静态同步方法
                            st.decrement();

                        }
                    }
                });
            }
            for(Thread t : threads){
                t.start();
            }
            //让main线程阻塞等待所有的20个子线程执行完毕
            for(Thread t : threads){
                t.join();
            }

            System.out.println(COUNT);
        }
}
  • 拆分写法同理-sychronized必须锁同一对象才能实现同步互斥
  1. 一部分加锁一部分未加锁
public class Test4 {
    private static int COUNT = 0;

    public static void main(String[] args) throws InterruptedException {
    //有一个变量COUNT=0;同时启动20个线程，每个线程循环1000次，每次循环COUNT++
    //等着20个子线程执行完毕之后，在main线程打印COUNT（预期20000）
            Class clazz=Test4.class;
            Test4 st=new Test4();
            Thread[] threads = new Thread[20];
            for(int i=0; i<19; i++){
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0; j<1000; j++){
                           synchronized (st){
                               COUNT++;
                           }
                        }
                    }
                });
            }
            for(int i=0; i<1; i++){
                threads[19+i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0; j<1000; j++){
                                COUNT++;
                        }
                    }
                });
            }
            for(Thread t : threads){
                t.start();
            }
            //让main线程阻塞等待所有的20个子线程执行完毕
            for(Thread t : threads){
                t.join();
            }

            System.out.println(COUNT);
        }
}
  1. 加锁同一对象
public class Test4 {
    private static int COUNT = 0;

    public static void main(String[] args) throws InterruptedException {
    //有一个变量COUNT=0;同时启动20个线程，每个线程循环1000次，每次循环COUNT++
    //等着20个子线程执行完毕之后，在main线程打印COUNT（预期20000）
            Class clazz=Test4.class;
            Test4 st=new Test4();
            Thread[] threads = new Thread[20];
            for(int i=0; i<19; i++){
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0; j<1000; j++){
                           synchronized (st){
                               COUNT++;
                           }
                        }
                    }
                });
            }
            for(int i=0; i<1; i++){
                threads[19+i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0; j<1000; j++){
                            synchronized (st){
                                COUNT++;
                            }
                        }
                    }
                });
            }
            for(Thread t : threads){
                t.start();
            }
            //让main线程阻塞等待所有的20个子线程执行完毕
            for(Thread t : threads){
                t.join();
            }

            System.out.println(COUNT);
        }
}
  1. 加锁不同对象
public class Test4 {
    private static int COUNT = 0;

    public static void main(String[] args) throws InterruptedException {
    //有一个变量COUNT=0;同时启动20个线程，每个线程循环1000次，每次循环COUNT++
    //等着20个子线程执行完毕之后，在main线程打印COUNT（预期20000）
            Class clazz=Test4.class;
            Test4 st=new Test4();
            Thread[] threads = new Thread[20];
            for(int i=0; i<19; i++){
                threads[i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0; j<1000; j++){
                           synchronized (st){
                               COUNT++;
                           }
                        }
                    }
                });
            }
            for(int i=0; i<1; i++){
                threads[19+i] = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0; j<1000; j++){
                            synchronized (clazz){
                                COUNT++;
                            }
                        }
                    }
                });
            }
            for(Thread t : threads){
                t.start();
            }
            //让main线程阻塞等待所有的20个子线程执行完毕
            for(Thread t : threads){
                t.join();
            }

            System.out.println(COUNT);
        }
}

synchronized对象锁之间的关系

  • Class t=Test.class
  • Test t1=new Test()
  • Test t2=new Test()

在这里插入图片描述

synchronized流程图

在这里插入图片描述

无名小飛猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程安全分析
weixin_54794309的博客
01-29 2721
在通过例子分析线程安全之前先 看了解这些 知识 在去看例子会清晰一点 Java有三大变量 静态变量:在方法区。 实例变量：在堆当中 局部变量:在栈中。 以上三大变量中: 局部变量永远都不会存在线程安全问题。 因为局部变量不共享。(一个线程一个栈。) 局部变量在栈中。所以局部变量永远都不会共享。 实例变量在堆中,堆只有1个。 静态变量在方法区中,方法区只有1个. 堆和方法区都是多线程共享的，所以可能存在线程安全问题。 局部变量+常量:不会有线程安全问题。
深入理解线程安全与Singleton
09-05
线程安全是多线程编程中的一个重要概念，它关乎程序在并发执行时的正确性和稳定性。线程安全问题通常出现在共享资源的访问中，当多个线程同时访问和修改同一块内存区域时，如果没有合适的同步机制，就可能出现数据不...
Vector线程安全
xuxin132133的博客
03-01 2035
Vector是线程安全的，因为Vector好多方法是sychornized关键字修饰的，比如addElement方法： Public syschronized void addElement(E obj){ modCount++; ensureCapatityHelper(elementCount+1); elementData[elementCount++]=obj;...
Java之线程安全问题浅析
ldcaws的专栏
04-13 3068
在java开发中确保线程安全已成为基本要求，线程安全就是指某段代码在多线程环境下能够正确的执行，不会出现数据不一致的情况，反之就是非线程安全。 目前解决线程安全的方式有： 线程安全类，如AtomicInteger 加锁排队执行，如synchronized、reentrantLock 线程本地变量，如ThreadLocal 场景分析：创建一个变量num等于0，然后创建线程1，执行1000000次++操作，然后在创建线程2执行1000000次–操作，等线程1和2都执行完之后，打印num变量值，若结果为0，则说
C# 线程安全
菜鸟厚非
09-16 2万+
System.Collections.Concurrent 命名空间下提供多个线程安全集合类，只要多个线程同时访问集合，就应使用这些类来代替 System.Collections 和 System.Collections.Generic 命名空间中的相应类型。 但是，不保证通过扩展方法或通过显式接口实现访问集合对象是线程安全的，可能需要由调用方进行同步。.........
集合线程安全
Source
04-08 3876
集合线程安全 常用的集合类型如ArrayList，HashMap，HashSet等，在并发环境下修改操作都是线程不安全的，会抛出java.util.ConcurrentModificationException异常，这节主要记录如何在并发环境下安全地修改集合数据。 List 举个ArrayList线程不安全的例子： public class CollectionTest { public static void main(String[] args) { List<Strin
Java 基础 —— 线程安全
IT__learning的博客
10-31 8937
一、线程安全问题 线程安全 当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的 一个程序在运行起来的时候会转换成进程，通常含有多个线程。通常情况下，一个进程中的比较耗时的操作（如长循环、文件上传下载、网络资源获取等），往往会采用多线程来解决。又比如实际生活中，银行取钱问题、火车票多个售票窗口的问题，通常会涉及到并发的问题，从而需要多线程的技术。 当进程中
三种线程安全的List
热门推荐
weixin_45668482的博客
05-30 9万+
在单线程开发环境中，我们经常使用ArrayList作容器来存储我们的数据，但它不是线程安全的，在多线程环境中使用它可能会出现意想不到的结果。 多线程中的ArrayList： 我们可以从一段代码了解并发环境下使用ArrayList的情况： public class ConcurrentArrayList { public static void main(String[] args) throws InterruptedException { List<Integer> l
Vector的线程安全问题
小小本科生
11-04 7536
首先提一个问题，Vector是线程安全的吗？ 很多人都会回答：vector是线程安全的。 确实，通过查看JDK源码中，Vector确实是线程安全的，至少Vector的作者是这么说的。 通过观察源码，发现 Vector 类中的大部分方法都是由 synchronized 关键字来修饰的，这也就保证了所有的对外接口都会以 Vector 对象为锁。访问 Vector 的任何方法都必须获得对象的 intrinsic lock (或叫 monitor lock )，所以在Vector内部，所有的方法都不会被多线
Java线程安全
qq_40132294的博客
10-10 2万+
前段时间有测试一个后端对账单和话单采集服务,在测试过程中有涉及到数据库读写逻辑和并发的场景,所以结合经验针对系统技术架构设计了部分并发场景结合数据库读写时可能出现的一些问题的用例,也确实出现了一些测试环境容易忽视,线上环境确确实实可能出现的问题,当然最后还是得到了妥善的解决.下面说说后端测试应该考虑的一些线程安全和数据读写方面的问题. 前提:测试环境的架构尽量向线上环境的架构靠拢,比如线上如果采用分布式集群,测试环境如果是单机,那么部分问题自然无法暴露,如果测试环境无足够资源模拟线上的几十台集群环境,那么
java枚举是如何保证线程安全的
08-25
Java枚举类型自Java SE5引入以来，成为了保证线程安全的一种强大工具。在Java中，枚举是一种特殊的类，由编译器自动处理并确保其线程安全性。以下是关于Java枚举线程安全的详细解释。 首先，枚举类型在Java中实际上...
C++日志库-线程安全
04-28
线程安全的日志库在多线程环境下尤为重要，因为不正确的日志操作可能会导致数据竞争和同步问题。本文将详细讨论如何在C++中实现一个基于Win32接口的线程安全日志库，并关注其核心概念和技术。 首先，我们需要理解...
某大型集团管控制度流程.docx
08-17
某大型集团管控制度流程.docx
普华永道-HR数字化-人力资源管理新逻辑.pdf
最新发布
08-17
普华永道-HR数字化-人力资源管理新逻辑.pdf
包装标贴机_机械3D图可修改打包下载.zip
08-17
包装标贴机_机械3D图可修改打包下载.zip
开发资料技术资料USB接口通信(驱动)的设计与实现非常好的技术资料.zip
08-17
开发资料技术资料USB接口通信(驱动)的设计与实现非常好的技术资料.zip
苹果电子产品用的贴标机_机械3D图可修改打包下载.zip
08-17
苹果电子产品用的贴标机_机械3D图可修改打包下载.zip
C#线程安全容器实现深度解析
"本文将深入探讨线程安全容器的实现方法，主要以C#语言为例，结合实际开发经验和Microsoft的源码分析，介绍如何构建线程安全的集合，如ArrayList和线程安全的泛型队列及字典。" 线程安全容器在多线程编程中扮演着至...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值