Java并发之同步与锁

最新推荐文章于 2023-05-25 19:10:49 发布
最新推荐文章于 2023-05-25 19:10:49 发布
阅读量398 收藏
点赞数
分类专栏： 并发编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59287292/article/details/121791560
版权
本文探讨了Java中Concurrent包的ReentrantLock和Condition类在多线程中的应用，通过实例解析了test1(), test2(), test3()方法的工作原理，重点讲解了锁的获取、释放、竞争以及Condition的使用。
摘要由CSDN通过智能技术生成 
public class Concurrent3 {

    static Object obj = new Object();
    static Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        for(int i = 0 ; i < 10 ; i++){
            test1();
        }

    }

    private static void test1() {

        Thread t = new Thread(() -> {
           synchronized (obj){
               try {
                   System.out.println("hello");
                   Thread.sleep(1000);
               }catch (Exception e){
                   e.printStackTrace();
               }
           }
        });
        t.start();
    }

    public static void test2(){
        Thread t = new Thread(() -> {

            try {
                lock.lock();
                System.out.println("hello");
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                   lock.unlock();
            }
        });
        t.start();
    }
    
}

运行test1()和test2()
都是每隔一秒打印一句Hello
在这里插入图片描述
lock.tryLock();表示尝试获取锁
成功获取的话返回true
获取失败返回false

public static void test3(){
        Thread t = new Thread(() -> {
            boolean b = false;
            try {
                b = lock.tryLock();
                if(b){
                    System.out.println("hello");
                    Thread.sleep(1000);
                }

            }catch (Exception e){
                e.printStackTrace();
            }finally {
                if(b)   lock.unlock();
            }
        });
        t.start();
    }

在这里插入图片描述
原因：线程1获取了锁成功，b==true
其他线程获取锁失败所以就没有执行输出语句

   public static void test3(){
        Thread t = new Thread(() -> {
            boolean b = false;
            try {

                b = lock.tryLock(1500L, TimeUnit.MILLISECONDS);
                if(b){
                    System.out.println("hello");
                    Thread.sleep(1000);
                }

            }catch (Exception e){
                e.printStackTrace();
            }finally {
                if(b)   lock.unlock();
            }
        });
        t.start();
    }

在这里插入图片描述
在这里插入图片描述

obj.wait();//表示释放锁，

obj.wait():表示拿了锁然后把他释放掉,进入阻塞，等待被唤醒
obj.notify():唤醒一个调用wait（）方法进入阻塞的线程,前提是你也占用了锁资源

static Object obj = new Object();
    static Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        for(int i = 0 ; i < 10 ; i++){
            test1();
        }
        Thread.sleep(2000);
        obj.notify();
    }

    private static void test1() {

        Thread t = new Thread(() -> {
           synchronized (obj){
               try {
                   obj.wait();
                   System.out.println("hello");
                   Thread.sleep(1000);
               }catch (Exception e){
                   e.printStackTrace();
               }
           }
        });
        t.start();
    }

    public static void test2(){
        Thread t = new Thread(() -> {

            try {
                lock.lock();
                System.out.println("hello");
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                   lock.unlock();
            }
        });
        t.start();
    }

执行会报错
在这里插入图片描述
修改：

static Object obj = new Object();
    static Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        for(int i = 0 ; i < 10 ; i++){
            test1();
        }
        Thread.sleep(2000);
        synchronized (obj){
            obj.notify();
        }

    }

    private static void test1() {

        Thread t = new Thread(() -> {
           synchronized (obj){
               try {
                   obj.wait();
                   System.out.println("hello");
                   Thread.sleep(1000);
               }catch (Exception e){
                   e.printStackTrace();
               }
           }
        });
        t.start();
    }

    public static void test2(){
        Thread t = new Thread(() -> {

            try {
                lock.lock();
                System.out.println("hello");
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                   lock.unlock();
            }
        });
        t.start();
    }

在这里插入图片描述
唤醒了一个阻塞线程，其他都在阻塞
obj.notifyAll();
唤醒所以

static Object obj = new Object();
    static Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        for(int i = 0 ; i < 10 ; i++){
            test1();
        }
        Thread.sleep(2000);
        synchronized (obj){
            obj.notifyAll();
        }

    }

    private static void test1() {

        Thread t = new Thread(() -> {
           synchronized (obj){
               try {
                   obj.wait();
                   System.out.println("hello");
                   Thread.sleep(1000);
               }catch (Exception e){
                   e.printStackTrace();
               }
           }
        });
        t.start();
    }

lock如何释放和唤醒锁

static Lock lock = new ReentrantLock();
Condition c1 = lock.newCondition();

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

zz@yuan
关注
专栏目录
Java并发编程系列15:同步锁synchronized(2)
fen_fen的专栏
01-09 2234
在https://blog.csdn.net/fen_fen/article/details/122392800遇到线程不安全问题 解决方法：使用synchronized 解析可参考：https://blog.csdn.net/fen_fen/article/details/121466128 1、synchronized代码块，代码示例 package runnable; // 定义一个实现了 Runnable 接口的类 class RunnableTest4 implements ..
Java并发之嵌套管程锁死详解
08-28
Java并发之嵌套管程锁死详解 Java并发编程中，嵌套管程锁死是一个经常出现的问题，严重影响着系统的性能和稳定性。嵌套管程锁死是由多个线程竞争资源导致的死锁现象。 嵌套管程锁死的发生： 嵌套管程锁死的发生是...
Java并发编程：同步锁、读写锁
weixin_34353714的博客
03-06 193
之前我们说过线程安全问题可以用锁机制来解决，即线程必要要先获得锁，之后才能进行其他操作。其实在 Java 的 API 中有这样一些锁类可以提供给我们使用，与其他对象作为锁相比，它们具有更强大的功能。 Java 中的锁有两种，分别是：1）同步锁 2）读写锁 一、同步锁 　　同步锁（ReentrantLock）类似于 synchronize 代码块中传入的那个锁对象，可以用于进行线程同步。Ree...
Java并发编程——Synchronized同步锁
Java是世界上最好的语言
11-06 489
原子性问题 在下面的案例中，演示了两个线程分别去去调用 demo.incr 方法来对 i 这个变量进行叠加，预期结果应该是20000，但是实际结果却是小于等于20000的值。 public class AutoDemo { int i = 0; // synchronized 排它锁 互斥锁 --- 同一时刻只能由一个线程执行 public synchronized void incr() { i++; } public static void
synchoronize原理
疯一样的女子
11-13 910
并发编程中用到最多的关键字毫无疑问是synchronized。这篇文章就来探究下synchronized： synchronized如何使用？ synchronized是实现同步加锁的原理？ synchronized解决了并发编程的哪些问题？ 1. synchronized使用 1.1线程安全问题 并发编程中，当多个线程同时访问同一个资源的时候，就会存在线程安全问题。 由于每...
java同步锁案例_Java并发编程：同步锁、读写锁
weixin_28994935的博客
02-26 225
之前我们说过线程安全问题可以用锁机制来解决，即线程必要要先获得锁，之后才能进行其他操作。其实在 Java 的 API 中有这样一些锁类可以提供给我们使用，与其他对象作为锁相比，它们具有更强大的功能。Java 中的锁有两种，分别是：1)同步锁 2)读写锁一、同步锁同步锁(ReentrantLock)类似于 synchronize 代码块中传入的那个锁对象，可以用于进行线程同步。ReentrantLo...
基于Java并发编程的多线程同步与锁机制.zip
最新发布
09-06
基于Java并发编程的多线程同步与锁机制 项目简介 本项目旨在深入探讨Java并发编程中的多线程同步与锁机制，涵盖了从基础的线程创建、同步方法到高级的并发工具类如ReentrantLock、ReadWriteLock、Atomic类等的...
深入解析Java并发程序中线程的同步与线程锁的使用
09-02
Java并发编程中，线程的同步和线程锁的使用是确保多线程安全的关键技术。在Java中，`synchronized`关键字和`Lock`接口是实现线程同步的常见方式，它们主要用于解决多线程环境下的数据一致性问题，防止数据的不一致性...
Java并发问题之乐观锁与悲观锁
08-28
"Java并发问题之乐观锁与悲观锁" 在 Java 中，并发问题是非常重要的，因为多线程的存在会引起数据的不一致性和安全性问题。为了解决这些问题，Java 提供了多种锁机制，其中最常见的就是乐观锁和悲观锁。 悲观锁...
基于JDK源码解析Java领域中的并发锁之设计与实现.pdf
09-17
在Java并发编程中，理解和掌握并发锁的原理与实现至关重要，因为它们是解决多线程环境下的互斥和同步问题的关键。本文将基于JDK源码解析Java领域中的并发锁，探讨AQS基础同步器、LockSupport、Condition接口、Lock...
Java 同步锁(synchronized)详解及实例
08-30
主要介绍了Java 同步锁(synchronized)详解及实例的相关资料,需要的朋友可以参考下
Java 并发总结——高并发与同步锁
茅坤宝骏氹的博客
08-01 438
一、线程 （1）线程与进程 进程是一个实体，每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。 一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可
java---同步锁实例分析
hl6621的博客
12-07 360
同步锁synchronized是为了解决线程安全提出的，同步锁的作用，在这里我们用一个窗口售票的例子来详细讲解 首先，给出两种可以实现三个窗口完成100票的售卖，方法一就是继承Thread类，方法二就是实现Runnable接口 首先给出Thread类的继承，代码如下： ackage org.westos_07; public class SellTicket extends Thr
Java并发体系-锁与同步-[1]
xiejunxing的专栏
05-25 628
冯诺依曼，提出计算机由五大组成部分，输入设备，输出设备，存储器，控制器，运算器。输入设备：鼠标，键盘等等输出设备：显示器，打印机等等存储器：内存条运算器和控制器组成CPU一方面，程序员需要JMM提供一个强的内存模型来编写代码；另一方面，编译器和处理器希望JMM对它们的束缚越少越好，这样它们就可以最可能多的做优化来提高性能，希望的是一个弱的内存模型。JMM考虑了这两种需求，并且找到了平衡点，对编译器和处理器来说，
java同步锁实例_Java lock同步锁使用实例解析
weixin_42333411的博客
02-13 250
这篇文章主要介绍了Java lock同步锁使用实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1)Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现，synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，...
java 之 Lock 同步锁学习示例
ETHAN IN IT
03-21 1258
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class LockTest { /** * @param args */ public static void main(String[] args) { init(); }
线程同步 synchronized 同步代码块 同步方法 同步锁
dhxiyzqv45340的博客
01-09 322
一 同步代码块 1.为了解决并发操作可能造成的异常，java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块。其语法如下： synchronized(obj){ //同步代码块 } 其中obj就是同步监视器，它的含义是：线程开始执行同步代码块之前，必须先获得对同步监视器的锁定。任何时刻只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完...
java-Synchronized 一种同步锁：
qq_43617838的博客
11-27 165
java-Synchronized 一种同步锁： package com.company; import java.util.Vector; /** * synchronized 是一种同步锁 * * 修饰一个代码块 *　1、一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。 */ public class SynchronizedThread extends Thread { public static int count
并发编程基础篇（二）之同步锁
Cc461319777的博客
03-14 156
java常见使用的锁及其原理分析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值