并发编程4 - 线程状态、死锁及ReentrantLock

最新推荐文章于 2024-04-19 10:45:48 发布
最新推荐文章于 2024-04-19 10:45:48 发布
阅读量576 收藏 1
点赞数
分类专栏： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39505091/article/details/119079042
版权

文章目录

一. 再述线程状态转换

在这里插入图片描述
情况1：New ——》RUNNABLE
当调用 t.start() 方法时

情况2：RUNNABLE 《——》WAITING
线程 synchronized(obj) 获得锁以后，调用 obj.wait 方法，状态将从 RUNNABLE ——》WAITING；调用 notify、notifyAll、interrupt 方法，如果：
- 竞争锁失败，线程从 WAITING ——》 BLOCKED
- 竞争锁成功，线程从　WAITING ——》RUNNABLE

注意 BLOCKED 状态与 WAITING 状态的区别：
waiting：主动为之，wait()方法释放cpu执行权和释放锁进入等待队列，需要notify()唤醒进入同步队列竞争锁；
blocked：被动的，在竞争锁的时候失败，被阻塞，在同步队列里继续竞争锁。

情况3：RUNNABLE 《——》WAITING

  • 当当前线程调用 t.join() 方法时，当前线程从 RUNNABLE ——》WAITING。
  • t 线程运行结束，或调用了当前线程的 interrupt()，当前线程从 WAITING ——》RUNNABLE 。

情况4：RUNNABLE 《——》WAITING

  • 当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE ——》WAITING；
  • 调用 LockSupport.unpark(t) 或调用了线程的 interrupt()，会让目标线程从 WAITING ——》RUNNABLE 。

情况5/6/7/8：RUNNABLE 《——》TIMED_WAITING

调用 obj.wait(n)、t.join(n)、Thread.sleep(n)、LockSupport.parkNanos(n)、LockSupport.parkUntil(n) 时，线程从 RUNNABLE ——》TIMED_WAITING。

注意：调用sleep(long)方法不会释放锁，时间到了自己返回原状态。

情况9：RUNNABLE 《——》BLOCKED

  • t 线程用 synchronized(obj) 竞争对象锁失败时，从 RUNNABLE ——》BLOCKED；
  • 获得锁的线程执行完毕后，会唤醒所有阻塞的线程重新竞争，竞争成功的从 BLOCKED ——》RUNNABLE

情况10：RUNNABLE ——》TERMINATED
线程中的代码全部执行完毕，RUNNABLE ——》TERMINATED。

二. 多把锁与线程活跃性问题

1. 多把锁

当两个业务完全不相干时，可以选择更加细粒度的锁，增加程序的并发性。

class MultiLock {
    //两个对象锁
    private Object bedRoom = new Object();
    private Object studyRoom = new Object();
    
    public void sleep() {
        //不再锁住 this 对象，而是更加细粒度的锁
        synchronized (bedRoom) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public void study() {
        synchronized (studyRoom) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2. 活跃性

（1）死锁

但是当一个程序中存在多把锁，而一个线程需要同时获得多把锁时，就容易发生死锁。

public class MultiLockTest {
    final static Logger logger = LoggerFactory.getLogger(MultiLockTest.class);
    public static void main(String[] args) {
        Object lock1 = new Object();
        Object lock2 = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                try {
                    logger.info("lock 1 ……");
                    Thread.sleep(1000);
                    synchronized (lock2) {
                        logger.info("lock 2 ……");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                try {
                    logger.info("lock 2 ……");
                    Thread.sleep(2000);
                    synchronized (lock1) {
                        logger.info("lock 1 ……");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}

在这里插入图片描述
(2) 定位死锁

方式1：jps + jstack
在这里插入图片描述在这里插入图片描述
方式2：jconsole

连接——》线程——》检测死锁
在这里插入图片描述
（3）哲学家就餐问题

在这里插入图片描述
程序模拟死锁问题：

筷子类

class Chopstick {
    private String name;
    public Chopstick(String name) {
        this.name = name;
    }
}

哲学家类

class Philosopher extends Thread {
    Logger logger = LoggerFactory.getLogger(Philosopher.class);
    //模拟左右两根筷子
    private Chopstick left;
    private Chopstick right;

    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
    }

    @Override
    public void run() {
        while(true) {
        	//需要两根筷子才能吃饭
            synchronized (left) {
                synchronized (right) {
                    logger.info("eating ……");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

测试类

public class PhilosopherTest {
    public static void main(String[] args) {
        Chopstick c1 = new Chopstick("c1");
        Chopstick c2 = new Chopstick("c2");
        Chopstick c3 = new Chopstick("c3");
        Chopstick c4 = new Chopstick("c4");
        Chopstick c5 = new Chopstick("c5");

        new Philosopher("p1", c1, c2).start();
        new Philosopher("p2", c2, c3).start();
        new Philosopher("p3", c3, c4).start();
        new Philosopher("p4", c4, c5).start();
        new Philosopher("p5", c5, c1).start();

    }
}

在这里插入图片描述
jconsole检测结果，五个线程均陷入死锁：
在这里插入图片描述
（4）活锁

当两个线程都在改变对方的运行结束条件时会发生活锁。
示例：

public class LiveLockTest {
    static int count = 10;
    private static final Logger logger = LoggerFactory.getLogger(LiveLockTest.class);

    public static void main(String[] args) {
        new Thread(() -> {
            while (count > 0) {
                count--;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                logger.info("count: " + count);
            }
        }, "t1").start();
        new Thread(() -> {
            while (count < 20) {
                count++;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                logger.info("count: " + count);
            }
        }, "t2").start();

    }
}

在这里插入图片描述

与死锁的不同：死锁是两个线程都陷入了阻塞状态，而活锁是两个线程都在运行，只是无法结束。
解决活锁问题，可以使两个线程交错运行，或者增加随机睡眠时间。

Thread.sleep(new Random().nextInt(1000));

（5）饥饿

饥饿：一个线程由于优先级太低，始终得不到CPU调度执行，也不能够结束。

比如之前的哲学家就餐问题，为避免死锁问题，我们可以通过采用顺序获取锁的方式解决：

new Philosopher("p1", c1, c2).start();
new Philosopher("p2", c2, c3).start();
new Philosopher("p3", c3, c4).start();
new Philosopher("p4", c4, c5).start();
new Philosopher("p5", c1, c5).start(); //获取锁的方式改为 c1, c5

但是日志显示，P4和P3线程获取锁的几率较高，而P5线程几乎获取不到锁，这就是饥饿现象：
在这里插入图片描述

三. ReEntrantLock

1. 基本用法

//获取锁，只有获取到了锁后面的代码才会继续执行，否则将一直阻塞在这里
reentrantLock.lock();
try {
	// 临界区 
} finally {
	// 释放锁
	reentrantLock.unlock();
}

2. 可重入

可重入是指同一个线程如果已经获得了一把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁。
如果是不可重入锁，那么第二次获取锁时，自己也会被锁挡住。

synchronized 也是可重入锁。

public class ReEntrantLockTest {
    private static final Logger logger = LoggerFactory.getLogger(ParkTest.class);
    public static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        lock.lock();
        try {
            logger.info("enter main……");
            m1();
        } finally {
            lock.unlock();
        }
    }

    public static void m1() {
        lock.lock(); //可重入
        try {
            logger.info("enter m1……");
        } finally {
            lock.unlock();
        }
    }
}

3. 可打断

可打断表明可以打断一直处于等待锁状态的线程，避免死锁。

synchronized 是不可打断锁，因为interrupt() 方法只是将打断标记设置为 true，当线程未获取到锁处于阻塞状态下时，并没有显式抛出异常。而处于WAITING 状态下的线程可被打断是因为 wait、sleep、join 这些方法会检查打断标记，并抛出InterruptedException异常。为什么synchronized不可打断

ReentrantLock的 lock 方法也是不可打断的，而 lockInterruptibly() 方法 是可打断的。
示例：

public class ReEntrantLockTest {
    private static final Logger logger = LoggerFactory.getLogger(ParkTest.class);
    public static ReentrantLock lock = new ReentrantLock();
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                logger.info("t1线程尝试获取锁……");
                lock.lockInterruptibly();
                logger.info("t1获取到锁……");
                lock.unlock();
            } catch (InterruptedException e) {
                logger.info("t1线程没有获取到锁……");
                e.printStackTrace();
            }
        });

        lock.lock();
        logger.info("主线程获取到锁……");
        t1.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.interrupt();
    }
}

在这里插入图片描述
查看 lockInterruptibly() 方法的源码发现，它其实也是通过检查打断标记抛出InterruptedException异常，来实现可打断的功能：

lockInterruptibly 源码：在这里插入图片描述
在这里插入图片描述

4. 锁超时

tryLock() 与 tryLock(long timeout, TimeUnit unit) 方法允许线程自己设置锁等待时间，前者没有获取到锁立即返回，后者会等待一定的时间，超过时间没有获取到锁则返回。

public class TryLockTest {
    private static final Logger logger = LoggerFactory.getLogger(TryLockTest.class);
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            logger.info("尝试获取锁");
            try {
                if (! lock.tryLock(2, TimeUnit.SECONDS)) {
                    logger.info("没有获取到锁");
                    return; //没获取到锁需要返回
                }
            } catch (InterruptedException e) { //带参数的tryLock方法也允许被打断
                e.printStackTrace();
                logger.info("没有获取到锁");
                return;
            }
            //获取到了锁需要执行的代码
            try {
                logger.info("获取到了锁");
            } finally {
                lock.unlock();
            }
        }, "t1");
        logger.info("获取了锁");
        lock.lock();
        t1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("释放了锁");
        lock.unlock();
    }
}

使用 tryLock() 解决哲学家就餐问题：

由于不能再使用 synchronized 锁住筷子对象，则筷子对象本身就需要具有锁特性。因此，这里将筷子类继承 ReentrantLock 类。

class Chopstick extends ReentrantLock {
    private String name;
    public Chopstick(String name) {
        this.name = name;
    }
}

将 synchronized 换成 tryLock 或者 tryLock(long timeout, TimeUnit unit) :

class Philosopher extends Thread {
    Logger logger = LoggerFactory.getLogger(Philosopher.class);
    private Chopstick left;
    private Chopstick right;

    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
    }

    @Override
    public void run() {
        while(true) {
        	//将synchronized换成 tryLock
            if (left.tryLock()) {
                try {
                    if (right.tryLock()) {
                        try {
                            logger.info("eating ……");
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } finally {
                            right.unlock();
                        }
                    }
                } finally {
                	//解决死锁的关键就在于右筷子拿不到时会释放左筷子
                    left.unlock();
                }
            }
        }
    }
}

在这里插入图片描述

5. 公平锁

synchronized 锁是不公平锁，即当锁被释放时，阻塞队列里的线程会同时去争抢锁，而不是按照进入阻塞队列的顺序获取锁。

ReentrantLock 默认是不公平锁，可以通过改变其构造方法将其设置为公平锁：

ReentrantLock lock = new ReentrantLock(true);

公平锁可以用来解决饥饿问题，但是会降低并发度，一般无需设置。

6. 条件变量

与 synchronized 的 wait/notify 类似的概念，当条件不满足时，为了不阻塞其他线程用锁，可以进入 waitSet 等待。

ReentrantLock 的条件变量更强大的地方在于，它支持多个条件变量，即等待不同条件的线程可以进入不同的等待室。

使用流程：

  • await 前需要获得锁；
  • await 执行后会释放锁，进入 conditionObject 等待；
  • await 的线程被唤醒（或打断、或超时）后，需要重新竞争锁；
  • 竞争锁成功后，从await 后继续执行。

await / signal 使用示例：

public class ReEntrantLockTest {
    private static final Logger logger = LoggerFactory.getLogger(ParkTest.class);
    public static ReentrantLock lock = new ReentrantLock();
    static boolean condition1 = false;
    static boolean condition2 = false;

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

        Condition waitSet1 = lock.newCondition();
        Condition waitSet2 = lock.newCondition();

        Thread t1 = new Thread(() -> {
            lock.lock();
            try {
                while (!condition1) {
                    try {
                        logger.info("条件1不满足，进入等待");
                        waitSet1.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                logger.info("t1 开始执行");
            } finally {
                lock.unlock();
            }

        }, "t1");

        Thread t2 = new Thread(() -> {
            lock.lock();
            try {
                while (!condition2) {
                    try {
                        logger.info("条件2不满足，进入等待");
                        waitSet2.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                logger.info("t2 开始执行");
            } finally {
                lock.unlock();
            }
        }, "t2");

        t1.start();
        t2.start();
        Thread.sleep(2000);
        lock.lock();
        try {
            logger.info("通知t1执行……");
            condition1 = true;
            waitSet1.signal();

            logger.info("通知t2执行……");
            condition2 = true;
            waitSet2.signal();
        } finally {
            lock.unlock();
        }
    }
}

在这里插入图片描述

weixin_39505091
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java并发编程专题（五）----详解（JUC）ReentrantLock
08-18
Java并发编程中的ReentrantLock是Java并发包（java.util.concurrent，简称JUC）中的一个重要的锁机制，它是Lock接口的一个具体实现，提供了比synchronized更强大的锁定功能和更细粒度的控制。ReentrantLock的主要...
Java并发编程进程和线程之由来Java开发Java经验技
11-22
总结来说，Java并发编程深入理解和熟练掌握进程与线程的概念及操作，是Java开发者必备的技能。通过使用Java提供的并发工具和最佳实践，可以有效地编写出高效、安全的并发代码，以应对复杂的多线程应用场景。
锁-ReentrantLock
weixin_41998947的博客
06-17 657
ReentrantLock
ReentrantLock中tryLock()和Lock()方法的区别
m0_53611007的博客
10-03 2016
ReentrantLock: Lock():阻塞加锁，无返回值，如果该线程没有获得锁就阻塞，直到获得锁放开 tryLock()：尝试枷锁，布尔类型返回值，线程有锁返回true，反之返回false，不会阻塞 利用tryLock()可以有自旋锁， 自旋锁对cpu消耗较大，但是性能要优于lock()方法 ...
ReentrantLock详解
最新发布
超级博客
04-19 717
ReentrantLock 是 Java 并发包（java.util.concurrent.locks）中的一个可重入锁实现，它提供了比 synchronized 关键字更灵活、功能更丰富的线程同步机制。ReentrantLock类内部总共存在Sync、NonfairSync、FairSync三个类，NonfairSync（非公平锁）与FairSync（公平锁）类继承自Sync类，Sync类继承自AbstractQueuedSynchronizer抽象类。
ReentrantLock可重入、可打断、锁超时实现原理
m0_73311735的博客
10-13 1063
本文主要从使用到原理讲解了ReentrantLock锁的可重入、可打断和锁超时的特性，希望对大家有帮助。
死锁和活锁的理解
u011186019的专栏
03-23 6593
活锁：就是指线程一直处于运行状态，但却是在做无用功，而这个线程本身要完成的任务却一直无法进展。就想小猫追着自己的尾巴咬，虽然一直在咬 却一直没有咬到。活锁的典型例子是某些重试机制导致一个交易（请求）被不断地重试，而每次重试都是失败的（线程在做无用功），这就导致其他失败 的交易无法得到重试的机会（任务无法进展），简单理解：就是一直尝试去获取需要的锁，不断的try,这种情况下线程并没有阻塞，所以是
经典面试题-wait vs sleep
xiaoshiguang3的博客
07-18 578
多线程中的wait和sleep有何异同点
java并发编程专题（三）----详解线程的同步
08-18
Java并发编程中的线程同步是确保多线程环境下数据一致性与正确性的关键技术。在Java中，线程同步主要是为了避免多个线程同时访问共享资源，从而可能导致数据不一致的问题。本文将深入探讨线程同步的概念、临界区的...
Java 并发编程实战-随书源码
04-27
9. **死锁、活锁和饥饿**：这些是并发编程中常见的问题，了解它们的原理和避免策略至关重要。 10. **jcip-examples-src**：这个子文件夹可能包含了《Java并发编程实战》书中提到的各种示例代码，涵盖了上述知识点的...
Java并发编程-线程安全与基础构建模块
04-04
在Java编程领域，多线程并发是不可或缺的一部分，特别是在服务器端和高并发应用中。本文将深入探讨"Java并发编程-线程安全与基础构建模块"这一主题，旨在帮助开发者理解如何有效地处理并发问题，提高程序性能和稳定...
第四章并发编程基础
BuZiShuoquoto的博客
07-06 146
线程简介 什么是线程 进程：现代操作系统运行一个程序时，会为其创建一个进程。（进程可以认为是运行着的程序，活着的程序）。 线程：现代操作系统的最新调度单位就是线程，线程也称为轻量级进程（Light Weight Process）。 一个进程中可以包含多个线程，这些线程有自己的计数器、堆栈、和局部变量属性，并且能够访问共享的内存变量。 为什么线程能够同时执行：处理器在不同的线程间高速切换，让使用者感...
Java线程并发中的锁——ReentrantLock（重入锁）原理详解
路漫漫，水迢迢
05-20 8719
ReentrantLock是一个重入锁，可以支持一个线程对资源重复加锁，他还支持公平加锁和非公平加锁。synchronized关键字也隐式的支持重进入，比如一个synchronized修饰的递归方法，在方法执行时，执行线程在获取了锁之后仍能连续多次地获得该锁ReentrantLock虽然没能像synchronized关键字一样支持隐式的重进入，但是在调用lock()方法时，已经获取到锁的线程，能够再
ReentrantLock学习总结
Nill_K的博客
09-15 103
ReentrantLock锁和synchronized锁相比具有以下特点： 可被中断：即可以设置“可中断锁”，当t1线程获取不到锁对象处于Blocked状态时，可由另一个线程调用t1的interrupt方法将其中断，此时t1会抛出被打断异常。 可以设置超时时间：如果没有获取到锁对象处于Blocked状态时，t1线程可以自己决定要等待多久。 可以设置为公平锁。 支持多个条件变量，即不同线程可以处于不同的waitSet进行等待，唤醒时也可以按照waitSet唤醒。 ReetrantLock的打开方式：
Java面试题12-ReentrantLock中tryLock和lock方法的区别
z318913的博客
09-01 887
ReentrantLock中tryLock和lock方法的区别
reentrantlock非公平锁不会随机挂起线程?_Java多线程-同步与锁机制
weixin_39739395的博客
11-20 126
1 同步的含义1 原子性2 内存可见性(一个线程修改对象的状态后，其他线程可看到状态的改变)2 保证线程安全的本质保证线程安全的手段(1)不在线程之间共享该状态变量。(2)将状态变量修改为不可变的变量。(3)在访问状态变量时使用同步。3 死锁发生的四个条件互斥，持有，不可剥夺，环形等待4 JVM发生死锁如何恢复JVM在解决死锁，只能重启恢复程序。5 乐观锁与悲观锁(1)乐观锁对于细粒度的操作，有一...
线程安全（三）实现方法sychronized与ReentrantLock（阻塞同步）
relife
04-14 1188
sychronized和lock
ReentrantLock替换synchronized解决多线程并发死锁，Java
Zhang Phil
11-01 445
Java并发多线程环境中，造成死锁的最简单的场景是：多线程中的一个线程T_A持有锁L1并且申请试图获得锁L2，而多线程中另外一个线程T_B持有锁L2并且试图申请获得锁L1。线程的锁申请操作是阻塞的，于是造成线程T_A和线程T_B无法正确获得想要的锁，两个线程被阻塞进入死锁状态。Java线程同步锁ReentrantLock和Condition中断等待程序前提条件满足_zhangphil的博客-CSDN博客。
ReentrantLock的使用
程序员的天堂
02-01 287
      ReentrantLock是一个可重入的互斥锁，重入锁是一种递归无阻塞的同步机制。ReentrantLock由最近成功获取锁，还没有释放的线程所拥有，当锁被另一个线程拥有时，调用lock的线程可以成功获取锁。如果锁已经被当前线程拥有，当前线程会立即返回。   重入锁的构造方法提供一个可选的公平参数：      公平情况下，操作会排一个队按顺序执行，来保证执行顺序。      ...
JAVA并发编程入门：线程基础与实战解析
"并发编程——线程基础.pdf" 在并发编程中，线程是核心概念之一。线程基础是Java编程中的重要组成部分，特别是在构建高效、响应迅速的多用户应用程序时。本课程深入浅出地讲解了Java中线程的基础知识，适合初学者和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值