多线程下的数据安全

最新推荐文章于 2024-09-22 11:46:40 发布
最新推荐文章于 2024-09-22 11:46:40 发布
阅读量1k 收藏 1
点赞数
分类专栏： 多线程 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39736103/article/details/89173351
版权

前言

  多线程下的线程安全，主要是由于无法控制线程的执行顺序，无法确定那个线程是先执行，是由CPU确定的，出现线程不安全的情况-》每次运行的结构都不相同（程序无法按照我们想要的结果）

下面是一个简单的多线程例子，来说明下多线程下的数据安全

   

package com.el.jichu.thread.writerlock;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Auther: roman.zhang
 * @Date: 2019/4/10 8:44
 * @Version:V1.0
 * @Description:LockDemo1
 */
public class LockDemo1 {
   // private AtomicInteger atomicInteger=new AtomicInteger(0);
    private int i=0;

    public void add(){
        i++;
       //atomicInteger.getAndIncrement();
    }

    public static void main(String[] args) throws InterruptedException {
        LockDemo1 demo1 = new LockDemo1();
        for(int i=0;i<2;i++){
            new Thread(()->{
                for(int j=0;j<10000;j++){
                    demo1.add();
                }
            }).start();
        }

        Thread.sleep(3000);

       // System.out.println("计算结果是："+demo1.atomicInteger);
        System.out.println("计算结果是："+demo1.i);
    }

}

每次运行结果：

   第一次：11783

   第二次：12670

上面之所以出现这种情况，是多线程下，无法控制线程间的执行顺序，无法确定在执行完一个线程后（即完成一个整体操作后，再去执行另一个线程）。

  解决方式

    1.使用AtomicInterger 下面是AtomicInterger相关的类

   

直接上代码：

  

package com.el.jichu.thread.writerlock;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Auther: roman.zhang
 * @Date: 2019/4/10 8:44
 * @Version:V1.0
 * @Description:LockDemo1
 */
public class LockDemo1 {
    private AtomicInteger atomicInteger=new AtomicInteger(0);
    //private int i=0;

    public void add(){
        //i++;
       atomicInteger.getAndIncrement();
    }

    public static void main(String[] args) throws InterruptedException {
        LockDemo1 demo1 = new LockDemo1();
        for(int i=0;i<2;i++){
            new Thread(()->{
                for(int j=0;j<10000;j++){
                    demo1.add();
                }
            }).start();
        }

        Thread.sleep(3000);

        System.out.println("计算结果是："+demo1.atomicInteger);
        //System.out.println("计算结果是："+demo1.i);
    }

}

使用AtomicInter就能保证每次得到我们想要的结果

2.使用synchronized这个方式，不在介绍，介绍一个功能更多的Lock

直接上代码：

   

package com.el.jichu.thread.writerlock;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Auther: roman.zhang
 * @Date: 2019/4/10 8:44
 * @Version:V1.0
 * @Description:LockDemo1
 */
public class LockDemo1 {
    //private AtomicInteger atomicInteger=new AtomicInteger(0);
    private int i=0;
    private Lock lock=new ReentrantLock();
    public  void add(){
        lock.lock();
        try {
            i++;
        } finally {
            lock.unlock();
        }
        //i++;
       //atomicInteger.getAndIncrement();
    }

    public static void main(String[] args) throws InterruptedException {
        LockDemo1 demo1 = new LockDemo1();
        for(int i=0;i<2;i++){
            new Thread(()->{
                for(int j=0;j<10000;j++){
                    demo1.add();
                }
            }).start();
        }

        Thread.sleep(3000);

       // System.out.println("计算结果是："+demo1.atomicInteger);
        System.out.println("计算结果是："+demo1.i);
    }

}

下面介绍下AtomicInteger的原理（CAS）

   CAS （硬件语言） 即每个线程从内存中拿到值（称为当前值），以及想把内存值改为的目标值，每次去更新内存值时，都会将当前值与内存值比较，如果相同，则把内存值变为目标值。

使用CAS方式实现线程同步

package com.el.jichu.thread.writerlock;

import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Auther: roman.zhang
 * @Date: 2019/4/10 8:44
 * @Version:V1.0
 * @Description:LockDemo1
 */
public class LockDemo1 {
    //private AtomicInteger atomicInteger=new AtomicInteger(0);
    private int i=0;
    private Lock lock=new ReentrantLock();

    static Unsafe unsafe=null;
    private static  long valueOffset;
    static {
        //反射
        try {
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            unsafe= (Unsafe) theUnsafe.get(null);
            //目标：通过unsafe去调用底层硬件原语
            //无法直接操作内存，委屈求全，只能去通过对象中属性的偏移量，去修改值
            valueOffset = unsafe.objectFieldOffset(LockDemo1.class.getDeclaredField("i"));
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    public  void add(){
        ///使用CAS去实现同步
        //为什么是个循环：因为CAS会失败，因此才会使用循环
        int current ;
        do{
            current=unsafe.getIntVolatile(this,valueOffset);
        }while(!unsafe.compareAndSwapInt(this,valueOffset,current,current+1));
        /**
         * unsafe.compareAndSwapInt(当前对象，内存值，当前值，新值)
         */
       /* lock.lock();
        try {
            i++;
        } finally {
            lock.unlock();
        }*/
        //i++;
       //atomicInteger.getAndIncrement();
    }

    public static void main(String[] args) throws InterruptedException {
        LockDemo1 demo1 = new LockDemo1();
        for(int i=0;i<2;i++){
            new Thread(()->{
                for(int j=0;j<10000;j++){
                    demo1.add();
                }
            }).start();
        }

        Thread.sleep(3000);

       // System.out.println("计算结果是："+demo1.atomicInteger);
        System.out.println("计算结果是："+demo1.i);
    }

}

  AtomicXXX源码：

  

 

3.使用自定义锁，实现线程同步

   手写锁代码

 

package com.el.jichu.thread.writerlock;

import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;

/**
 * @Auther: roman.zhang
 * @Date: 2019/4/10 10:32
 * @Version:V1.0
 * @Description:CustomLock
 *    思路
 *       1.没有获取锁的线程，如何让线程挂起，不在往下执行，等待其他线程释放锁。
 *       2.释放锁之后，如何通知其他线程去获取锁
 */
public class CustomLock implements Lock {
    //锁的拥有者
    AtomicReference<Thread> owner=new AtomicReference<>();

    //一个容器存储等待的线程
    ConcurrentHashMap<Thread,Object> queue=new ConcurrentHashMap<>();

    @Override
    public void lock() {
       while( !owner.compareAndSet(null,Thread.currentThread())){
           //没有获取成功，则将该线程停下来
           queue.put(Thread.currentThread(),"");
           //正在运行的线程进入停车场
           LockSupport.park();
           queue.remove(Thread.currentThread());
       }

    }
    @Override
    public void unlock() {
          while(owner.compareAndSet(Thread.currentThread(),null)){//释放锁
              //通知其他线程去park线程，继续去强锁
            //  Thread next=null;
              ConcurrentHashMap.KeySetView<Thread, Object> threads = queue.keySet();
              for(Thread t:threads){
                  LockSupport.unpark(t);
              }
          }
    }



    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock() {
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }



    @Override
    public Condition newCondition() {
        return null;
    }
}

测试代码

 

package com.el.jichu.thread.writerlock;

import java.util.concurrent.locks.Lock;

/**
 * @Auther: roman.zhang
 * @Date: 2019/4/10 15:15
 * @Version:V1.0
 * @Description:LockDomo2
 */
public class LockDomo2 {
    private  int i;
    //private AtomicInteger atomicInteger=new AtomicInteger(0);
    private Lock customLock=new CustomLock();
    public  void add(){
        customLock.lock();
        try {
            i++;

        } finally {
            customLock.unlock();
        }
        //atomicInteger.getAndIncrement();
    }

    public static void main(String[] args) throws InterruptedException {
        LockDomo2 demo2 = new LockDomo2();
        for(int i=0;i<2;i++){
            new Thread(()->{
                for(int j=0;j<10000;j++){
                    demo2.add();
                }
            }).start();
        }

        Thread.sleep(3000);

        // System.out.println("计算结果是："+demo1.atomicInteger);
        System.out.println("计算结果是："+demo2.i);
    }

}

 

Java之多线程并发环境下的数据安全问题
gaohanjie123的博客
04-19 1103
一 什么是多线程环境下的数据安全问题 多线程环境下的数据安全问题需要满足三个条件 多线程并发 多个线程有共享数据 被共享的数据有修改的行为 二 多线程环境下数据安全的重要性 以后在实际的开发中，我们的项目都是运行在服务器上，而服务器已经将线程的定义、线程对象的创建、线程的启动等都已经实现完了。这些代码我们不需要编写。 最重要的是我们需要知道，我们编写的程序要放到一个多线程的环境下运行，...
多线程怎么保证数据安全_这8种保证线程安全的技术你都知道吗？
weixin_39912303的博客
11-20 1449
并发情况下如何保证数据安全，一直都是开发人员每天都要面对的问题，稍不注意就会出现数据异常，造成不可挽回的结果。笔者根据自己的实际开发经验，总结了下面几种保证数据安全的技术手段：无状态不可变安全的发布volatilesynchronizedlockcasthreadlocal一.无状态我们都知道只有多个线程访问公共资源的时候，才可能出现数据安全问题，那么如果我们没有公共资源，是不是就没有这...
多线程的安全问题
weixin_30381793的博客
11-22 662
1、多线程安全问题分析 　　多线程安全问题原因是在cpu执行多线程时，在执行的过程中可能随时切换到其他的线程上执行。 　　 　　在以上红色选中的三个部分，线程都有可能进行切换。只要cpu在这个三个地中的任何地方切换了，都可能导致错误数据出现，线程的不安全因素就有了。 　　造成错误数据的原因是多个线程可能出现同时访问num的情况。而任何一个线程在访问num的过程中都可以切换到其他的线程...
JAVA：多线程与数据安全
最新发布
2401_87298532的博客
09-22 931
一、进程概论​ 进程就是指正在运行的程序的实例。当我们打开任务管理器的时候，在进程这一栏我们可以看到当前运行的所有进程,这些被我们称为进程。并且进程是系统进行资源分配和调用的独立单位，在任务管理器中我们可以看到每一个进程都有它自己的CPU占用程度、内存使用成都和对磁盘、网络的使用程度。二、线程概论而线程则是进程中的单个顺序的控制六，是一条执行路径。线程又可以分为和**单线程：**一个进程如果只有一个执行路径，则成为单线程程序**多线程：**一个进程如果有多个执行路径，那么成为多线程程序。
多线程数据安全
臻实
06-04 153
多线程数据安全问题
多线程下的数据安全 问题
qq_32783703的博客
02-07 240
多线程下的数据安全 问题 在unix下如果不加锁使用全局变量会产生数据安全问题，比如，不安全的做法 #include &lt;unistd.h&gt; #include &lt;stdio.h&gt; #include &lt;net/if.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #include &lt;strop...
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
C#多线程处理多个队列数据的方法
09-03
6. **线程安全**: 示例中没有特别处理线程同步问题，这意味着在多线程环境下，队列操作可能会有竞态条件的风险。在实际应用中，可能需要使用锁定机制（如Mutex、Monitor或lock关键字）来确保线程安全，防止数据竞争...
mybaits 多线程 实现数据批量插入 （运用CountDownLatch实现闭锁）
10-12
总结来说，MyBatis结合多线程和CountDownLatch闭锁实现数据批量插入是一种高效且安全的方法。它不仅能显著提升数据处理速度，还能有效防止并发问题，是处理大数据量场景下的明智选择。在实际开发中，可以根据具体...
这8种保证线程安全的技术你都知道吗？
HollisChuang's Blog
10-17 702
并发情况下如何保证数据安全，一直都是开发人员每天都要面对的问题，稍不注意就会出现数据异常，造成不可挽回的结果。笔者根据自己的实际开发经验，总结了下面几种保证数据安全的技术手段：无状态不可...
实现Runnable解决多线程数据安全问题
xlecho的博客
08-08 1851
xl_echo编辑整理，欢迎转载，转载请声明文章来源。更多IT、编程案例、资料请联系QQ：1280023003，加群298140694。百战不败，依不自称常胜，百败不颓，依能奋力前行。——这才是真正的堪称强大！！ 之前的文章我们讲到了，四个电影院窗口同时出售50张彩票的问题。在实现的过程中，我们使用Tread继承，达到了需求的效果，但是也提出了一部分问题。这里我们先使用Runnable...
多线程数据安全问题
qq_36276066的博客
04-08 567
多线程的好处：cpu利用效率高，可以缩短程序执行时间，提高程序执行效率和性能。 如何解决多线程下的数据共享（安全）问题？ 主要用到synchronized对象同步锁机制。 一般来说，我们都是通过Runnable去实现多线程。如果我们不使用同步锁，那么在对共享数据进行操作时就会出现：当第1个线程想操作A状态的数据时，发现已经被第二个线程修改为了B状态，于是无法完成本想完成的任务。比如售票，假如...
【多线程】多线程安全，为什么不安全，要怎么做保证其安全，实例
代码的魅力，根本走不出来
01-24 1600
多线程安全是指在多线程环境下，对共享的数据进行操作时，保证这些操作能够正确、稳定地执行，不会导致数据不一致、异常等问题。多线程不安全通常是因为多个线程同时访问、修改了共享的数据，导致一些不可预料的结果。
多线程数据安全问题与三种解决方式
go_pkqL00的博客
03-16 1131
1，多线程数据安全问题引入 多线程可以提高程序的使用率，也可以提高cpu的使用使用率，同时也会带来一些弊端，比如： 数据安全问题 今天我们就先说一下多线程会产生什么样的数据安全问题；在讲之前，我们需要明确： cpu执行的操作是原子性的，是不可拆分的 这里说的数据安全针对的数据是多个线程共享的数据，所以我们会使用在第一部分中说的方式2来实现多线程 由此，我...
ThreadLocal在多线程下保证数据安全
qq_38621978的博客
07-10 1250
1）ThreadLocal是干什么的 多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，一般在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。ThreadLocal是除了加锁这种同步方式之外的另一种保证多线程访问变量时的线程安全的方法；如果每个线程对变量的访问都是基于线程自己的变量这样就不会存在线程不安全问题。 在Java的多线程编程中，为保证多个线程对共享变量的安全访问，通常会使用synchronized来保证同一时刻只有一个线程对共
最新c# 高级编程-多线程安全_c# 多线程 数据安全
2401_84264662的博客
05-04 1007
还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！【完整版领取方式在文末！！
VC环境下多线程高速数据采集系统设计
1. **数据缓冲区管理**：在多线程环境下，数据从采集线程传递到处理线程时，需要借助缓冲区来暂存数据，防止数据丢失或冲突。 2. **同步机制**：使用信号量、互斥量等同步工具，确保不同线程之间的安全操作，避免...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值