Java 中线程同步机制synchronized，互斥锁，死锁，释放锁的详解

已于 2023-01-07 09:37:26 修改
阅读量1.7k 收藏 5
点赞数 2
分类专栏： java笔记 文章标签： java synchronized 互斥锁 死锁 释放锁
于 2022-05-01 11:29:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lu202032/article/details/124523516
版权

博主前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住也分享一下给大家，
👉点击跳转到网站

一、线程同步机制synchronized的理解在这里插入图片描述
二、synchronized的具体使用
在这里插入图片描述
下面可以通过同步机制，解决多线程卖票，出现的超卖问题，代码如下

public class SellTicket {
    public static void main(String[] args) {
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里会出现超卖现象
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程
        /*
        输出结果：
        窗口 Thread-0 售出一张票剩余票数=2
        窗口 Thread-1 售出一张票剩余票数=-1
        售票结束
        窗口 Thread-0 售出一张票剩余票数=-2
        售票结束
        窗口 Thread-2 售出一张票剩余票数=0
        售票结束
         */

//        System.out.println("----使用实现接口的方式来售票----");
//        SellTicket02 sellTicket02 = new SellTicket02();
//        new Thread(sellTicket02).start();//第1个线程-窗口
//        new Thread(sellTicket02).start();//第2个线程-窗口
//        new Thread(sellTicket02).start();//第3个线程-窗口
        /*
        输出结果
        窗口 Thread-0 售出一张票剩余票数=2
        窗口 Thread-2 售出一张票剩余票数=1
        窗口 Thread-2 售出一张票剩余票数=0
        售票结束
        窗口 Thread-0 售出一张票剩余票数=-1
        售票结束
        窗口 Thread-1 售出一张票剩余票数=-2
        售票结束
        */


        System.out.println("----使用线程同步的方式来解决超卖票的情况----");
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();//第1个线程-窗口
        new Thread(sellTicket03).start();//第2个线程-窗口
        new Thread(sellTicket03).start();//第3个线程-窗口
        /*
        窗口 Thread-0 售出一张票剩余票数=6
        窗口 Thread-0 售出一张票剩余票数=5
        窗口 Thread-0 售出一张票剩余票数=4
        窗口 Thread-0 售出一张票剩余票数=3
        窗口 Thread-0 售出一张票剩余票数=2
        窗口 Thread-0 售出一张票剩余票数=1
        窗口 Thread-2 售出一张票剩余票数=0
        售票结束...
        售票结束...
        售票结束...
         */
    }
}

//使用Thread方式
class SellTicket01 extends Thread {
    private static int ticketNum = 100;//让多个线程共享

    @Override
    public void run() {
        while (true) {
            //在判断这个条件的时候，三个线程会同时进来 当ticketNum等于1时，
            //三个线程都进来了，会出现超卖的情况
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            //休眠50毫秒,模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + "剩余票数=" + (--ticketNum));
        }
    }
}


//实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            //休眠50毫秒,模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + "剩余票数=" + (--ticketNum));
        }
    }
}


//实现接口方式,使用synchronized实现线程同步
class SellTicket03 implements Runnable {
    private int ticketNum = 100;
    private boolean loop = true;

    public synchronized void sell() {//同步方法，在同一时刻，只能有一个线程来执行sell方法
        if (ticketNum <= 0) {
            System.out.println("售票结束...");
            loop = false;
            return;
        }
        //休眠50毫秒,模拟
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                + "剩余票数=" + (--ticketNum));
    }

    @Override
    public void run() {
        while (loop) {
            sell();//sell方法是一个同步方法
        }
    }
}

分析同步原理
在这里插入图片描述
三、互斥锁的介绍
在这里插入图片描述
下面演示在代码块中加锁，和方法上加锁，还是以上面的多线程卖票为例

//实现接口方式,使用synchronized实现线程同步
class SellTicket03 implements Runnable {
    private int ticketNum = 100;
    private boolean loop = true;
    Object object = new Object();//也可以用同一个对象，比如object，因为是三个线程共享一个object对象，满足三个线程共享一个对象

    //同步方法(静态的)的锁为当前类本身
    //1.public synchronized static void m1(){}锁 是加在SellTicket03.class
    //2.如果在静态方法中，实现一个同步代码块
    /*
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
     */
    public synchronized static void m1() {
    }

    public static void m2() {
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }

    //1. public synchronized void sell(){} 就是一个同步方法
    //2.也可以在代码块上写synchronized ,同步代码块,互斥锁还是在this对象
    public /*synchronized*/ void sell() {//同步方法，在同一时刻，只能有一个线程来执行sell方法
        synchronized (/*this*/object) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }
            //休眠50毫秒,模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + "剩余票数=" + (--ticketNum));
        }
    }

    @Override
    public void run() {
        while (loop) {
            sell();//sell方法是一个同步方法
        }
    }
}

互斥锁的注意细节如下
在这里插入图片描述
四、线程的死锁

在这里插入图片描述

public class DeadLock_ {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B线程");
        A.start();
        B.start();
    }
}

//线程
class DeadLockDemo extends Thread {
    static Object o1 = new Object();//保证多线程，共享一个对象，这里使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        //下面业务逻辑分析
        //1.如果flag为true，线程A就会先得到/持有 o1 对象锁,然后尝试去获取o2对象锁
        //2.如果线程A 得不到o2对象锁，就会Blocked
        //3.如果flag为false,线程B就会先得到/持有 o2 对象锁,然后尝试去获取o1对象锁
        //2.如果线程B 得不到o1对象锁，就会Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁，下面是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入1");
                synchronized (o2) {//这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + "进入2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入3");
                synchronized (o1) {//这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + "进入4");
                }
            }
        }
    }
}

输出结果

B线程 进入3
A线程 进入1

之后就卡在这里了，写代码时一定要避免

下面操作会释放锁
在这里插入图片描述
下面操作不会释放锁
在这里插入图片描述
线程相关的练习题如下
在这里插入图片描述
代码如下

public class HomeWork01 {
    public static void main(String[] args) {
        A a = new A();
        a.start();
        B b = new B(a);
        b.start();
    }
}

class A extends Thread {
    private boolean loop = true;

    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    @Override
    public void run() {
        while (loop) {
            System.out.println((int) (Math.random() * 100 + 1));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("a线程退出...");
    }
}

class B extends Thread {
    private A a;

    public B(A a) {//构造器中，传入A类对象
        this.a = a;
    }

    @Override
    public void run() {
        while (true) {
            //接收到用户的输入
            System.out.println("请输入命令");
            Scanner scanner = new Scanner(System.in);
            char c = scanner.next().toUpperCase().charAt(0);
            if (c == 'Q') {
                //以通知的方式结束A线程
                a.setLoop(false);
                break;
            }
        }
        System.out.println("b线程退出...");
    }
}

输出结果如下

85
请输入命令
8
41
79
81
75
41
29
Q
b线程退出...
a线程退出...

练习题二

在这里插入图片描述
代码如下

public class HomeWork02 {
    public static void main(String[] args) {
        Card card = new Card();
        new Thread(card).start();
        new Thread(card).start();
    }
}

//编程取款的线程
//1.因为这里涉及到多个线程共享线程资源，所以我们使用实现Runnable方式
class Card implements Runnable {
    private boolean loop = true;
    private int balance = 10000;

    @Override
    public void run() {
        while (loop) {
            //解读：
            //1.这里使用synchronized实现了线程同步
            //2.当多个线程执行到这里时，就会去争夺this对象锁
            //3.哪个对象争夺到(获取)this对象锁，就执行synchronized代码块，执行完成后，会释放this对象锁
            //4.争夺不到this对象锁，就blocked，准备继续争夺
            //5.this对象锁 是非公平锁
            synchronized (this) {
                if (balance < 1000) {
                    System.out.println("余额不足..");
                    loop = false;
                    return;
                }
                System.out.println(Thread.currentThread().getName() + " 取出1000 剩余余额为：" + (balance -= 1000));
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


}

输出结果如下

Thread-0 取出1000 剩余余额为：9000
Thread-1 取出1000 剩余余额为：8000
Thread-1 取出1000 剩余余额为：7000
Thread-0 取出1000 剩余余额为：6000
Thread-1 取出1000 剩余余额为：5000
Thread-0 取出1000 剩余余额为：4000
Thread-1 取出1000 剩余余额为：3000
Thread-0 取出1000 剩余余额为：2000
Thread-1 取出1000 剩余余额为：1000
Thread-0 取出1000 剩余余额为：0
余额不足..
余额不足..
路宇
关注
专栏目录
java synchronized加锁和释放流程
bpk_2的博客
01-05 4679
为什么需要加锁 在多线程环境中，多个线程同时运行同一个方法时，如果其中有对某一个资源就行修改处理时，可能会存在先后操作的问题，使得逻辑不一致，程序运行的结果不时我们想要的。 线程如何加锁 这里只讲synchronized进行加锁，并且只进行使用原理的阐述，其他加锁方式使用另外的篇幅。 加锁是为了避免多个线程同时进行逻辑处理时，可能会有数据不一致等情况从而影响程序的逻辑的准确性。 所以我们可以使用一个对象，给该对象设置一个锁状态标记，其他线程要进行逻辑处理时需要把该状态设置成功才能正常进行，不然就阻塞挂起。
Java多线程 ReentrantLock互斥锁详解
08-25
Java多线程ReentrantLock互斥锁详解 ReentrantLock是Java多线程编程中的一种锁机制，它可以实现线程之间的同步访问资源。ReentrantLock的主要特点是可以重入，即一个线程可以多次获得锁，而不需要释放锁。这种机制...
详解线程同步和线程互斥，Java如何实现线程同步和互斥
做兴趣使然的Hero
06-09 1142
最开始我们的操作系统的作业的调度单位是进程，但是由于每个进程都单独占据一个资源，而且进程的形态转换非常的耗费系统资源。为了系统的调度更加轻量级，能够更好的支持并发，因此引入了线程这个概念。...
多线程之线程安全（synchronized篇）：死锁问题及解决方法
最新发布
小蜗牛的珍贵百宝箱
09-26 693
线程安全是指多个线程同时访问共享资源时，不会因为线程之间的调度问题导致数据不一致或程序行为异常。为保证线程安全，常常需要同步访问共享资源，以确保同一时间只有一个线程可以操作这些资源。死锁是指两个或多个线程互相等待对方持有的锁，导致所有线程都无法继续执行的情况。简单来说，线程A持有锁1，等待锁2；而线程B持有锁2，等待锁1。此时，这两个线程都无法继续运行，程序进入了僵局。
Java同步锁何时释放？
CJaver的专栏
01-31 4875
任何线程进入同步代码块、同步方法之前，必须获得同步监视器的锁定，那么何时会释放这个锁定呢？在程序中，是无法显式释放对同步监视器的锁的，而会在如下几个情况下释放锁。 1、当前线程的同步方法、代码块执行结束的时候释放 2、当前线程在同步方法、同步代码块中遇到break 、 return 终于该代码块或者方法的时候释放。 3、。。。。出现未处理的error或者exception导致异常结束的时候释
Java互斥锁synchronized
wcy1900353090的博客
05-27 329
互斥锁是JDK6中引入的新特性 使用规则 一、锁对象设置 a、修饰代码块时，需要设置一个引用类型对象作为锁的同步监视器对象 b、修饰实例方法时，默认的同步监视器对象是当前对象 c、修饰类方法（静态方法）时、默认的同步监视器对象是当前类的Class对象 二、根据锁对象的不同，一把锁同时最多只能被一个线程拥有 a、若锁对象已被当前线程持有，则其他线程需要等待持有锁的线程释放锁后才能继续执行，否则就阻塞 b、synchronized 添加在方法上时只针对该方法在多线程同步执行时只有一个在运行，其.
Java 线程安全、线程同步、互斥锁、Lock锁、死锁、线程间通信
一只文森特
04-25 1960
Java 线程安全、线程同步、互斥锁、Lock锁、死锁、线程间通信
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
在Java多线程编程中，ReentrantLock提供了更灵活的锁管理机制，相比synchronized，它允许更细粒度的控制，并且提供了更多的同步原语。以下是一些使用ReentrantLock的关键点： 1. **可重入性**：ReentrantLock允许一...
详解Java中synchronized关键字的死锁和内存占用问题
09-02
Java中的`synchronized`关键字是用于实现线程同步的重要机制，其主要目的是确保多线程环境下的数据一致性与安全性。在Java中，`synchronized`可以应用于方法或代码块，以控制对共享资源的访问。 首先，`...
Java多线程同步机制与synchronized关键字详解
第十一章详细介绍了Java多线程的基础概念、创建方式、调度机制、同步机制以及与进程的关系，为开发者理解和实现高效的并发编程提供了必要的理论和实践指导。理解这些核心概念对于编写高性能、无竞态条件的并发程序至...
详解iOS 多线程 锁 互斥 同步
08-31
在iOS开发中，多线程的互斥同步是一个重要的概念，尤其是在处理共享资源时。当多个线程同时访问同一块内存地址时，可能会引发数据不一致的问题。为了解决这个问题，iOS提供了多种锁机制来确保线程安全。以下是五种...
java互斥锁_[Java并发-3]Java互斥锁，解决原子性问题
weixin_36416418的博客
02-15 171
在前面的分享中我们提到。一个或者多个操作在 CPU 执行的过程中不被中断的特性，称为“原子性”思考：在32位的机器上对long型变量进行加减操作存在并发问题，什么原因！？原子性问题如何解决我们已经知道原子性问题是线程切换，而操作系统做线程切换是依赖 CPU 中断的，所以禁止 CPU 发生中断就能够禁止线程切换。在单核 CPU 时代，这个方案的确是可行的。这里我们以 32 位 CPU 上执行 lon...
Java 多线程并发编程之互斥锁 Reentrant Lock
相思红叶似水年华
06-09 899
Java 中的锁通常分为两种： 通过关键字 synchronized 获取的锁，我们称为同步锁，上一篇有介绍到：Java 多线程并发编程 Synchronized 关键字。java.util.concurrent（JUC）包里的锁，如通过继承接口 Lock 而实现的 ReentrantLock（互斥锁），继承 ReadWriteLock 实现的 ReentrantReadWriteLoc
【Java 多线程】【Synchronized 原理&死锁】
OTO233的博客
08-04 554
比如：两个工人，只有一把锤子和钉子，一个人拿着锤，一个人拿着钉子，两人都需要对方持有的，但都不放下自己持有的，进入僵持状态；同一个线程，对同一把锁，加锁两次，可重入没有事，不可重入就会产生锁竞争，等待锁，自己竞争自己，自等待；存在锁竞争，尝试加锁状态，但不是真正的加锁，而是打上个偏向锁的标记，记录这个锁属于哪个线程。区分是否真正需要加锁，有其他的线程来打标记，JVM就会通知赶紧加上锁。锁竞争更加激烈，多条线程进入自旋，就会升级为重量级锁。延迟加锁，非必要，不加锁，避免加锁的开销。最有效解决死锁问题，就是。
synchronized什么情况下会释放锁?
zbh1957282580的博客
05-27 673
当一个线程在一个对象上调用notify()或notifyAll()方法时，它会唤醒等待在这个对象上的一个或多个线程，这些线程会尝试获取对象的锁。综上所述，synchronized会在代码块执行完毕、异常抛出、调用wait()方法以及调用notify()或notifyAll()方法时释放锁。当一个线程在一个对象上调用wait()方法时，它会释放这个对象的锁，使得其他线程能够访问这个对象。如果一个线程在执行synchronized代码块时抛出了异常，JVM会自动释放锁，以免造成死锁。
JAVA互斥锁
木卫
11-22 1616
package socket; /** * 互斥锁 * 当多个代码片被synchronized块修饰后，这些同步块的同步监听器对象又是同一个时 * 这些代码片端就是互斥的，多个线程不能同时在这些方法中运行 * @author ckx * */ public class SyncDemo4 { public static void main(String[] args) { Boo boo = new Boo(); Thread t1 = new Thread(){ pub
Java 多线程synchronized关键字详解(六)
09-03
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以避免数据不一致和竞态条件。在这个问题中，我们将深入理解`synchronized`的关键字用法，包括同步方法和同步块。 1. **...
java线程同步操作实例详解
08-27
synchronized关键字是Java中最基本的线程同步机制。它可以用来锁定一个对象或一个代码块，以防止多个线程同时访问该对象或代码块。synchronized关键字可以用来修饰方法、代码块或静态方法。 例如，在上面的代码中，...
JAVA中的互斥锁
weixin_43709238的博客
01-04 1379
无
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

路宇

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

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

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

打赏作者

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

抵扣说明：

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

余额充值