java线程锁策略

最新推荐文章于 2023-03-31 20:52:37 发布
最新推荐文章于 2023-03-31 20:52:37 发布
阅读量711 收藏 1
点赞数 3
分类专栏： JAVA Web 文章标签： java 线程安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44712669/article/details/119388765
版权
JAVA 同时被 2 个专栏收录
97 篇文章 0 订阅
订阅专栏
Web
15 篇文章 0 订阅
订阅专栏

线程不安全问题及锁策略

1.线程不安全问题及原因

1.1什么叫做线程不安全问题？

数据的不一致：在多线程的执行中，程序的执行结果与预期不相符
代码示例如下：

public class ThreadDemo15 {
    static class Counter{
        private int num = 0;
        private final int maxSize = 100000;
        public void increment(){
            for (int i = 0; i <maxSize ; i++) {
                num++;
            }
        }
        public void decrement(){
            for (int i = 0; i <maxSize ; i++) {
                num--;
            }
        }
        public int getNum(){
            return num;
        }
    }


    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(()->{
            counter.increment();
        });
        t1.start();
        Thread t2 = new Thread(()->{
           counter.decrement();
        });
        t2.start();
        t1.join();
        t2.join();


        System.out.println("结果"+counter.getNum());
    }
}

这里我们期望的结果是0；但是每次执行都会出现不同的结果
在这里插入图片描述

1.2 导致线程非安全的原因

1.CPU强占执行，
2.非原子性：原子性–指一个操作是不可中断的，即使多个线程一起执行的时候，一个操作一旦开始就不会被其他线程干扰；而非原子性就是指线程操作被其他线程干扰；
3.编译器优化：在单线程下可以提升程序的执行效率，但是在多线程下就会出现混乱，从而导致线程不安全的问题；–指令重排序
4.内存可见性问题：线程A对共享变量进行了操作，但没有及时把更改后的值存入主内存中，而此时线程B从主内存读取到了共享变量的值，所以X的值是原始值，此时对于线程B来说，共享变量的改变对于B是不可见的，
5.多个线程同时修改同一个变量

理解非原子性问题：

public class ThreadDemo15 {
    static class Counter{
        private int num = 0;
        private final int maxSize = 100000;
        public void increment(){
            for (int i = 0; i <maxSize ; i++) {
                num++;
            }
        }
        public void decrement(){
            for (int i = 0; i <maxSize ; i++) {
                num--;
            }
        }
        public int getNum(){
            return num;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(()->{
            counter.increment();
        });
        t1.start();
        Thread t2 = new Thread(()->{
           counter.decrement();
        });
        t2.start();
        t1.join();
        t2.join();
        System.out.println("结果"+counter.getNum());
    }
}

在这里插入图片描述
按照我们设计的线程执行结果应该是num=0；但这里每一次执行的num都不相同，
这就是由于线程之间的操作的原子性导致的；
线程处理数据的过程：
1.从主内存中加载数据到工作内存，
2.对工作内存中的内容进行操作
3.操作完成之后就对这些数据写入主内存；
两个线程都改变了num的值，因而在操作过程中，出现了两次操作混乱的情况；
而导致上述问题就是由于两个线程操作内存的顺序混乱；

2.线程不安全问题的解决方案

1.volatile 作用：
A.禁止指令重排序，
B.解决线程可见性问题–每次线程操作完变量之后，强制删除掉工作内存中的变量
注意：不能解决原子性问题；因此不能解决上述问题
2.加锁：
A.synchronized加锁和释放锁–JVM的解决方案
B.Lock手动锁–自己加锁和释放锁

2.1 synchronized的使用

synchronized：为保证操作的原子性–最好只用1把锁；

public class ThreadDemo17 {
    private static int num = 0;
    private static final int maxSize = 100000;


    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Object lock2 = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <maxSize ; i++) {
                    synchronized (lock){
                        num++;
                    }


                }
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <maxSize ; i++) {
                    synchronized (lock){
                        num--;
                    }


                }
            }
        });
        t2.start();
        t1.join();
        t2.join();
        System.out.println(num);
    }
}

在这里插入图片描述
如果加了两把锁，跟没加锁一样：
在这里插入图片描述
使用锁就可以让线程在拥有锁的时候才能执行，没有锁就不能执行；

2.1.2种使用场景

synchronized关键字最主要有以下3种应用方式，下面分别介绍

  • 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁

  • 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁

  • 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁

  1. 修饰实例方法：使用synchronized修饰了increase方法，new了两个不同的实例对象时就有两个不同的锁
public synchronized void increase(){ 
        i++; 
}
  1. 修饰静态方法：当synchronized作用于静态方法时，其锁就是当前类的class对象锁。
public static synchronized void increase(){ 
        i++; 
}
  1. 修饰代码块：将synchronized作用于一个给定的实例对象instance，即当前实例对象就是锁对象，每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待
public void run() {
        //省略其他耗时操作....
        //使用同步代码块对变量i进行同步操作,锁对象为instance
        synchronized(instance){
            for(int j=0;j<1000000;j++){
                    i++;
              }
        }
    }

2.1.3 synchronized原理解析;

首先理解JAVA中对象头和Monitor
在JVM中，对象在内存中的布局分为三块区域，对象头、实例数据和对齐填充
在这里插入图片描述

  • 实例变量：存放类的属性数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按4字节对齐
  • 填充数据：由于虚拟机要求对象起始地址必须是8字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐

Java对象头，是实现synchronized的锁对象的基础：
synchronized使用的锁对象是存储在JAVA对象头中的，JVM使用两个字节存储对象头，也就是mark word–分为lock
word和标志位； 标志位通常就表示当前锁的状态：
在这里插入图片描述

monitor：
当线程进入被synchronized修饰的方法或代码块：指定的锁对象就会通过一些操作将对象头中的Lockword指向monitor的起始地址，同时monitor中owner存放拥有当前锁的线程标识，确保一次只能由一个线程执行该部分的代码，线程在获取锁之前不允许执行该部分代码

2.2 lock手动锁

java种的ReentrantLock实现了手动锁
通常书写格式如下：

//加锁
lock.lock();
try{
    num++;
}finally {
//释放锁    
  lock.unlock();
}

使用示例

public class ThreadDemo18 {
    private static int num = 0;
    private static final int maxSize = 100000;


    public static void main(String[] args) throws InterruptedException {
        //创建手动锁
        Lock lock = new ReentrantLock();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <maxSize ; i++) {
                    lock.lock();
                    try{
                        num++;
                    }finally {
                        lock.unlock();
                    }






                }
            }
        });
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <maxSize ; i++) {
                    lock.lock();
                    try{
                        num--;
                    }finally {
                        lock.unlock();
                    }


                }
            }
        });
        t2.start();
        t1.join();
        t2.join();
        System.out.println(num);
    }
}

在这里插入图片描述
与synchronized效果相同

3. 面试常问

3.1 synchronized和lock的区别：

synchronized是非公平锁，

A.synchronized可以修饰代码块、静态方法、实例方法，Lock只能修饰代码块
B.sychronized只有非公平锁策略，而Lock即可以是公平锁，也可以是非公平锁；
C.sychronized是自动加锁和释放锁，lock需要手动加锁和释放锁；
公平锁可以按顺序执行，而非公平锁强占式执行，效率更高；
在java中所有的锁默认位非公平锁；
lock默认非公平锁，但可以实现公平锁
示例如下：

public class ThreadDemo19 {
    public static void main(String[] args) throws InterruptedException {
        Lock lock = new ReentrantLock(true);
        Runnable runnable =new Runnable() {
            @Override
            public void run() {
                for (char item:"ABCD".toCharArray()){
                    lock.lock();
                    try{System.out.print(item);
                    }finally {
                        lock.unlock();
                    }


                }
            }
        };
        Thread t1 = new Thread(runnable,"t1");
        Thread t2 = new Thread(runnable,"t2");
//        Thread.sleep(10);
        t1.start();
        t2.start();
    }
}

公平锁可以按照顺序执行线程；
在这里插入图片描述

3.2 volatile和synchronized的区别？

volatile可以解决内存可见性问题和禁止指令重排序，但不能解决原子性问题，synchronized用来保证线程安全，可以解决所有线程安全的问题，–始终一个线程执行锁操作；

超分辨菜鸟
关注
专栏目录
Java 多线程（致命）面试题：线程锁+线程池+线程同步等
m0_68850571的博客
05-26 1279
1、并发编程三要素？ 1）原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。 2）可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。 实现可见性的方法： synchronized 或者 Lock：保证同一个时刻只有一个线程获取锁执行代码，锁释放之前把最新的值刷新到主内存，实现可见性。 3）有序性 有序性，即程序的执行顺序按照代码的先后顺序来执行。 2、多线程的价值？ 1...
一篇文章总结Java中的锁策略
爱敲代码的三毛的博客
01-15 349
文章目录一、乐观锁&悲观锁版本号机制二、使用步骤1.引入库2.读入数据总结 一、乐观锁&悲观锁 加锁，是一个开销比较大的事情，创建锁销毁锁都是会消耗资源的。我们希望在特定的场景下，针对场景做出一些取舍，好让锁更高效一些 乐观锁：假设锁冲突的概率比较低，甚至都没有冲突，就只是简单处理一下冲突 悲观锁：假设锁冲突的概率比较高，甚至于每次尝试加锁都会有冲突，此时就会愿意付出更多成本来解决冲突 乐观锁，假设一般情况下都不会产生锁冲突，因此就尝试直接访问数据，如果发现了锁冲突 ，然后再去处理。 悲观
java单线程上锁_java-简单线程锁
weixin_36260016的博客
02-28 399
1.简单线程锁,一个一个访问import com.zhl.framework.web.message.SimpleMessage;import com.zhl.scheduling.service.ProgrammeService;import com.zhl.scheduling.service.SchedulingDispatchMediaService;import org.springfr...
java基础-线程锁
Owen Guo
06-14 469
一、 synchronized关键字 1.对象锁 a.当使用对象锁的时候，注意要是相同的对象，并且当有线程正在访问对象锁内部的代码的时候，其他线程无法访问。(注意无法访问的范围)。 b.但是并不影响没有使用对象锁的部分的代码的运行。 对象锁分为两类一个叫做synchronized代码块(圆括号内是普通类的对象)，另外一个是sybchronized修饰普通成员方法。它们二者其实可以通过this关键字进项转化。 2.类锁 a. 当使用类锁的时候，只要是同一个类的对象.当有线程正在访问类锁内部的代码的时候，其他线
java 线程 各种锁总结_Java线程锁总结
weixin_42469578的博客
02-24 142
Java线程锁总结1.synchronized：在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序通常会尽可能的进行优化synchronize，另外可读性非常好。2.ReentrantLock:在资源竞争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍，而R...
Java线程同步机制下的手动加锁和自动加锁
最新发布
刘先生倒了u的博客
03-31 354
我们能想到的解决方案就是加锁，加锁分为自动加锁和手动加锁。可以看到，数量在低于30的情况下，不支持修改了。使用sychronized关键字进行加锁。这段代码会出现线程不同步问题。从输出就可以看出，数据出现了。非常简单，只需要在方法前加。程序中定义了5个线程对。
java 线程公平锁与非公平锁详解及实例代码
08-31
Java线程公平锁与非公平锁是并发编程中重要的概念，尤其在使用ReentrantLock时。ReentrantLock是Java并发包（java.util.concurrent）中的一个可重入互斥锁，它提供了比内置的synchronized关键字更为灵活的锁操作。 ...
java线程进程锁资源
02-12
Java线程和进程是计算机程序执行的两种基本方式，它们在多任务环境下尤为关键。Java作为一门多线程编程语言，提供了丰富的工具和机制来管理线程和进程，以实现高效的并发执行。 **进程与线程的区别** 1. **进程**：...
解析Java线程同步锁的选择方法
09-05
本文将深入探讨Java线程同步锁的选择方法及其适用场景。 1. **synchronized关键字**： synchronized是Java内置的同步原语，它提供了两种使用方式：方法同步和代码块同步。在上述示例中，`method`方法通过`...
Java线程公平锁和非公平锁的差异讲解
08-26
`ReentrantLock`提供了可配置的公平性和非公平性，允许开发者根据应用需求选择合适的锁策略。 **公平锁**： 公平锁确保线程获取锁的顺序遵循先进先出（FIFO）的原则。当线程请求锁时，它会检查当前是否有其他线程在...
如何解决线程不安全问题以及java中两种加锁
qq_47801720的博客
05-05 640
要解决线程不安全问题，首先要了解导致线程不安全的因素： CPU是抢占式执行的（万恶之源） 多个线程同时修改同一个变量（即共享变量） 可见性 原子性 指令重排序 1、2两种因素，是我们无法改变的，所以我们只能解决剩下的因素。 解决方案 用volatile修饰 解决可见性： 每个线程都有自己的工作内存，假设有两个线程，对一个count值进行修改，按一般情况是线程1对count修改为1再放入主内存，线程2再对count修改为-1，再存入主内存，但此时线程1的工作内存中count还是为1(即线程2的修改对线
java单线程上锁,Java多线程详解-锁
weixin_35711852的博客
03-15 650
前言最近工作有点忙，周末也一直在996加班，所以没有时间来写博客，今早忙里偷闲来写一下多线程的第二篇。废话不多说，开始这次的主题。复习上一张我们学习了Java多线程的基础知识。回顾一下：1：实现多线程的两种方式，继承Thread类以及实现Runable接口，然后重写里面的run方法即可。2：线程的状态：新建状态，就绪状态，运行状态，阻塞状态，死亡状态。其中最重要的地方，也是难点就是线程的阻塞状态，...
JAVA 7+ 实现自动锁(AutoLock)
weixin_34232363的博客
09-01 649
了解自动锁 很早就受不了 java 锁的机制了,每次都需要在 finally 去解锁, 不仅代码不美观,而且很麻烦 我想能不能实现加锁之后自动解锁, 如果是C++ 可以利用析构函数实现, 但java就....... 想了想好像可以利用java7 的 try-with-resource 特性, 对象只需要实现 AutoCloseable 接...
Java中的线程和锁机制
Tender的博客
02-18 909
线程池 为什么使用线程池？ 线程池执行原理？ 线程池参数有哪些？ 线程池大小怎么设置？ 线程池的类型有哪些？适用场景？ 进程线程 线程的生命周期 讲一下线程中断？ 创建线程有哪几种方式？ 什么是线程死锁？ 线程死锁怎么产生？怎么避免？ 线程run和start的区别？ 线程都有哪些方法？ volatile底层原理 AQS原理 synchronized的用法有哪些? Synchronized的作用有哪些？ synchronized 底层实现原理？ ReentrantLock 是如何实现可重入性的?.
Java 多线程加锁的方式总结及对比
热门推荐
u010842515的博客
03-28 7万+
参考博文：http://www.cnblogs.com/handsomeye/p/5999362.html 一.Java多线程可以通过： 1. synchronized关键字 2. Java.util.concurrent包中的lock接口和ReentrantLock实现类 这两种方式实现加锁。 二.synchronized关键字加锁的缺陷： 如果一个代码块被s
必问系列 | 12张图带你彻底理解Java中的各种锁~
小龙coding的博客鸭~
12-07 393
12张图 | 图解Java中的各种锁~
java什么操作可以解锁_Java用不同的方法锁定和解锁.如何尝试/终于？
weixin_42510360的博客
02-13 276
这实际上是应用execute around method pattern的非常好的候选者.如果您的类的客户端需要对需要正确初始化和/或正确清理的资源执行某些操作,您可以将清理保留在客户端的手中,并希望文档和失败的快速行为会使客户端正确处理资源.通过初始化并从客户端再次清理出来,执行around方法模式带来了这个难题.基本上,您引入了一种方法,该方法可以正确地执行资源的初始化和清理,并且可以将其交给...
java手动实现简易可重入锁
sweet_sauce的博客
02-26 711
 说到可重入锁默认提到的就是Reentrantlock，可重入的概念就是，当前线程可以多次获得一个锁，这样主要是解决了死锁问题。 如果没有可重入锁，当一个线程递归获得当前锁的时候，会由于锁没有释放而导致死锁，jdk基于AQS实现，主要是有个 state变量，如果是当前线程获得锁，就自增一次，释放锁就是给这个state递减，减到零就释放这个锁。这篇文章只实现非公平的可重入锁，没有涉及CLH等待队列...
Java并发（三）一篇弄懂锁机制
最高永远来自最下
09-21 1398
一、简介 在做多线程开发时，如果多个线程同时操作一个可共享的资源变量时（如数据的增删改查），就会出现混乱的现象，数据产生冲突，得到的值并不是该线程预期想要的。那么我们就需要对线程的操作进行控制，让其排队去处理对应的数据，处理完了再交给另一个线程，这个过程就叫线程同步，实现线程同步就需要用到锁机制，顾名思义，当一个线程需要用资源的时候，就把它锁起来，直到用完再解锁，交给其他线程使用。 二、锁的实现 Java中锁的实现主要是通过synchronized关键字 和java.util.concurrent.lock
Java线程锁与条件对象深度解析
本文将深入讲解Java中的线程同步技术，特别是线程锁和条件对象的概念以及其在并发编程中的应用。在多线程环境中，避免数据竞争和并发问题至关重要。Java提供了多种同步机制，其中synchronized关键字是最基础的，它会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值