2022/08/04 吉软 Java基础(18) 锁与线程池

最新推荐文章于 2024-05-23 21:40:23 发布

激进的圣诞树

最新推荐文章于 2024-05-23 21:40:23 发布

阅读量234

点赞数 1

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/panChong_/article/details/126156579

版权

学习目录

LockSupport 工具类（线程阻塞的工具类）

synchronized和Lock的区别：

Lock以下功能是synchronized不具备的！

lock锁的原理CAS和APS

并发编程三大特性：

java.util.concurrent.atomic下的JUC并发编程包

原子类Atomic

线程池

为什么要使用线程池？

JDK自带的四种线程池通过Executors提供的：

LockSupport 工具类（线程阻塞的工具类）

所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有唤醒的方法。
park：停车。如果我们把Thread看成一辆车的话，park就是让车停下
unpark：就是让车启动然后跑起来
这里的park和unpark其实实现了wait和notify的功能。

区别：

park不需要获取某个对象的锁（不释放锁）
因为中断park不会抛出InterruptedException异常，需要在park之后自行判断中断状态，然后做额外的处理。

具体代码如下：

public class Ch01 {

    public static final Object OBJ = new Object();

    public void show() {
        try {
            super.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = () -> {
            synchronized (OBJ) {
                System.out.println("线程【" + Thread.currentThread().getName() + "】正在执行...");
                // 阻塞
                LockSupport.park("我被阻塞了...");
                if(Thread.currentThread().isInterrupted()){
                    System.out.println("被中断了...");
                }
                System.out.println("继续执行...");
            }
        };
        Thread t1 = new Thread(runnable,"线程一");
        Thread t2 = new Thread(runnable,"线程二");

        t1.start();
        Thread.sleep(1000);
        System.out.println(LockSupport.getBlocker(t1));
        t2.start();
        Thread.sleep(3000);
        // 线程中断
        t1.interrupt();
        // 把t2唤醒
        LockSupport.unpark(t2);
        t1.join();
        t2.join();
    }
}

总结：

park和unpark可以实现wait和notify的功能，但是并不和wait和notify交叉使用。
park和unpark不会出现死锁。
blocker的作用看到阻塞对象的信息

Lock 锁

Lock是一个接口

public interface Lock {...}

具体代码如下：

    public void show() {
        Lock lock = new Lock() {
            @Override
            public void lock() {

            }

            @Override
            public void lockInterruptibly() throws InterruptedException {

            }

            @Override
            public boolean tryLock() {
                return false;
            }

            @Override
            public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
                return false;
            }

            @Override
            public void unlock() {

            }

            @Override
            public Condition newCondition() {
                return null;
            }
        };
        // 加锁
        lock.lock();
        try {
            // 正常处理业务逻辑
            // 输入输出的操作IO操作
            // 操作的是物理内存
            // 多线程是内存操作
            System.out.println();
        }catch (Exception e){
            // 当出现异常的解决方案
        }finally { // 释放资源，关闭连接，关闭输入输出流
            // 手动释放锁
            lock.unlock();
        }
    }

    public void info() {
        Lock lock = new Lock() {
            @Override
            public void lock() {

            }

            @Override
            public void lockInterruptibly() throws InterruptedException {

            }

            @Override
            public boolean tryLock() {
                return false;
            }

            @Override
            public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
                return false;
            }

            @Override
            public void unlock() {

            }

            @Override
            public Condition newCondition() {
                return null;
            }
        };
        // 如果拿到了锁
        if(lock.tryLock()){
            try {
                // 正常处理业务逻辑
            }catch (Exception e){
                // 当出现异常的解决方案
            }finally { // 释放资源，关闭连接，关闭输入输出流
                // 手动释放锁
                lock.unlock();
            }
        }else {
            // 如果没有拿到锁，则直接做另外的事情
        }

    }

注意！

键盘输入、打印输出极其耗资源IO操作。这两种在实际开发中绝对不允许使用！！！

ReentrantLock 可重入锁

Lock接口的实现类ReentrantLock

synchronized和Lock的区别：

Lock是一个接口，synchronized是一个关键字，是由底层（C）语言实现的。
synchronized发生异常时，会自动释放线程占用的锁不会发生死锁。Lock发生异常，若没有主动释放，极有可能占用资源不放手，需要在finally中手动释放锁。
Lock可以让等待锁的线程响应中断，使用synchronized只会让等待的线程一直等待下去，不能响应中断
Lock可以提高多个线程进行读操作的效率。

Lock以下功能是synchronized不具备的！

ReentrantReadWriteLock：对于一个应用而言，一般情况下读操作远远多于写的操作，如果仅仅是读的操作没有写的操作，数据又是线程安全，读写锁给我们提供了一种锁，读的时候可以很多线程一起读，但是不能有线程写，写是独占的，当有线程在执行写的操作，其他线程既不能读，也不能写。在某些场景下能极大的提升效率！！！

lock锁的原理CAS和APS

synchronized是由C语言实现的，只能作为关键字来使用 * java提供了一些并发的编程的包，底层的实现原理CAS和APS

CAS：compare and swap，比较并交换。JDK11改成了compare and set。思路：就是给一个元素赋值的时候，先看看内存里的那个值到底变没变。
AQS：抽象队列同步器，用来解决线程同步执行的问题。它是一个双向链表

并发编程三大特性：

1.原子性：原子操作可以是一个步骤，也可以是多个步骤，但是顺序不能乱，也不可以被切割只执行其中的一部分，将整个操作视为一个整体。原子性不仅仅是多行代码，也可能是多条指令。
2.可见性
3.有序性

注：synchronized lock：可以保证原子性、可见性、有序性。