java的锁以及线程通信

已于 2022-07-25 16:52:19 修改
阅读量346 收藏
点赞数
分类专栏： JUC 文章标签： 安全 java 开发语言
于 2021-12-07 13:15:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LC_Liangchao/article/details/121766803
版权

文章目录


说到锁，你们能想起java种有哪些锁的概念？
乐观锁，悲观锁，公平锁，非公平锁，同步锁（代码块），读写锁，可重入锁，lock锁等等。。。

一、 锁的介绍

对于锁的理解 -确保线程安全

公平/非公平锁

公平：不可以插队
非公平：可以插队，这是正常的业务逻辑 – 大部分锁都是

乐观/悲观锁

乐观锁：乐观，操作的时候不加锁，等最后的时候判断是否需要事务回滚。

  • 关系型数据库：添加一个字段version，操作前先获取，结束后再获取version，两次值不同说明发生了变化。
  • 非关系型数据库（redis）：watch监控命令就是有个乐观锁

悲观锁：悲观，一开始就加锁。

正是由于有了悲观锁，所以才会有其他锁的概念。

二、锁

1.synchronized同步锁

同步锁synchronized，是一种悲观锁
synchronized关键字：表示“同步”的。它可以对“多行代码”进行“同步”——将多行代码当成是一个完整的整体；
一个线程如果进入到这个代码块中，会全部执行完毕，执行结束后，其它线程才会执行。这样可以保证这多行的代码作为完整的整体，被一个线程完整的执行完毕。
使用方法有两种：

  1. 同步方法
  2. 同步代码块

但是有一个致命的缺点就是数据同步的问题，尤其是遇到减法的时候，可能会导致超卖等真实问题。

同步代码块

用于方法中的某个区块中，表示只对这个区块的资源实行互斥访
问

synchronized(同步锁){
  需要同步操作的代码
}

1. 锁对象 可以是任意类型。
2. 多个线程对象 要使用同一把锁。

例子：

Object lock = new Object();

synchronized (lock) {
	if(ticket>0){//有票 可以卖
		//出票操作
		//使用sleep模拟一下出票时间
		try {
			Thread.sleep(50);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//获取当前线程对象的名字
		String name = Thread.currentThread().getName();
		System.out.println(name+"正在卖:"+ticket--);
	}
}

同步方法

保证A线程执行该方法的时候,其他线程只能在方法外等着

public synchronized void method(){
    里面是可能会产生线程安全问题的代码
}

对于非static方法,同步锁就是this当前调用者对象。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

public synchronized void sellTicket(){
    if(ticket>0){//有票 可以卖
      //出票操作
      //使用sleep模拟一下出票时间
      try {
      Thread.sleep(100);
     } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
      //获取当前线程对象的名字
      String name = Thread.currentThread().getName();
      System.out.println(name+"正在卖:"+ticket--);
   }
}

2.lock锁


从api文档可知，lock是一个接口，有三个实现类，分别是：

  • ReentrantLock 可重入锁
  • ReentrantReadWriteLock.ReadLock 读锁
  • ReentrantReadWriteLock.WriteLock 写锁

ReentrantLock 可重入锁

我们正常使用lock锁，是new 一个可重入锁对象使用的
ReentrantLock有两个实现类

  • ReentrantLock（） 默认非公平锁
  • ReentrantLock（boolean fair） true为公平，false非公平
    例子
Lock lock = new ReentrantLock();
业务方法（）{
	lock.lock(); //加锁
	try{
		线程不安全的操作
	}catch(){
	
	} finally{
		lock.unlock(); //解锁
	}
}

ReentrantReadWriteLock 读写锁

本身是ReadWriteLock接口的唯一实现类

读可以被多线程同时读，但是写只能被一个线程写

第一步：创建读写锁
ReadWriteLock lock = new ReentrantReadWriteLock();
第二步：对写的操作
lock.writeLock().lock();
lock.writeLock().unlock();
第三步：对读的操作
lock.readLock().lock();
lock.readLock().unlock();

3.java.util.（concurrent）.locks

这个locks下面有三个接口

  1. Condition 并发锁
  2. Lock 锁
  3. ReadWriteLock 读写锁

4.Synchronized和lock锁的区别

Synchronized 是关键字 无法判断获取锁的状态 自动加放锁 线程阻塞一直等待 可重入锁，非公平，不可终端， 是和少量代码的同步问题

Lock 是类 可判断获取锁的状态 手动加放锁 lock.tryLock()可以尝试获取锁，不会一直等待 可重入锁 适合大量代码

三、线程的通信

线程之间的通信其实就是线程支架你的等待唤醒和通知唤醒

比如，想线程之间交替执行，就需要实现线程之间的通信

有两个版本，第一个是Synchronized版本 ，另一个是JUC版本

1.Synchronized版本

使用的是wait和notify方法来实现

这里需要注意一个问题，不能用if，单线程个数超过2个的时候，会出现虚假唤醒，也就是同时唤醒多个线程，导致数据不对。。。所以等待应该总是出现在循环while中，防止虚化唤醒

class Data {
	private int number = 0;
	public syschronized void increment {
		while(number != 0) {
			this.wait();  // 等待，放锁
		}
		number ++; // 业务
		this.notifyAll(); // 唤醒通知其他线程，+1的业务操作执行完毕
	}

	public syschronized void decrement {
		while(number == 0) {
			this.wait();  // 等待，放锁
		}
		number --; // 业务
		this.notifyAll(); // 唤醒通知其他线程，-1的业务操作执行完毕
	}
}

class A {
	main() {
		Data data = new Data();
		new Thread(()-> for循环10执行data.increament());
		new Thread(()-> for循环10执行data.decreament());
	}
}

结果就是 一直10101010这样

2.JUC版本

JUC版本就是使用Lock中的Condition的await和signal方法

class Date {
	private int number = 0;
	Lock lock - new ReetrantLock();
	Condition condition = lock.new Condition();
	public void increment() {
		lock.lock();
		try{
			while(number != 0) {
				condition.await(); // 等待
			}
			number++;
			condition.signalAll(); // 唤醒
		}
	} catch（）{}
	finally{
		lock.unlock();
	}
	
}

减法decrement方法同理

Synchronized版本和JUC版本的区别就是：

JUC版本可以精准唤醒某一个线程，那就是使用signal而不是用signalAll，例子

使用多个condition对象，同步对象点击不同的await和signal方法来实现
如 condition2.signal那唤醒的就是用condition2.await的线程

四、自动释放锁 - jdk新特性

jdk7的新特性，自动释放锁- AutoCloseable
问题产生：

在开发中锁的释放是必须要做的事情，所以会把它放在 finally 中执行。但是在开发中往往很多时候都会忘记释放锁或者忘记把锁的释放放入 finally 中，就会造成死锁的现象，这就是一个危险的操作和行为。

问题解决：

使用 AutoCloseable 接口覆盖 close 方法。JDK 在1.7 之后出现了自动关闭类的功能，该功能的出现为各种关闭资源提供了相当大的帮助。实现 AutoCloseable 接口覆盖 close 方法，把原来要写 finally 中释放资源的动作放入到 close 方法中让 JVM 自动地去执行。

自动释放资源实现：

  • 实现 AutoCloseable 接口。
  • 接口的实现类要重写 close 方法。
  • 将要关闭的资源定义在 try 中，程序执行完毕之后，资源将会自动关闭。
public class MyLockDemo implements AutoCloseable {
    static Lock lock = new ReentrantLock();
    public static void main(String[] args) {
        try {
            lock.lock();
            System.out.println("1-----加锁成功");
            System.out.println("1-----开始执行业务逻辑");
            Thread.sleep(3000);
            System.out.println("3-----业务执行完毕");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void close() throws Exception {
        lock.unlock();
        System.out.println("4-----释放锁资源");
    }
}

五、案例

假如我要使用一个广告节目单，分为两个步骤：
步骤一：生成节目单
步骤二：发布节目单
判断条件：最新的发布时间 不能 在生成时间之后


	private static Date newestPublicDate = new Date();
	
	// 时间判断的方法
    public void updateNewestPublicDate(Date createTime) {
        synchronized (newestPublicDate) {
            if (newestPublicDate.after(createTime)) {
                String errMsg = MyPlanConstant.PC_CREATETIME_BEFORE_PUBLICTIME;
                logger.error(errMsg);
                throw new PlanException(EamErrorType.PC_ITEM_CREATE_ERROR.getValue(), errMsg);
            }
            newestPublicDate = createTime;
        }
    }
    
 /**
     * 生成节目单
     * 加一个互斥锁
     *
     * @param itemDto
     * @return
     */
    @Override
    @SaveLog
    @Transactional
    public synchronized List<ItemCache> moreCreateItem(ItemDto itemDto) {
		// 业务逻辑,存储生成时间在redis
	}
 /**
     *发布节目单
     */
    @SaveLog
    @Override
    @Transactional
    public void saveItem(ItemDto itemDto) {
		// 最新发布时间和生产时间做判断
	}

测试用例：

public void test(int i) {
        System.out.println("初始" + myCommonUtil.SDF2.format(newestPublicDate));

        Thread thread1 = new Thread(() -> {
            Date createTime1 = new Date();
            try {
                createTime1 = myCommonUtil.SDF2.parse("2022-07-22 00:00:00");
            } catch (ParseException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "启动");
            this.updateNewestPublicDate(createTime1, "甲");
            System.out.println(Thread.currentThread().getName() + "结束");
            System.out.println("甲线程" + myCommonUtil.SDF2.format(newestPublicDate));
        });
        thread1.setName("甲线程");

        thread1.start();

        Thread thread2 = new Thread(() -> {
            Date createTime2 = new Date();
            try {
                createTime2 = myCommonUtil.SDF2.parse("2022-07-21 00:00:00");
            } catch (ParseException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "启动");
            this.updateNewestPublicDate(createTime2, "乙");
            System.out.println(Thread.currentThread().getName() + "结束");
            System.out.println("乙线程" + myCommonUtil.SDF2.format(newestPublicDate));
        });
        thread2.setName("乙线程");
        thread2.start();


        Thread thread3 = new Thread(() -> {
            Date createTime2 = new Date();
            try {
                createTime2 = myCommonUtil.SDF2.parse("2022-07-26 00:00:00");
            } catch (ParseException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "启动");
            this.updateNewestPublicDate(createTime2, "丙");
            System.out.println(Thread.currentThread().getName() + "结束");
            System.out.println("丙线程" + myCommonUtil.SDF2.format(newestPublicDate));
        });
        thread3.setName("丙线程");
        thread3.start();


        Thread thread4 = new Thread(() -> {
            Date createTime2 = new Date();
            try {
                createTime2 = myCommonUtil.SDF2.parse("2022-07-27 00:00:00");
            } catch (ParseException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "启动");
            this.updateNewestPublicDate(createTime2, "订");
            System.out.println(Thread.currentThread().getName() + "结束");
            System.out.println("订线程" + myCommonUtil.SDF2.format(newestPublicDate));
        });
        thread4.setName("订线程");
        thread4.start();

        Thread thread5 = new Thread(() -> {
            Date createTime2 = new Date();
            try {
                createTime2 = myCommonUtil.SDF2.parse("2022-07-20 00:00:00");
            } catch (ParseException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "启动");
            this.updateNewestPublicDate(createTime2, "a");
            System.out.println(Thread.currentThread().getName() + "结束");
            System.out.println("a线程" + myCommonUtil.SDF2.format(newestPublicDate));
        });
        thread5.setName("a线程");
        thread5.start();


        Thread thread6 = new Thread(() -> {
            Date createTime2 = new Date();
            try {
                createTime2 = myCommonUtil.SDF2.parse("2022-07-29 00:00:00");
            } catch (ParseException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "启动");
            this.updateNewestPublicDate(createTime2, "b");
            System.out.println(Thread.currentThread().getName() + "结束");
            System.out.println("b线程" + myCommonUtil.SDF2.format(newestPublicDate));
        });
        thread6.setName("b线程");
        thread6.start();

        Thread thread7 = new Thread(() -> {
            Date createTime2 = new Date();
            try {
                createTime2 = myCommonUtil.SDF2.parse("2022-07-30 00:00:00");
            } catch (ParseException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "启动");
            this.updateNewestPublicDate(createTime2, "c");
            System.out.println(Thread.currentThread().getName() + "结束");
            System.out.println("c线程" + myCommonUtil.SDF2.format(newestPublicDate));
        });
        thread7.setName("c线程");
        thread7.start();

    }

六 线程安全的集合使用

文章

LC超人在良家
关注
专栏目录
java使用Lock锁实现线程的通讯
weixin_46054799的博客
06-11 5615
package com.liu.pc; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class B { public static void main(String[] args) { Data2 data = new Data2(.
JAVA线程锁：多线程通信
baidu_36415076的博客
01-13 314
synchronized重入锁（读<=写）//基本用法 public class UseReentrantLock { private Lock lock = new ReentrantLock(); public void method(){ try { lock.lock(); System.out.println(
学习java的第四十天，Lock（锁）、线程通信的学习
10719876
07-25 158
学习java的第四十天，Lock（锁）、线程通信的学习
Java多线程通讯——同步锁的高端操作
girls的博客
02-18 153
package thread; //资源相同，分工不同 //线程通信至少三个类 //凡是操作资源的语句都需要加上同步代码块（同步锁） //锁内的代码块执行完后，锁外的抢夺和输出同时进行（抢夺cpu） //根据布尔值控制（进和出的）等待和唤醒过程 public class _a8_多线程通信 { public static void main(String[] args) { Resourse r =new Resourse(); Input in = new Input(r); O
java保证线程安全关于锁处理的理解
weixin_36098377的博客
10-09 289
关于java里面保证线程安全关于锁的做法理解： 1、最大的锁，用synchronized锁住整个大方法，如单例模式的线程安全问题处理方式； 2、用synchronized或ReentrantLock锁住大方法内部会出现线程不安全的对象，如Vector、Collections.SynchronizedList和CopyOnWriteArrayList的方法实现； 3、用ConcurrentHashM...
Java线程间的通信方式详解
09-02
本文将详细介绍两种常见的Java线程通信方式：同步和while轮询。 1. 同步（Synchronized） 同步是Java中控制线程并发的一种手段，它通过`synchronized`关键字实现。在Java中，同步主要有两种形式：同步方法（通过在...
深入理解java线程通信
08-25
深入理解 Java 线程通信 Java 线程通信是 Java 编程中一个非常重要的概念，它可以使得多个线程之间能够相互通信和协作，从而实现更加复杂的任务。下面我们将深入理解 Java 线程通信的机制和实现方式。 一、等待...
深入理解Java 线程通信
08-19
"深入理解Java 线程通信" Java 线程通信是指在 Java 编程...Java 线程通信机制可以通过使用 wait()、notify() 和 notifyAll() 方法来实现线程间的交流和协作，使用同步锁和 volatile 变量等机制来保证线程协调运行。
深入解析Java的线程同步以及线程间通信
09-03
总之，Java的线程同步和线程间通信是多线程编程中的关键概念，通过`synchronized`关键字、同步块和监视器锁，以及`wait()`, `notify()`, `notifyAll()`等方法，可以有效地管理共享资源，避免并发问题，并实现线程间...
深入理解JAVA多线程之线程间的通信方式
09-02
在Java多线程编程中，线程间的通信是至关重要的，因为它确保了多个并发执行的任务能够协调工作，避免数据不一致性和死锁等问题。本文将深入探讨两种主要的线程间通信方式：同步机制和基于轮询的方式。 1. 同步机制...
java中锁的四种状态
热门推荐
张姐姐聊编程
06-20 1万+
在多线程并发编程中Synchronized一直是元老级角色，很多人都会称它为重量级锁，但是随着 Java SE1.6 对 Synchronized 进行了各种优化之后，有些情况下它并不那么重了，本文详细介绍了 Java SE1.6 中为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁，以及锁的存储结构和升级过程。
多线程为什么要使用锁？多线程如何保证线程安全？
ke1ying的博客
11-06 4497
多线程保证线程安全就是让多个线程执行的情况和单线程一样，读的时候是不影响线程安全的，但如果对数据操作，增加或者删除，几个线程同时进行，就会发生删多或者增加多的情况，这时候为了保证线程安全，就可以加对象锁。 并发不是很高的情况下，sychronized性能更好，优先选择，反之reentrantlock在高并发的情况下，性能会提高几十倍。或者使用reentrantlock三个独有的功能就选择reentrantlock： 两者都是可重入锁：都是同一个线程进入会+1，直到为0才释放锁， 两者.....
iOS之深入解析保证线程安全的“锁”的使用和性能分析
╰つ栺尖篴夢ゞ
04-11 8228
一、线程安全 在平时的开发中经常使用到多线程，在使用多线程的过程中，难免会遇到资源竞争的问题，那么怎么来避免出现这种问题呢？ 当一个线程访问数据的时候，其他的线程不能对其进行访问，直到该线程访问完毕。简单来讲就是在同一时刻，对同一个数据操作的线程只有一个。只有确保了这样，才能使数据不会被其他线程影响。而线程不安全，则是在同一时刻可以有多个线程对该数据进行访问，从而得不到预期的结果。 比如写文件和读文件，当一个线程在写文件的时候，理论上来说，如果这个时候另一个线程来直接读取的话，那么得到的结果可能是无法预料
334 - 线程通信问题
最新发布
xiaozhou的博客
10-21 236
线程通信问题
线程安全与锁机制
葱葱那年
09-01 560
一、什么是线程安全 线程安全：当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方法进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，即这个对象是线程安全的。 Java中的线程安全，就是多个线程之间访问共享数据时，能够正确访问。将Java中访问共享数据的操作由线程安全的“安全程度”由强至弱分为：不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。 （1）不可变：不可变对象一定是线程安全的，如final关键字修饰的基本数据类
synchronized 加锁保证线程安全
leo的博客
08-19 790
synchronized 锁 synchronized关键字最主要有以下3种应用方式： 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。   1 实例方法加锁 (非静态方法) 使用synchro...
线程安全的理解和如何保证线程安全
gukesdo的专栏
05-15 1万+
线程安全的理解和如何保证线程安全 http://www.cnblogs.com/mindsbook/archive/2009/10/15/thread-safety-and-GIL.html 线程是在多线程环境下，线程安全能够保证多个线程同时执行程序时依旧运行正确，而且要保证对于共享数据，可以由多个线程存取，但是同一时刻只能有一个线程进行存取。一般通过加锁的方式来实现。 加锁也分2种不同粒度
Java多线程入门篇（三）Java线程间的通信（锁，等待/通知，信号量，管道）
wangdawei_的博客
02-28 819
java多线程入门篇 （三） 锁与同步等待/通知机制信号量：管道：其它通信相关join方法sleep方法ThreadLocal类InheritableThreadLocal   在Java中合理的使用多线程可以更好的利用服务器资源。一般来说，线程都有自己的自由线程上下文，互不干扰。但是当我们需要多个线程之间互相协作的时候，就需要掌握Java线程的通信方式才可以 锁与同步   在Java中锁都是基于对象的，所以又称为对象锁。锁与线程的关系就像婚姻关系，一个锁在同一时间只能由一个线程持有，只有当持有锁的线程释放
Java与MySQL中的锁以及保证线程安全的方式
weixin_47867018的博客
06-16 1515
无论是存在硬盘里的数据还是存在内存中的数据，只要不是像Redis那样只支持单线程访问，就都存在线程安全问题。通常，在代码中，面对线程安全问题的态度，分为【悲观】和【乐观】。本文从这两个角度对Java与MySQL中的锁及保证线程安全的方式进行一个对比，尽量提炼出其中的相似之处。文中的某些地方会把Java中的【线程】与MySQL中的【事务】统称为【线程】。【悲观】认为，在当前环境下，极有可能发生线程安全问题，因此，需要把多线程共享的数据上一个重锁，在某个线程拥有这个数据的锁期间，其他线程无法对这个数据进行访问与
Java实现多线程通信详解
在Java编程中，多线程通信是一项重要的技术，它允许不同线程之间共享数据、同步执行，从而实现高效的并发处理。以下是对标题和描述中所述知识点的详细说明： 1. **虚假的多线程示例** 在上述例子中，创建了两个`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

LC超人在良家

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

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

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

打赏作者

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

抵扣说明：

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

余额充值