Java并发编程之Lock(同步锁、死锁)

简介: 这篇文章是接着我上一篇文章来的。

Java并发编程之Lock(同步锁、死锁)


这篇文章是接着我上一篇文章来的。

上一篇文章

同步锁

为什么需要同步锁?

首先,我们来看看这张图。

网络异常,图片无法展示
|

这是一个程序,多个对象进行抢票。

package MovieDemo;
public class ThM implements Runnable {
    private int count = 10;
    private int num = 0;
    @Override
    public void run() {
        while (true) {
                if (count <= 0) {
                    break;
                }
                num++;
                count--;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "抢到了第" + num + "个票"+"剩余票数:"+count);
        }
    }
}

线程类中代码很简单,就是当对象抢到票,count就会记录,每被抢一张就少一张。

当我们只有一个对象时,我们这个程序时正常的,但是当我们多个对象一起抢票时。因为线程是同时的,就像挤公交,多个人一起挤进去。

所以这里会出现多个人抢了同一张票的问题。

所以,当我们多个对象存在时,代码是这样运行的:

  1. 首先,多个线程的对象并发,也就是同时去抢票。
  2. 抢票的时候,多个对象都同时都抢到了票。
  3. 系统将会认为,这些对象都抢到了票,但是票只有一张,此时系统就出现错误了。
  4. 此时的关系就是几个人共享一张票

那再现实生活中,肯定不能这样,我们需要排队,肯定只能一个人对应一张票。

package MovieDemo;
public class Test {
    public static void main(String[] args) {
        ThM m = new ThM();
        Thread t = new Thread(m);
        Thread t1 = new Thread(m);
        Thread t2 = new Thread(m);
        t1.start();
        t2.start();
        t.start();
    }
}

这里有三个线程对象!

我们运行程序看看结果。

Thread-0抢到了第3个票剩余票数:7
Thread-1抢到了第3个票剩余票数:7
Thread-2抢到了第3个票剩余票数:7
Thread-0抢到了第6个票剩余票数:4
Thread-2抢到了第6个票剩余票数:4
Thread-1抢到了第6个票剩余票数:4
Thread-1抢到了第9个票剩余票数:1
Thread-0抢到了第9个票剩余票数:1
Thread-2抢到了第9个票剩余票数:1
Thread-1抢到了第10个票剩余票数:0

很明显看出来,这个程序就不对劲,0、1、2这三个人都抢到了同一张票。

那我们如何解决这种问题呢?

同步锁的使用

我们举个例子,一个公共厕所,一张门,你和一堆人都想进去上厕所,你此时进去了,但是其他人也要进来,你该怎么办?

此时,你明智的将厕所的门拉上(锁上),等你上完厕所,再开锁,下一位继续如此。

synchronize(Object)就是我们所说的这把锁。

Object是对象。

我们先看看这个“锁”的作用:

1.每个对象都有一个与它相关的内部锁(intrinsic lock)或者叫监视器锁(monitor lock)

2.第一个执行到同步语句的线程可以获得 obj 的内部锁,在执行完同步语句中的代码后释放此锁

3.只要一个线程持有了内部锁,那么其它线程在同一时刻将无法再获得此锁,当它们试图获取此锁时,将会进入BLOCKED状态

4.多个线程访问同一个 synchronized(Object)语句时,Object必须是同一个对象,才能起到同步的作用。

锁方法

同步锁用法很多,锁方法我们可以这样:

**实例方法:synchronized (this)

静态方法:synchronized (Class对象)**

注意的是,synchronized不能修饰构造方法!!!

锁语句

但是我们一般不喜欢直接锁住方法,就像,你有一个宝箱,你只需要锁住箱子,没必要将箱子所在的房子锁上。

**同步语句比同步方法更灵活一点

同步语句可以精确控制需要加锁的代码范围,减少处于BLOCKED状态的线程,充分利用劳动力**

实际操作

还是上面那个方法,我给它运行的部分加上锁!

package MovieDemo;
public class ThM implements Runnable {
    private int count = 10;
    private int num = 0;
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (count <= 0) {
                    break;
                }
                num++;
                count--;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "抢到了第" + num + "个票"+"剩余票数:"+count);
            }
        }
    }
}

实际上我锁住的是这一部分。

synchronized (this) {
    if (count <= 0) {
        break;
    }
    num++;
    count--;
    try {
        Thread.sleep(100);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName() + "抢到了第" + num + "个票"+"剩余票数:"+count);
}

this关键词指代当前线程的对象!

我们运行一下,看看还会不会出现之前的状况。

网络异常,图片无法展示
|

可能第二个对象运气好哈,就第一张票不是对象2抢到的。

但是,现在就是完全不会出现两个人抢到同一张票的故障了。

特别注意

运行类代码现在我改一下。

package MovieDemo;
public class Test {
    public static void main(String[] args) {
        ThM t = new ThM();
        ThM t1 = new ThM();
        ThM t2 = new ThM();
        t.start();
        t2.start();
        t1.start();
    }
}

此时我运行一下,会发生先去的故障。

网络异常,图片无法展示
|

因为此时,你的锁,锁的不是同一个对象。

而之前。

ThM m = new ThM();
Thread t = new Thread(m);
Thread t1 = new Thread(m);
Thread t2 = new Thread(m);

虽然是三个线程对象,但是他们new的对象都是m,也就是ThM类的对象,是同一个!

线程同步的优缺

使用了线程同步技术后:

  1. 虽然解决了线程安全问题,但是降低了程序的执行效率
  2. 因为加了锁就会有处于等待的线程,多了加锁解锁的操作
  3. 所以在真正有必要的时候,才使用线程同步技术。

死锁

什么是死锁:

两个或者多个线程永远阻塞,相互等待对方的锁

是并发下一组互相竞争资源的线程因互相等待导致永久阻塞的现象

CSDN上面一个大佬的举例就很好理解:

线程a占用对象锁1,线程b占用对象锁2

线程a需要继续占用对象锁2才能往下执行,所以线程a需要等待线程b释放对象锁2

线程b需要继续占用对象锁1才能往下执行,同样也需要线程a释放对象锁1

由于这2个线程都不释放自己已经占用的锁,所以这2个线程会处于无限等待状态

我说得比较通俗,就是,挤公交车,两个人互挤,但是谁也上不去!

网络异常,图片无法展示
|

这是那位博主的举例,很有意思哈。

为何会产生死锁?

  1. 互斥
  2. 占有且等待
  3. 不可抢占
  4. 循环等待

怎么说呢?

  • 互斥——>共享资源只能被一个线程占用,比如一个座位,只能容纳一个人,两个人都想做,谁也不让谁,那就都坐不了!
  • 占有且等待——>假设你此时有一个玩具,别的小朋友哪儿也有一个玩具,你想要两个玩具,你就拿着自己玩具不放手,然后等另一个小朋友不玩了,你就获得了两个玩具。
  • 不可抢占——>资源只能由持有它的线程自愿释放,其它线程不可强行占有该资源-无法释放对方资源。说白了,你不能抢别人的东西,(除非别人让你抢)。
  • 循环等待——>这个就拿上面的玩具解释,假设你此时有一个玩具,别的小朋友哪儿也有一个玩具,你想要两个玩具,你就拿着自己玩具不放手,然后等另一个不玩了再去拿,但是另一个小朋友也是一样,等你不玩了再去拿。此时就僵持了。

如何解决锁死的情况

首先!不能强制!不能直接去去掉死锁,这样不能保证线程安全。

那怎么办?找原因!解铃还须系铃人。也就是说,我们要打破上面4种原因中的任意一种。

大佬博客说的很好,我就直接搬过来了!

网络异常,图片无法展示
|

大佬博客在这

线程8锁

• 一个对象里面如果有多个synchronized方法,某一个时刻内,只要一个线程调用其中的一个synchronized方法了,其它的线程都只能等待,换句话说,某一个时刻内,只能有唯一一个线程去访问这些synchronized方法

锁的是当前对象this,被锁定后,其它的线程都不能进入到当前对象的其它的synchronized方法

• 加个普通方法后发现和同步锁无关

• 换成两个对象后,不是同一把锁了,情况立刻变化。

• 都换成静态同步方法后,情况又变化

所有的非静态同步方法用的都是同一把锁——实例对象本身,也就是说如果一个实例对象的非静态同步方法获取锁后,该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁,可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁,所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

所有的静态同步方法用的也是同一把锁——对象本身,这两把锁是两个不同的对象,所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后其他的静态同步方法必须等待该方法释放锁后才能获取锁,而不管是同一个实例对象的静态同步方法之间,还是不同的实例对象的静态同步方法之间,只要它们同一个类的实例对象,都得这样!!!

线程8锁可以说是个概念

我们记住以下两点:

① 非静态方法的默认锁是this ,静态方法的默认锁是class

②某一时刻内,只能有一个线程有锁,无论几个方法

相关文章
|
19天前
|
Kubernetes 负载均衡 Java
k8s的出现解决了java并发编程胡问题了
Kubernetes通过提供自动化管理、资源管理、服务发现和负载均衡、持续交付等功能,有效地解决了Java并发编程中的许多复杂问题。它不仅简化了线程管理和资源共享,还提供了强大的负载均衡和故障恢复机制,确保应用程序在高并发环境下的高效运行和稳定性。通过合理配置和使用Kubernetes,开发者可以显著提高Java应用程序的性能和可靠性。
63 31
|
20天前
|
Java 编译器 开发者
注解的艺术:Java编程的高级定制
注解是Java编程中的高级特性,通过内置注解、自定义注解及注解处理器,可以实现代码的高度定制和扩展。通过理解和掌握注解的使用方法,开发者可以提高代码的可读性、可维护性和开发效率。在实际应用中,注解广泛用于框架开发、代码生成和配置管理等方面,展示了其强大的功能和灵活性。
61 25
|
11天前
|
Java API Docker
在线编程实现!如何在Java后端通过DockerClient操作Docker生成python环境
以上内容是一个简单的实现在Java后端中通过DockerClient操作Docker生成python环境并执行代码,最后销毁的案例全过程,也是实现一个简单的在线编程后端API的完整流程,你可以在此基础上添加额外的辅助功能,比如上传文件、编辑文件、查阅文件、自定义安装等功能。 只有锻炼思维才能可持续地解决问题,只有思维才是真正值得学习和分享的核心要素。如果这篇博客能给您带来一点帮助,麻烦您点个赞支持一下,还可以收藏起来以备不时之需,有疑问和错误欢迎在评论区指出~
在线编程实现!如何在Java后端通过DockerClient操作Docker生成python环境
|
1月前
|
安全 Java 开发者
Java并发迷宫:同步的魔法与死锁的诅咒
在Java并发编程中,合理使用同步机制可以确保线程安全,避免数据不一致的问题。然而,必须警惕死锁的出现,采取适当的预防措施。通过理解同步的原理和死锁的成因,并应用有效的设计和编码实践,可以构建出高效、健壮的多线程应用程序。
47 21
|
21天前
|
Java 开发工具
课时6:Java编程起步
课时6:Java编程起步,主讲人李兴华。课程摘要:介绍Java编程的第一个程序“Hello World”,讲解如何使用记事本或EditPlus编写、保存和编译Java源代码(*.java文件),并解释类定义、主方法(public static void main)及屏幕打印(System.out.println)。强调类名与文件名一致的重要性,以及Java程序的编译和执行过程。通过实例演示,帮助初学者掌握Java编程的基本步骤和常见问题。
|
3月前
|
存储 缓存 Java
Java 并发编程——volatile 关键字解析
本文介绍了Java线程中的`volatile`关键字及其与`synchronized`锁的区别。`volatile`保证了变量的可见性和一定的有序性,但不能保证原子性。它通过内存屏障实现,避免指令重排序,确保线程间数据一致。相比`synchronized`,`volatile`性能更优,适用于简单状态标记和某些特定场景,如单例模式中的双重检查锁定。文中还解释了Java内存模型的基本概念,包括主内存、工作内存及并发编程中的原子性、可见性和有序性。
102 5
Java 并发编程——volatile 关键字解析
|
3月前
|
算法 Java 调度
java并发编程中Monitor里的waitSet和EntryList都是做什么的
在Java并发编程中,Monitor内部包含两个重要队列:等待集(Wait Set)和入口列表(Entry List)。Wait Set用于线程的条件等待和协作,线程调用`wait()`后进入此集合,通过`notify()`或`notifyAll()`唤醒。Entry List则管理锁的竞争,未能获取锁的线程在此排队,等待锁释放后重新竞争。理解两者区别有助于设计高效的多线程程序。 - **Wait Set**:线程调用`wait()`后进入,等待条件满足被唤醒,需重新竞争锁。 - **Entry List**:多个线程竞争锁时,未获锁的线程在此排队,等待锁释放后获取锁继续执行。
114 12
|
3月前
|
存储 安全 Java
Java多线程编程秘籍:各种方案一网打尽,不要错过!
Java 中实现多线程的方式主要有四种:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点,适用于不同的场景。继承 Thread 类最简单,实现 Runnable 接口更灵活,Callable 接口支持返回结果,线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外,还介绍了多线程相关的常见面试问题及答案,涵盖线程概念、线程安全、线程池等知识点。
310 2
|
Java
java并发编程:死锁代码示例
死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。
176 0
|
Java
一个简单的Java死锁示例(转)
在实际编程中,要尽量避免出现死锁的情况,但是让你故意写一个死锁的程序时似乎也不太简单(有公司会出这样的面试题),以下是一个简单的死锁例子,程序说明都写着类的注释里了,有点罗嗦,但是应该也还是表述清楚了的。
820 0