多线程下的数据安全

其他 2019-04-11 03:18:04 阅读次数: 0

前言

  多线程下的线程安全，主要是由于无法控制线程的执行顺序，无法确定那个线程是先执行，是由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);
    }

}

猜你喜欢

转载自blog.csdn.net/qq_39736103/article/details/89173351
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022