Java多线程与各种锁

最新推荐文章于 2024-07-08 00:01:13 发布
最新推荐文章于 2024-07-08 00:01:13 发布
阅读量168 收藏
点赞数
分类专栏： java常规 文章标签： java lock synchronized 锁 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46146718/article/details/120268413
版权

Java多线程与各种锁

一、Synchronize线程同步

public class BuyController {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        new Thread(myThread1, "购票者1").start();
        new Thread(myThread1, "购票者2").start();
        new Thread(myThread1, "购票者3").start();
    }
}

class MyThread implements Runnable {
    //票数是多个线程的共享资源
    private int ticket = 10;

    @Override
    // public void run() {  //原
    public synchronized void run() {
        while (ticket > 0) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "还剩下" + ticket-- + "张票");
        }
    }
}

在这里插入图片描述
也可以这么写

class MyThread2 implements Runnable {
    //票数是多个线程的共享资源
    private int ticket = 10;

    @Override
    public void run() {
        synchronized (MyThread2.class) {
            while (ticket > 0) {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "还剩下" + ticket-- + "张票");
            }
        }
    }
}

二、各种Lock锁

Synchronized在发生异常时会自动释放占有的锁，因此不会出现死锁；而Lock发生异常时，不会主动释放占有的锁，必须手动来释放锁，可能引起死锁的发生。

1、普通锁

/**
 * 服务
 */
class MyService {
    private Lock lock = new ReentrantLock();

    public void testMethod() {
        lock.lock();
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //不管是否有异常都要释放锁
            lock.unlock();
        }
    }
}

/**
 * 线程
 */
class MyThread3 implements Runnable {
    private MyService service;

    public MyThread3(MyService service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        service.testMethod();
    }
}

class LockTest {

    public static void main(String[] args) {
        MyService service = new MyService();
        MyThread3 t1 = new MyThread3(service);
        MyThread3 t2 = new MyThread3(service);
        MyThread3 t3 = new MyThread3(service);
        new Thread(t1, "窗口1").start();
        new Thread(t2, "窗口2").start();
        new Thread(t3, "窗口3").start();
    }
}

2、公平锁与非公平锁

//公平锁
Lock nonFairLock=new ReentrantLock(true);
//默认非公平锁
Lock fairLock=new ReentrantLock(false);

重入锁

public class BuyController {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        lock.lock();
        lock.lock();
        lock.unlock();
        lock.unlock();
    }
}

举例

class LockTest2 {

    //默认是非公平锁
    //static ReentrantLock lock=new ReentrantLock();
    //公平锁
    static ReentrantLock lock = new ReentrantLock(true);

    public static void main(String[] args) {
        Runnable myRunnable = new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        lock.lock();
                        System.out.println(Thread.currentThread().getName() + " 获得了锁对象");
                    } finally {
                        lock.unlock();
                    }
                }
            }
        };

        for (int i = 0; i < 5; i++) {
            new Thread(myRunnable, "线程" + i).start();
        }
    }
}

如果是：static ReentrantLock lock=new ReentrantLock(true); 这就是公平锁， 可以看到系统会按照线程等待的先后时间顺序，有序的为每个线程分配锁对象，这个顺序一直就是 0-2-4-3-1。

在这里插入图片描述

如果是：static ReentrantLock lock=new ReentrantLock(); 这默认就是非公平锁，可以看到多线程执行之后，系统更倾向于让一个之前获得锁的线程再次获得锁，这显然就体现了非公平性。

在这里插入图片描述

3、乐观锁与悲观锁以及CAS优化乐观锁

在这里插入图片描述
根据从上面的概念描述我们可以发现：

  • 悲观锁适合写操作多的场景，先加锁可以保证写操作时数据正确。
  • 乐观锁适合读操作多的场景，不加锁的特点能够使其读操作的性能大幅提升。
public class OptimisticPessimisticLock {
    //悲观锁的调用方式
    //synchronized
    public synchronized void testMethod( ) {
        //操作同步资源
    }
    //ReentrantLock
    private ReentrantLock lock = new ReentrantLock();//需要保证多个线程使用同一个锁
    public void modifyPublicResources() {
        lock.lock();
        //操作同步资源
        lock.unlock();
    }

    //乐观锁的调用方式
    private AtomicInteger atomicInteger = new AtomicInteger();//需要保证多个线程使用同一个
    public void modifyPublicResources2() {
        //操作同步资源
        atomicInteger.incrementAndGet();//执行自增1
    }
}

我们可以发现悲观锁基本都是在显式的锁定之后再操作同步资源，synchronized和Lock这种方式又有一个名字，叫做互斥锁，一次只能有一个持有锁的线程进入，再加上还有不同线程争夺锁这个机制，效率比较低，所以又称“悲观锁”。
而乐观锁则直接去操作同步资源。那么，为何乐观锁能够做到不锁定同步资源也可以正确的实现线程同步呢？我们通过介绍乐观锁的主要实现方式 “CAS” 的技术原理来为大家解惑。

CAS算法涉及到三个操作数：

  • 需要读写的内存值 V。
  • 进行比较的值 A。
  • 要写入的新值 B。

实现思想 CAS（V, A, B），V为内存地址、A为预期原值，B为新值。如果内存地址的值与预期原值相匹配，那么将该位置值更新为新值。否则，说明已经被其他线程更新，处理器不做任何操作；无论哪种情况，它都会在 CAS 指令之前返回该位置的值。而我们可以使用自旋锁，循环CAS，重新读取该变量再尝试再次修改该变量，也可以放弃操作。

public class OptimisticPessimisticLock {
    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {

        AtomicInteger atomicInteger = new AtomicInteger();
        //计数器用于阻塞
        CountDownLatch countDownLatch = new CountDownLatch(2);
        for (int i = 0; i < 2; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 1000; j++) {
                        //CAS执行自增
                        atomicInteger.incrementAndGet();
                        //普通的自增
                        count++;
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();
        System.out.println("atomicInteger:" + atomicInteger.get());
        System.out.println("count:" + count);
    }
}

java语言CAS底层如何实现？
利用unsafe提供的原子性操作方法。
什么是ABA问题？怎么解决？
当一个值从A变成B，又更新回A，普通CAS机制会误判通过检测。利用版本号比较可以有效解决ABA问题。

public class MyOptimisticLock {

    public Personnel findAndUpdate(List<Personnel> personnels) {
        //从数据库中获取所有员工列表
        List<Personnel> personnelList = findPersonnelList();
        if (personnelList != null && personnelList.size() > 0) {
            //获取第一个员工并修改
            Personnel personnel = personnelList.get(0);
            personnel.setName("Tom");
            Integer result = updatePersonnel(personnel);
            if (result == 1) {
                return personnel;
            } else {
                //已被更新 则再次获取
                findAndUpdate(personnelList);
            }
        } 
        return null;
    }
}


@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Personnel {
    private String name;
    private Integer age;
    private Integer version;
}

	<update id="updatePersonnel" parameterType="com.yuange.mapper.PersonnelUpdate">
		UPDATE t_personnel 
		SET NAME = #{name} ,
		AGE = #{age} ,
		VERSION = VERSION + 1 
		WHERE
			NAME = #{name}			
			AND VERSION = #{version}
	</update>

简要说明：表设计时，需要往表里加一个version字段。每次查询时，查出带有version的数据记录，更新数据时，判断数据库里对应id的记录的version是否和查出的version相同。若相同，则更新数据并把版本号+1；若不同，则说明，该数据发送并发，被别的线程使用了，进行递归操作，再次执行递归方法，知道成功更新数据为止。
上述findAndUpdate方法即实现了一个乐观锁，作用是冲数据库里更新一条数据病返回前端。如果并发率大，一次请求可能则会重复执行很多次findAndUpdate，则性能低。如果并发很乐观，用户请求少，则不需要用synchronized，多线程时性能高。

乐观锁适用于写比较少的情况下，即冲突比较少发生，这样可以省去了锁的开销，加大了系统的整个吞吐量。
但如果经常产生冲突，乐观锁 的重复尝试 反倒会降低了性能，所以这种情况下用悲观锁就比较合适。

4、重入锁与重入自旋锁

在JAVA环境下 ReentrantLock 和synchronized 都是 可重入锁

/**
 * @author lichangyuan
 * @create 2021-10-11 14:08
 */
public class ReentryLock implements Runnable {
    //synchronized版
    public synchronized void get() {
        System.out.println(Thread.currentThread().getId());
        set();
    }

    public synchronized void set() {
        System.out.println(Thread.currentThread().getId());
    }

    //ReentrantLock版
    ReentrantLock lock = new ReentrantLock();

    public void get2() {
        lock.lock();
        System.out.println(Thread.currentThread().getId());
        set2();
        lock.unlock();
    }

    public void set2() {
        lock.lock();
        System.out.println(Thread.currentThread().getId());
        lock.unlock();

    }

    @Override
    public void run() {
        get();
        get2();
    }

    public static void main(String[] args) {
        ReentryLock reentryLock = new ReentryLock();
        new Thread(reentryLock).start();
        new Thread(reentryLock).start();
    }
}

在这里插入图片描述
我们以自旋锁作为例子

class SpinLock1 {
    private AtomicReference<Thread> owner = new AtomicReference<>();

    public void lock() {
        Thread current = Thread.currentThread();
        while (!owner.compareAndSet(null, current)) {
        }
    }

    public void unlock() {
        Thread current = Thread.currentThread();
        owner.compareAndSet(current, null);
    }
}
  1. 若有同一线程两调用lock() ，会导致第二次调用lock位置进行自旋，产生了死锁
    说明这个锁并不是可重入的。（在lock函数内，应验证线程是否为已经获得锁的线程）
  2. 若1问题已经解决，当unlock（）第一次调用时，就已经将锁释放了，实际上不应释放锁。
    （采用计数次进行统计）

该自旋锁即为可重入锁。

class SpinLock2 {
    private AtomicReference<Thread> owner = new AtomicReference<>();
    private int count = 0;

    public void lock() {
        Thread current = Thread.currentThread();
        //如果锁的线程被锁过了则直接退出
        if (current == owner.get()) {
            count++;
            return;
        }
        //如果有线程持有锁则继续回调直到锁被释放，则把当前线程锁住
        while (!owner.compareAndSet(null, current)) {

        }
    }

    public void unlock() {
        Thread current = Thread.currentThread();
        //如果当前count值不为0说明前面有重入锁发生且未解锁，知道值递减为0则解锁当前线程
        if (current == owner.get()) {
            if (count != 0) {
                count--;
            } else {
                owner.compareAndSet(current, null);
            }
        }
    }
}
和烨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
知识积累-ReentrantLock公平锁的实现
qq_44302011的博客
04-17 1239
ReentranLock公平锁
java 线程重入锁：ReentrantLock 简单案例
weixin_44540005的博客
02-06 357
在这就简单说下锁重要性吧，锁一般应用在安全方面。如项目中与钱相关的操作，单机情况下是基本没安全方面的问题。像网站这种，情况一：线程不安全，当多个请求同时到达，他们可能同时执行，我们的普通限制可能会失效，取款金额就可能出现负数（这一般是不允许出现的情况）。情况一：线程安全，我这指的是加锁，当多个请求同时到达，这样就能达到一条一条请求执行的效果。 案例（有锁的） 包：com.gx.mi_dome ...
利用Synchronized或者ReentrantLock解决并发问题demo
weixin_52793468的博客
07-12 54
想法：还可用乐观锁实现，通过版本号控制，当线程拿到这个共享数据时，版本号+1，后面线程想拿数据就进行比对版本号，版本号不一致就无法进行操作共享数据。当库存还剩1时，通过加锁操作共享数据，防止其它线程抢占CPU造成库存出现负数。
synchronized/ReentrantLock-实现多个线程间的数据同步Demo
李杰的博客
03-31 119
文章目录1、未用锁情况2、使用synchronized3、使用ReentrantLock公平锁非公平锁 1、未用锁情况 demo public static void main(String[] args) { TestTicket testTicket = new TestTicket(); Thread threadA = new Thread(testTicket); Thread threadB = new Thread(testTicke
面经手册 · 第16篇《码农会锁，ReentrantLock之公平锁讲解和实现》
bugstack虫洞栈
11-05 1988
作者：小傅哥 博客：https://bugstack.cn 沉淀、分享、成长，让自己和他人都能有所收获！???? 一、前言 Java学多少才能找到工作？ 最近经常有小伙伴问我，以为我的经验来看，学多少够，好像更多的是看你的野心有多大。如果你只是想找个10k以内的二线城市的工作，那还是比较容易的。也不需要学数据结构、也不需要会算法、也需要懂源码、更不要有多少项目经验。 但反之我遇到一个国内大学TOP2毕业的娃，这货兼职是Offer收割机：腾讯、阿里、字节还有国外新加坡的工作机会等等，薪资待遇也是贼高，可能
Java多线程和锁
好好学习天天向上
05-20 65
文章目录引言一个线程的生命周期java多线程的四个创建方法1.继承Thread类2.实现Runnable接口和run()方法3.实现Callable接口和call()方法4.线程池参考资料 引言 本文主要记录java学习中的多线程和锁的问题 一个线程的生命周期 一个线程的生命周期有五个状态：新建状态，就绪状态，运行状态，阻塞状态，死亡状态 新建状态: 使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。 就绪
java 多线程加锁
一个抽风的女Ren的博客
06-09 2172
java 加锁方法： 1：直接加 synchronized 关键字 2：使用lock private java.util.concurrent.locks.Lock lock = new ReentrantLock(); private void fun(){ lock.lock(); try{ 执行语句...... } finally{ lock.unlock(); } } 例子： 生成订单号，此处是由时间戳 public clas...
Java多线程 ReentrantLock互斥锁详解
08-25
Java多线程ReentrantLock互斥锁详解 ReentrantLock是Java多线程编程中的一种锁机制，它可以实现线程之间的同步访问资源。ReentrantLock的主要特点是可以重入，即一个线程可以多次获得锁，而不需要释放锁。这种机制...
Java多线程锁机制相关原理实例解析
08-18
Java多线程锁机制相关原理实例解析 Java多线程锁机制是指在Java编程语言中，用于解决多线程并发访问共享资源的机制。该机制主要通过锁机制来实现线程同步，确保多线程之间的安全访问共享资源。 锁机制是Java多线程...
Java 多线程同步 锁机制与synchronized深入解析
09-05
总结来说，Java的synchronized关键字提供了锁机制，用于实现多线程环境下的同步。同步方法和同步代码块是两种不同级别的同步控制，同步代码块提供了更灵活的控制和更高的效率。理解并合理使用这些机制对于编写高效、...
JAVA Lock加锁实例
07-10
Lock锁是对象锁，仅在同一对象中，锁才会生效。（不做论证） （以下场景皆为单例模式下运行） lock.lock()的加锁方式，会使后续请求的线程堵塞等待。（方案A） lock.tryLock()的加锁方式，不会堵塞，会立即返回加锁成功与否。（方案AEX） lock.tryLock(1000, TimeUnit.SECONDS)的加锁方式，允许堵塞时间，若在堵……
Java多线程中Lock锁的使用总结
08-18
Java多线程中Lock锁的使用总结 Java多线程中Lock锁的使用总结主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。 知识点1: Java多线程中的...
java多线程和锁，用于学习参考
09-09
Java多线程与锁是Java并发编程中的核心概念，它们在构建高效、可扩展的并发应用程序中起着至关重要的作用。下面将详细讲解这两个主题。 首先，Java中的多线程是指程序执行时可以同时进行多个任务。这得益于操作系统...
基于ReentrantLock实现简易生产者、消费者模型
Dream_it_possible！的博客
11-30 2266
实际开发中，我们可能会需要一个队列场景，往队列投入资源的为生产者，往队列中拿元素的为消费者，那么ReentrantLock能帮助我们实现这种生产者、消费者模型。 实现原理: 我们可以借助ReentrantLock定义两个信号量: notFull和notEmpty, notFull.await()阻塞生产者投放资源，同时提醒消费者可以拿资源，notFull.signal() 用来提醒生产者可以继续投放资源 ; notEmpty.await用来阻塞消费者拿资源并提醒生产者往队列...
通俗易懂的ReentrantLock总结
qq_51033936的博客
01-02 161
ReentrantLock 对其操作都转化为对 Sync 对象的操作，由于 Sync 继承了 AQS，所以基本上都可以转化为对 AQS 的操作。如将 ReentrantLock 的 lock 函数转化为对 Sync 的 lock 函数的调用，而具体会根据采用的策略 (如公平策略或者非公平策略) 的不同而调用到 Sync 的不同子类。
以ReentrantLock为例，分析Java并发编程中公平锁和非公平锁的实现；
代码小司机
05-20 527
概念解释： 公平锁，指的是在进行锁的竞争中，没有获得锁的线程，当锁被释放时，会按照先后顺序依次进行锁的获取，先到先得，体现公平性； 非公平锁，指的是锁释放后，竞争锁的线程不会按照先后顺序来获取被释放的锁，结果具有随机性，故不体现公平性； 实例分析： 以ReentrantLock 为例，分别实现公平锁及非公平锁案例； /*** * 公平锁实现： * ReentrantLock 构造方法中可以设置为true，代表公平锁，false，代表非公平锁； * * 实例逻辑： * 主线程占用锁..
Java---ReentrantLock
qq_41653753的博客
02-19 118
一.AQS 1.概述 AQS（AbstractQueuedSynchronizer），是抽象队列同步器，其实就是一个用来构建锁和同步器的框架。内部实现的关键是：先进先出的队列、state状态。 2.核心思想 AQS核心思想是：如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，AQS使用一个voliate int成员变量来表示同步状态，通过内置的FIFO队列来完成获取资源线程的排队工作。AQS使用CAS对该同步状态进行原子操
java 重入锁_Java并发编程之ReentrantLock可重入锁的实例代码_Java_软件编程
weixin_30423863的博客
02-19 196
目录 1.ReentrantLock可重入锁概述2.可重入3.可打断4.锁超时5.公平锁6.条件变量 Condition1.ReentrantLock可重入锁概述相对于 synchronized 它具备如下特点可中断synchronized锁加上去不能中断，a线程应用锁，b线程不能取消掉它可以设置超时时间synchronized它去获取锁时，如果对方持有锁，那么它就会进入entryList一直等待...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 531
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
最新发布
小明的Java问道之路
07-08 604
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

和烨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值