线程安全问题2

最新推荐文章于 2023-12-26 13:30:25 发布
最新推荐文章于 2023-12-26 13:30:25 发布
阅读量111 收藏
点赞数
分类专栏： JAVA 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40707269/article/details/119718356
版权
JAVA 同时被 2 个专栏收录
87 篇文章 2 订阅
订阅专栏
笔记
60 篇文章 0 订阅
订阅专栏

为了结局数据原子性问题
我们引入基于CAS机制的
在这里插入图片描述
原子变量类，来进行保证共享数据的原子性。

package org.example.testjul;


import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;

//设计一个计数器，所有的系统中的线程访问了系统之后，都可以用
public class Indicator {

    private static final Indicator INSTANCE = new Indicator();//定义一个私有的本类静态对象

    public static Indicator getINSTANCE() {
        return INSTANCE;
    }

    private Indicator(){


    }

    private final AtomicLong requestCount  = new AtomicLong(0);//请求总数
    private final AtomicLong successCount = new AtomicLong(0);//请求成功
    private final AtomicLong fialureCount = new AtomicLong(0);//请求失败

    //处理成功情况，处理成功的加加
     public void requestProcess(){
        requestCount.incrementAndGet();//相当于增加
    }

    //
    public void successCount(){
         successCount.incrementAndGet();
    }

    public void failureCount(){
         //统计失败的请求总数
        fialureCount.incrementAndGet();
    }

    public long getRequestCount(){
         return requestCount.get();
    }

    public long getSuccessCount(){
         return successCount.get();
    }

    public long getFialureCount(){
         return fialureCount.get();
    }




}

使用方法进行介绍。

在这里插入图片描述
API使用。

关于乐观锁和悲观锁

独占锁是一种悲观锁，而 synchronized 就是一种独占锁，synchronized 会导致其它所有未持有锁的线程阻塞，而等待持有锁的线程释放锁。

     **所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果更新数据之前，验证一下，有没有冲入，如果因为冲突失败就重试，直到成功为止。而乐观锁用到的机制就是CAS。**

LOCK锁
在这里插入图片描述

可重入性锁
已经获得了锁对象，再次请求时候还是能获得锁。
、在这里插入图片描述

相当于我拿着一把锁进了两个们，这种感觉
说白了，就是被同一把锁锁住的们，我都可以进去，我拿着锁都可以进去。

可以发现没发生死锁，可以多次获取相同的锁

可重入锁有

synchronized
ReentrantLock
使用ReentrantLock的注意点
ReentrantLock 和 synchronized 不一样，需要手动释放锁，所以使用 ReentrantLock的时候一定要手动释放锁，并且加锁次数和释放次数要一样
reentrantLock方法，获得和释放锁
使用方法介绍。

package org.example.testjul;

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

public class Test1 {
    static Lock lock = new ReentrantLock();

    public static void sm(){
        lock.lock();;
        for(int i = 0;i < 100;i++){
            System.out.println(Thread.currentThread().getName() + "--" + i);
        }

        lock.unlock();//释放锁
        //这个锁就是比较灵活，我可以选择那些部分被锁住，那些不被锁住
    }

    public static void main(String[] args) {


        Runnable r = new Runnable(){
            @Override
            public void run(){
                sm();
            }
        };

        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
    }
}

unlock锁可以用于同步不同方法中的同步代码块。
经常和try和fiinally联合使用
毕竟你必须要释放锁

Lock和synchorized的区别和异同。
https://blog.csdn.net/hefenglian/article/details/82383569

package org.example.testjul;

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

public class Test1 {
    static Lock lock = new ReentrantLock();

    public static void sm1(){
       try{
           lock.lock();
           System.out.println(Thread.currentThread().getName() + "-- method1 -- " + System.currentTimeMillis() );
           Thread.sleep(5000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       } finally{
           lock.unlock();

        }


        //这个锁就是比较灵活，我可以选择那些部分被锁住，那些不被锁住
    }

    public static void sm2(){
        try{
            lock.lock();//同一个锁对象lock能够锁住同一批同步代码块
            //只要使用了同一个锁对象，不管同步代码块在哪里，都可以被一把锁锁住
            System.out.println(Thread.currentThread().getName() + "-- method1 -- " + System.currentTimeMillis() );
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally{
            lock.unlock();

        }

        //这个锁就是比较灵活，我可以选择那些部分被锁住，那些不被锁住
    }



    public static void main(String[] args) {


        Runnable r = new Runnable(){
            @Override
            public void run(){
                sm1();
            }
        };

        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                sm2();
            }
        };

        new Thread(r).start();
        new Thread(r).start();
        new Thread(r).start();
        new Thread(r1).start();
        new Thread(r1).start();
        new Thread(r1).start();
        //同一把锁，把sm2和sm1两个方法都给锁住了
    }
}

这些东西都可以实现同步
在这里插入图片描述
使用这个锁时候可以考虑静态化，静态化实际上是将整个变量变成所有类公用，这样两个对象就可以公用一把锁了。

在这里插入图片描述
可重入锁表示可以反复获得这个锁
那么，就一定要释放两次
这里重点是，一个静态对象，是属于全类的，那么就可以拿来作为整个类的锁。
在这里插入图片描述
如果当前线程没被中断，那么就可以直接获得锁
如果收到了来自psvm的中断标志，那么就抛出异常
就像如果你没被下封杀命令，那么就可以正常出入境内外，如果下了，那么就不行。
在这里插入图片描述
注意这里
在这里插入图片描述
给t2线程一个中断标志
那么执行到t2线程时候，t2线并不会获取到锁
但是对t1没影响，t1还是可以正常获取到锁。
在这里插入图片描述
相当于告诉你，没希望了，别等了，别傻傻等待了。
在这里插入图片描述
当线程长时间未响应时候，可以让线程停止等待。
在这里插入图片描述
可以让线程停止等待。
实际开发时候中断其中一个线程就可以解决死锁问题

Lock就是显示锁，可以解决锁的死锁问题
synchnorized是内部锁，内部锁并不可以解决死锁问题。

lock和synchnorized区别
https://blog.csdn.net/qq_37807989/article/details/93380526

可以使用tryLoc方法解决线程死锁问题
毕竟上一个解决方法里，有一个问题
我们要等待多少秒之后将哪一个死锁线程给关掉呢？

tryLock方法本质就是限时等待，在一定时间内，没有获取到锁那么这个线程也不会去进行等待，而是结束，说白了就是追女神有个时间限制，规定时间内没追到就结束了。

package org.example.testjul;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test1 {

    public static void main(String[] args) {
        new TimeThread().start();
        new TimeThread().start();
        //第一个线程获得锁，将持有6秒，第二个线程启动3秒后没有获得锁，自动结束，不会等待
    }
    private static class TimeThread extends Thread{
        private static ReentrantLock reentrantLock = new ReentrantLock();

        @Override
        public void run(){
            try {
                if(reentrantLock.tryLock(3, TimeUnit.SECONDS)){
                    //等待3秒后没获得锁
                    System.out.println(Thread.currentThread().getName() + "获得所");

                        Thread.sleep(30000);
                }
                else{
                    System.out.println("没有获得锁");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                if(reentrantLock.isHeldByCurrentThread()){
                    //如果线程被当前线程持有
                    reentrantLock.unlock();//那么就释放了
                }
            }
        }

    }

}

trylock不加参数，就是无限去等待。

线程中NewCondition方法
可以实现等待通知模式。
在这里插入图片描述

newContition可以选择性的根据条件变化随机唤醒一个线程。
在这里插入图片描述
await方法和signal方法就很像同步代码块里
this.wait和notify

package org.example.testjul;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test1 {

    private static Lock lock = new ReentrantLock();//获得一把锁
    static Condition condition = lock.newCondition();//用这把锁创建一个condition对象

    //总结起来就是，你首先要有一把锁，第二你从这把锁中衍生出来一个条件对象用于让东西去等待

    private static class SubThread extends Thread{
        @Override
        public void run(){


            try {
                lock.lock();//调用await之前必须先获得锁
                System.out.println("method lock");
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();//线程释放锁
            }
            System.out.println("method await");//进入线程等待状态

        }


    }


    public static void main(String[] args) {
        new SubThread().start();
        //子线程很快进入沉睡状态，如果某个线程比如主线程要去叫醒这个线程，那么必须首先获得锁
        //你要救出沉睡的公主，你首先要有公主房间的钥匙
        //await方法已经把锁吐出来了，你要做的就是获得这把锁
        lock.lock();
        condition.signal();//叫醒线程

        lock.unlock();

    }




}

不过我觉得这个东西最厉害的地方还是
一个点
lock可以锁住好多个线程
然后同一lock可以创造出好多个condition对象
然后这些对象可以一人锁住一个线程
就相当于这个锁可以诞生很多儿子
儿子一人锁住一个线程，需要时候唤醒指定condition下的就可以了。

package org.example.testjul;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test1 {





    //总结起来就是，你首先要有一把锁，第二你从这把锁中衍生出来一个条件对象用于让东西去等待

    private static class SubThread{
        private static Lock lock = new ReentrantLock();//获得一把锁
        static Condition condition1 = lock.newCondition();//用这把锁创建一个condition对象
        static Condition condition2= lock.newCondition();//第二个条件
        static Condition condition3 = lock.newCondition();//第三个可以沉睡线程东西

        public  void waitA(){

            try {
                lock.lock();
                System.out.println("A获得了锁");
                System.out.println("condition1等待");
                condition1.await();//第一线程进入等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("condition1被唤醒了");


        }

        public  void waitB(){

            try {
                lock.lock();
                System.out.println("B获得了锁");
                System.out.println("condition2等待");
                condition2.await();//第一线程进入等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("condition2被唤醒了");


        }

        public  void waitC(){

            try {
                lock.lock();
                System.out.println("C获得了锁");
                System.out.println("condition3等待");
                condition1.await();//第一线程进入等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("condition3被唤醒了");


        }

        public void notigyA(){

                lock.lock();

                System.out.println("notify1获得了锁，并且要唤醒A");
                condition1.signal();//唤醒condition下被沉睡的线程


                lock.unlock();
        }

        public void notifyC(){//唤醒C线程
            lock.lock();
            System.out.println("notify3获得了锁，并且要唤醒C");
            condition3.signal();
            lock.unlock();
        }




    }


    public static void main(String[] args) {
       new Thread(new Runnable() {
           @Override
           public void run() {

               new SubThread().waitA();//A让A和B睡眠
               new SubThread().waitB();
               new SubThread().waitC();
           }
       }).start();

       new Thread(new Runnable() {
           @Override
           public void run() {

               new SubThread().notigyA();//只唤醒A
               new SubThread().notifyC();//只唤醒C
           }
       }).start();

    }




}

可以单独唤醒指定线程。

可以用来进行线程交替打印

package org.example.testjul;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test1 {





    //总结起来就是，你首先要有一把锁，第二你从这把锁中衍生出来一个条件对象用于让东西去等待

    private static class SubThread{
        private static Lock lock = new ReentrantLock();//获得一把锁
        static Condition condition1 = lock.newCondition();//用这把锁创建一个condition对象
        static Condition condition2= lock.newCondition();//第二个条件
        private static int flag = 1;//flag = 1时候让线程1打印1，打印完了自己沉睡然后让标志位变成2
        //标志位为2让线程2醒来打印2

        public static void thread1Print(){

           try {
               lock.lock();//获得锁
               while(flag == 2){

                   condition1.await();//当flag == 2自己就沉睡了
               }
               System.out.println(1);//flag == 1时候正常打印
               flag = 2;//flag2
               condition2.signal();//叫醒2,状态变化了老兄
           }
           catch (Exception e){



           }
           finally {
               lock.unlock();
        }
        }

        public static void thread2Print(){

            try {
                lock.lock();//获得锁
                while(flag == 1){

                    condition2.await();//当flag == 1自己就沉睡了,用条件2让自己沉睡
                }
                System.out.println(2);//flag == 1时候正常打印
                flag = 1;//flag2
                condition1.signal();//叫醒1,状态变化了老兄
            }
            catch (Exception e){



            }
            finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        while(true){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int i = 0;i < 100;i++){
                        SubThread.thread1Print();

                    }

                }
            }).start();

            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 100; i++) {
                        SubThread.thread2Print();

                    }
                }
            }).start();

        }

    }








    }

公平锁和非公平锁
大多数情况下，锁都是非公平锁。
大部分锁都是非公平锁
就是线程随机从阻塞队列中拿出来一个，而不是按照时间先后顺序
能按照排队时间先后顺序拿到锁的才是公平锁。
非公平锁会出现线程饥饿问题，问题很多线程永远抢不到，就会饥饿，公平锁不会饥饿，因为永远有机会抢到。

synchronized就是非公平锁，毕竟是内部锁
lock有公平锁的机制，毕竟是显示锁

reentrantLock(boolean fair)提供一个实现公平锁的机会

package org.example.testjul;

import java.util.concurrent.locks.ReentrantLock;

public class Test11 {
    static ReentrantLock reentrantLock = new ReentrantLock(true);//创建Lock锁
    //这个状态下就是公平锁

    public static void main(String[] args) {

        for(int i = 0;i < 19;i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    reentrantLock.lock();
                    System.out.println(Thread.currentThread().getName() + "获得了线程");
                    reentrantLock.unlock();
                }
            });

            thread.setName(i + "");
            thread.start();
        }
        
        //公平锁会让所有线程都去获得一次锁，平均分配

    }
}

每个线程都有机会抢到一次cpu执行权。

package org.example.testjul;

import java.util.concurrent.locks.ReentrantLock;

public class Test11 {
    static ReentrantLock reentrantLock = new ReentrantLock(true);//创建Lock锁
    //这个状态下就是公平锁

    public static void main(String[] args) {

        for(int i = 0;i < 19;i++){
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        //让一个线程不断的占有和释放锁
                        reentrantLock.lock();
                        System.out.println(Thread.currentThread().getName() + "获得了线程");
                        reentrantLock.unlock();

                    }

                }
            });

            thread.setName(i + "");
            thread.start();
        }

        //公平锁会让所有线程都去获得一次锁，平均分配

    }
}

这种一个线程不断抢到锁，释放锁，抢到锁释放锁的线程，面对的最大问题就是不断的有的线程会长期持有锁，不会别人用，别人很难得到，就是线程饥饿状态。
所以需要公平锁，让每个线程都根据等待时间有机会去得到锁。

getHoldCount可以显示出调用lock的次数。

getQueueLength()返回的是等待的线程数量，等着拿锁的线程数量
在这里插入图片描述返回这个条件下正在wait状态，等待唤醒的线程数量
在这里插入图片描述在这里插入图片描述
直接将线程装进数组里，然后根据Lock去判断这个线程是不是在等待锁。
在这里插入图片描述
查询这个条件是不是在沉睡了某个线程。
在这里插入图片描述还可以设置沉睡时间。。
在这里插入图片描述
在这里插入图片描述

判断锁是不是被当前线程持有。

qq_40707269
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
国密：SM2公私钥加签验签
Su7148的博客
12-21 9370
国密SM2加签逻辑
Java加密：五、SM2国密算法
学以致用 知行合一
05-16 2万+
Java实现的SM2国密算法。 SM2是国家密码管理局于2010年12月17日发布的椭圆曲线公钥密码算法。SM2算法和RSA算法都是公钥密码算法，SM2算法是一种更先进安全的算法，在我们国家商用密码体系中被用来替换RSA算法。 SM2算法是在国际标准的ECC椭圆曲线密码理论基础上进行自主研发设计，具备ECC算法的性能特点并实现优化改进。
SM2 加解密工具
最新发布
zgcyyh的专栏
12-26 753
SM2 是国家密码管理局于 2010 年发布的一种国产公钥密码算法，它采用了椭圆曲线密码体制，其安全性已被国际公认。SM2 算法的主要特点是安全性高、效率高、易于实现，因此被广泛应用于电子商务、电子政务、金融等领域。
国密SM2,SM3,SM4在BC上的实现（一）
gongkanaa的专栏
05-25 1万+
SM2，SM3，SM4算法的实现在网络上实现有不少，但是实现只是加解密，签名等，如果说要生成国密数字证书就麻烦了，还有最近银行的项目上需要用ITEXT对pdf进行国密跟RSA证书数字签名，这个用SM2单独的签名是不能实现的，因为ITEXT签名是基于BC框架的，这里就是在BC框架上添加SM2，SM4算法，以及SM3摘要算法，在这里跟大家分享一下。 BC框架是基于JCA，JCE来实现的，关于JCA，J
JAVA SM2 密钥生成 签名验签 【快速入门】
热门推荐
q1009020096的博客
12-20 4万+
文章目录Before StartBuild with MavenQuickStart密钥对生成签名验签 Before Start SM2算法使用请参考：《GMT 0009-2012 SM2密码算法使用规范 》 在bouncycastle - 1.57版本之后，加入了对 我国的SM2、SM3、SM4算法的支持。 Bouncycastle releasenotes Build with Mave...
如何实现Java线程安全问题
08-25
Java线程安全问题解决方案 Java线程安全问题是指在多线程编程中，多个线程访问共享资源时可能出现的数据不一致、数据丢失或程序崩溃等问题。为了解决这些问题，Java提供了多种解决方案，包括使用同步代码块、同步...
完美解决Java中的线程安全问题
08-29
Java中线程安全问题的解决方案 Java 中的线程安全问题是一个常见的问题，特别是在多线程编程中。今天，我们将讨论如何解决 Java 中的线程安全问题。 Threads 安全问题的产生是由于多个线程访问同一个资源时，可能...
基于java线程安全问题及原理性分析
08-29
"基于java线程安全问题及原理性分析" 基于 Java 线程安全问题是指在多线程环境中，多个线程访问同一个对象时可能发生的安全问题。这种问题产生的根本原因是共享数据存在被并发修改的可能，即一个线程读取时，允许另...
解决线程安全问题方法
12-21
线程安全问题在多线程环境下常常出现，主要由于多个线程并发访问共享资源时可能导致数据的不一致性或异常情况。为了解决这类问题，Java提供了多种机制来确保线程安全，主要包括同步代码块、同步方法以及Lock锁。 1....
详解SimpleDateFormat的线程安全问题与解决方案
08-30
本文将深入探讨`SimpleDateFormat`的线程安全问题及其解决方案。 ### 1. 线程安全问题的原因 `SimpleDateFormat`内部维护了一个`Calendar`对象，用于处理日期和时间的解析与格式化。由于`SimpleDateFormat`不是...
终于把前后端sm加解密以及加签验证调通了。
qq_41846013的博客
02-21 4017
领导要求我对项目的数据传输安全考虑下，因此就想到了对敏感字段做加密和对请求、响应做数字签名验证。网上看了很多文章，可能是因为我对加密这块不了解，感觉都比较乱。所以前前后后花了4天才把前后端调通。特地写一篇文章记录下流程。这里使用的是sm国密算法。不对的地方请读者评论指出。
Vue + Springboot 前后端完整使用国密算法 SM2 数据加密 传输 交互 完整解决方案
yssa1125001的博客
11-08 7564
项目外网部署的时候经常会有要求数据加密传输的情况，特别是企事业单位的项目，另为安全或者红头文件计，经常要求使用国密算法，因为涉及交互，所以使用SM2非对称加密。 后端（Springboot） （1）所需主要依赖（其他如有缺失自行百度即可）： <!-- hutool工具类 --> <dependency> <groupId>cn.hutool</groupId> <artifa
vue/java使用国密SM2加密
weixin_49319251的博客
03-08 5549
————踩坑不易，转载需注明出处————— 本文前后端均使用国密SM2加密，后端在gateway中统一拦截，解密和加密。 流程步骤为： 1、前端对请求数据进行加密； 2、网关请求拦截器拦截前端请求，并对请求数据解密； 3、网关响应拦截器拦截后端响应数据，并对响应数据加密； 4、前端对返回的数据进行解密。 一：导入jar包 <!--SM2加密--> <dependency> <groupId>org.bouncycastle</groupId>
国密sm2加密算法 前后端加密实现
阳光
07-07 4042
国密sm2加密算法，前后端实现
国密：生成SM2秘钥、加解密及加验签
Su7148的博客
11-16 2万+
简述国密SM2的公私钥生成以及加签验签。
SM2国密算法java应用，可以与c++端互相验签通过
weixin_42192467的博客
09-24 1587
SM2国密算法java应用，可以与c++端互相验签通过
【SM2证书】签发SM2根证书 （精简、直接）
jy0921
09-20 4990
0.程序员专用开头： 1.项目结构： 2. 源码： AlgSm2Demo.java （签名验签） package alg.sm2demo; import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey; import org.bouncycastle.jce.provider.Bo...
SM2加密/签名，解密/验签Java多线程之Runnable任务
fen_fen的专栏
08-22 1664
SM2加密和签名Runnable任务
bouncycastle读取SM2证书文件
小强快跑~~
01-03 1696
主要的原因是java默认实现中，并不能识别SM2算法。，这里的"BC"，是指定使用BouncyCastleProvider，必须要指定才能正确读取SM2证书。可以放到类的初始化部分，不用在函数调用中每次都执行，这里主要是为了说明代码，放在了函数中。我们可以通过CertificateFactory的generateCertificate方法，来读取该文件并生成X509Certificate对象。这种做法对于RSA的证书，通常没有问题，但是对于。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值