JUC学习笔记（三）Lock API控制多线程

已于 2023-11-11 07:51:27 修改
阅读量356 收藏
点赞数
分类专栏： JUC 笔记 文章标签： 学习 java java-ee
于 2022-03-08 18:10:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/slxysyka/article/details/123359751
版权
笔记 同时被 2 个专栏收录
26 篇文章 2 订阅
订阅专栏
JUC
8 篇文章 0 订阅
订阅专栏

使用 Lock API 控制多线程

尚硅谷学习笔记

第一节 HelloWorld

1、卖票

public class Demo01HelloWorld {

    // 声明成员变量维护票库存
    private int stock = 100;

    // 创建锁对象
    // 变量类型：java.util.concurrent.locks.Lock 接口
    // 对象类型：Lock 接口的最常用的实现类 ReentrantLock
    private Lock lock = new ReentrantLock();

    // 声明卖票的方法
    public void saleTicket() {
        try {
            // 加锁
            lock.lock(); // synchronized (this) {

            if (stock > 0) {
                // 卖票的核心操作
                System.out.println(Thread.currentThread().getName() + " 卖了一张，还剩 " + --stock + " 张票。");
            } else {
                System.out.println(Thread.currentThread().getName() + " 卖完了。");
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock(); // }
        }
    }

    public static void main(String[] args) {

        // 1、创建当前类对象
        Demo01HelloWorld demo = new Demo01HelloWorld();
        // 2、开启三个线程调用卖票方法
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                demo.saleTicket();
                try {
                    TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
            }
        }, "thread-01").start();

        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                demo.saleTicket();
                try {
                    TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
            }
        }, "thread-02").start();

        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                demo.saleTicket();
                try {
                    TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
            }
        }, "thread-03").start();
    }

}

2、需要注意的点

①确保锁被释放

使用 Lock API 实现同步操作，是一种面向对象的编码风格。这种风格有很大的灵活性，同时可以在常规操作的基础上附加更强大的功能。但是也要求编写代码更加谨慎：如果忘记调用 lock.unlock() 方法则锁不会被释放，从而造成程序运行出错。

②加锁和解锁操作对称执行

不管同步操作是一层还是多层，有多少个加锁操作，就应该相应的有多少个解锁操作。

③避免锁对象的线程私有化

锁对象如果是线程内部自己创建的，而且是自己独占的，其它线程访问不到这个对象，那么这个锁将无法实现**『排他』**效果，说白了就是：锁不住。

[1]情况一局部变量：线程私有

代码片段如下：

    // 声明一个方法卖票
    public void saleTicket() {

        // 锁对象的线程私有化问题：在线程内部，让每个线程自己创建自己的锁。
        // 对其它线程无法产生排他性的互斥效果：锁不住，监守自盗。
        Lock lock = new ReentrantLock();

内存分析如下：

images

[2]情况二局部变量：线程共享

代码片段如下：

public static void main(String[] args) {

    // 场景一：局部变量被多个线程共享
    // 此时其实是锁得住的。
    Lock lock = new ReentrantLock();

    new Thread(()->{
        lock.lock();
    }, "thread-a").start();

    new Thread(()->{
        lock.lock();
    }, "thread-b").start();

}

内存分析如下：

images

[3]情况三成员变量：线程私有

代码片段如下：

class Phone {

    private Lock lock = new ReentrantLock();

    public void sendShortMessage() {
        lock.lock();
        System.out.println(lock.hashCode());
    }

    public static void main(String[] args) {
        new Thread(()->{
            Phone phone = new Phone();
            phone.sendShortMessage();
        },"thread-a").start();

        new Thread(()->{
            Phone phone = new Phone();
            phone.sendShortMessage();
        },"thread-a").start();
    }
}

内存分析如下：

images

[4]情况四成员变量：线程共享

代码片段如下：

public class Demo01HelloWorld {

    // 声明成员变量保存票的库存
    private int stock = 100;

    // 声明成员变量维护 Lock 锁对象
    private Lock lock = new ReentrantLock();

    public static void main(String[] args) {

        // 1、创建当前类的对象
        Demo01HelloWorld demo = new Demo01HelloWorld();

内存分析如下：

images

[5]小结

  • 使用 Lock 对象实现同步锁，要求各个线程使用的是同一个对象。

  • 那么各个线程它们使用的是不是同一个 ReentrantLock 对象，不能看表面。

    • 表面现象1：使用局部变量指向 ReentrantLock 对象。
    • 表面现象2：使用成员变量指向 ReentrantLock 对象。

  • 本质：根据一系列引用的链条最终找的的 ReentrantLock 对象是不是

    堆空间中的同一个对象

    • 是：锁得住。
    • 否：锁不住。

第二节 Lock 接口

全类名：java.util.concurrent.locks.Lock

方法功能说明：

方法名功能
void lock()加同步锁
void unlock()解除同步锁
boolean tryLock()尝试获取锁 返回 true：表示获取成功 返回 false：表示获取失败
boolean tryLock(long time, TimeUnit unit)尝试获取锁，且等待指定时间 返回 true：表示获取成功 返回 false：表示获取失败
void lockInterruptibly()以『支持响应中断』的模式获取锁
Condition newCondition();获取用于线程间通信的 Condition 对象

第三节 可重入锁

全类名：java.util.concurrent.locks.ReentrantLock

1、基本用法

  • 基本要求1：将解锁操作放在 finally 块中，确保解锁操作能够被执行到。
  • 基本要求2：加锁和解锁操作要对称。
try {
    // 加锁
    lock.lock();
    // 同步代码部分
} catch(Exception e) {
    // ...
} finally {
    // 解锁
    lock.unlock();
}

2、验证可重入性

// 声明卖票的方法
public void saleTicket() {

    try {
        // 加锁
        lock.lock(); // synchronized (this) {
        if (stock > 0) {
            // 卖票的核心操作
            System.out.println(Thread.currentThread().getName() + " 卖了一张，还剩 " + --stock + " 张票。");

            // ❤❤❤❤❤❤❤❤❤❤❤可重入性验证❤❤❤❤❤❤❤❤❤❤❤
            this.showMessage();
        } else {
            System.out.println(Thread.currentThread().getName() + " 卖完了。");
        }

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        // 解锁
        lock.unlock(); // }
    }
}

// ❤❤❤❤❤❤❤❤❤❤❤可重入性验证❤❤❤❤❤❤❤❤❤❤❤
public void showMessage() {

    try {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + " is working");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }
}

3、接口定义：tryLock()

public class Demo03TryLock {

    private Lock lock = new ReentrantLock();

    public void showMessage() {

        boolean lockResult = false;

        try {

            // 尝试获取锁
            // 返回true：获取成功
            // 返回false：获取失败
            lockResult = lock.tryLock();

            if (lockResult) {
                try {
                    TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
                System.out.println(Thread.currentThread().getName() + " 得到了锁，正在工作");
            } else {
                System.out.println(Thread.currentThread().getName() + " 没有得到锁");
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {

            // 如果曾经得到了锁，那么就解锁
            if (lockResult) {
                lock.unlock();
            }

        }

    }

    public static void main(String[] args) {

        // 1、创建多个线程共同操作的对象
        Demo03TryLock demo = new Demo03TryLock();

        // 2、创建三个线程
        new Thread(()->{

            for(int i = 0; i < 20; i++) {
                try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
                demo.showMessage();
            }
        }, "thread-01").start();

        new Thread(()->{

            for(int i = 0; i < 20; i++) {
                try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
                demo.showMessage();
            }

        }, "thread-02").start();

        new Thread(()->{

            for(int i = 0; i < 20; i++) {
                try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
                demo.showMessage();
            }

        }, "thread-03").start();
    }

}

4、接口定义：tryLock(time, timeUnit)

public class Demo04TryLockWithTime {
    private Lock lock = new ReentrantLock();

    // 得到锁之后占用 5 秒
    public void useLock() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + " 开始工作");
            try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {}
            System.out.println(Thread.currentThread().getName() + " 结束工作");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    // 在尝试获取锁的过程中，可以等待一定时间
    public void waitLock() {
        boolean lockResult = false;

        try {
		   //不带超时时间的方式
            //lockResult  = lock.tryLock();
            // 尝试获取锁，并指定了等待时间
            lockResult = lock.tryLock(3, TimeUnit.SECONDS);

            if (lockResult) {
                System.out.println(Thread.currentThread().getName() + " 得到了锁，开始工作");
            } else {
                System.out.println(Thread.currentThread().getName() + " 没有得到锁");
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (lockResult) {
                lock.unlock();
            }
        }

    }

    public static void main(String[] args) {

        // 1、创建当前类对象
        Demo04TryLockWithTime demo = new Demo04TryLockWithTime();

        // 2、创建 A 线程占用锁
        new Thread(()->{
            demo.useLock();
        }, "thread-a").start();

        // 3、创建 B 线程尝试获取锁
        new Thread(()->{
            demo.waitLock();
        }, "thread-b").start();
    }
}

5、实现类提供：公平锁

①概念

在 ReentrantLock 构造器中传入 boolean 类型的参数：

  • true：创建公平锁（在锁上等待最长时间的线程有最高优先级）
  • false：创建非公平锁
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

②代码

public class Demo05FairLock {

    private Lock lock = new ReentrantLock(true);

    public void printMessage() {

        try {

            lock.lock();

            System.out.println(Thread.currentThread().getName() + " say hello to you");

            try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}

        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }

    public static void main(String[] args) {

        // 1、创建当前类的对象
        Demo05FairLock demo = new Demo05FairLock();

        // 2、创建三个线程，每个线程内调用 printMessage() 方法十次
        new Thread(()->{

            for (int i = 0; i < 10; i++) {
                demo.printMessage();
            }

        }, "thread-a").start();

        new Thread(()->{

            for (int i = 0; i < 10; i++) {
                demo.printMessage();
            }

        }, "thread-b").start();

        new Thread(()->{

            for (int i = 0; i < 10; i++) {
                demo.printMessage();
            }

        }, "thread-c").start();


    }

}

③使用建议

  • 公平锁对线程操作的吞吐量有限制，效率上不如非公平锁。
  • 如果没有特殊需要还是建议使用默认的非公平锁。

6、接口定义：lockInterruptibly()

TIP

lock：动词，加锁的动作

Interruptibly：修饰动词的副词，表示可以被打断

组合起来的含义：以可以被打断的方式加锁。具体来说就是如果线程是被 lockInterruptibly() 加的锁给阻塞的，那么这个阻塞状态可以被打断。

①响应中断

响应中断这个概念，我们这么解释：

images

下图描述的是一个最基本的响应中断状态：

images

默认情况下，对于调用了 sleep() 方法进入 TIME_WAITING 状态的线程，可以通过调用 interrupt() 方法打断。对此我们可以说：线程的 TIME_WAITING 状态支持响应中断。

public static void main(String[] args) {

        // 1、创建线程对象
        Thread thread = new Thread(() -> {

            // 2、进入睡眠状态
            try {
                System.out.println(Thread.currentThread().getName() + " 开始睡了");

                // 概念：这个睡觉的状态能够被打断，那么我们就说这个状态支持响应中断
                Thread.sleep(20000);
                System.out.println(Thread.currentThread().getName() + " 睡醒了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });

        // 3、启动线程
        thread.start();

        // 4、等一会儿再去打断
        try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {}

        // 5、调用 interrupt() 方法打断线程的 TIME_WAITING 状态
        thread.interrupt();
    }

线程被打断后会抛出异常：

image-20220308115517378

②synchronized 方式下的阻塞状态无法被打断

结论：synchronized 导致的 blocked 状态不支持响应中断。

images

public static void main(String[] args) {

        // 1、创建一个对象作为锁对象
        Object lock = new Object();

        // 2、创建一个线程长期占用锁
        new Thread(()->{
            synchronized (lock) {
                while (true) {}
            }
        }, "thread-a").start();

        try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}

        // 3、创建一个线程尝试获取锁
        Thread thread = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " 开始痴痴的等待锁 。。。");
            synchronized (lock) {
                // ...
            }
        }, "thread-b");

        // 4、启动线程
        thread.start();

        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {}

        // 5、尝试打断当前线程的阻塞状态
        // 程序运行效果：blocked 状态无法被打断，也可以说——由 synchronized 造成的阻塞状态不支持响应中断
        System.out.println("调用 thread.interrupt() 方法之前");
        // 尝试打断
        thread.interrupt();
        System.out.println("调用 thread.interrupt() 方法之后");

    }

点击快照可以看到 thread-a处于RUNNABLE状态，thread-b 一直处于CLOCKED阻塞状态

image-20220308115933754

③lockInterruptibly()

images

lockInterruptibly() 方法表示获取锁但是没有得到的时候，在阻塞中等待其它线程释放锁的过程中，可以被打断。

public class Demo07LockInterruptibly {

    private Lock lock = new ReentrantLock();

    // 小强：持续占用锁。
    public void useLock() {
        try {
            lock.lock();
            while (true) {
                System.out.println(Thread.currentThread().getName() + " 正在占用锁");
                try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
            }
        }finally {
            lock.unlock();
        }
    }

    // 小明：痴痴地等待小强释放锁
    public void waitLock() {
        System.out.println(Thread.currentThread().getName() + " 线程启动了");

        try {
            // 通过 lockInterruptibly() 方法获取锁，在没有获取到锁的阻塞过程中可以被打断
            lock.lockInterruptibly();
            // ...
        }finally {
            lock.unlock();
        }

        System.out.println(Thread.currentThread().getName() + " 线程结束了");

    }

    public static void main(String[] args) {

        // 1、创建当前类对象
        Demo07LockInterruptibly demo = new Demo07LockInterruptibly();

        // 2、创建占用锁的线程（小强）
        new Thread(()->{
            demo.useLock();
        }, "thread-qiang").start();

        Thread thread = new Thread(() -> {
            demo.waitLock();
        }, "thread-ming");
        thread.start();

        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {}

        // 打断小明线程的阻塞状态
        thread.interrupt();
    }
}

第四节 读写锁

1、读写锁介绍

①概念

在实际场景中，读操作不会改变数据，所以应该允许多个线程同时读取共享资源；但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写的操作了。

针对这种场景，Java 的并发包提供了读写锁 ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为读锁，这是一种共享锁；一个是写相关的锁，称为写锁，这是一种排他锁，也叫独占锁、互斥锁。

②进入条件

[1]进入读锁的条件
  • 同一个线程内（可重入性角度）：
    • 目前无锁：可以进入
    • 已经有读锁：可以进入
    • 已经有写锁：可以进入（锁可以降级，权限可以收缩）
  • 不同线程之间（排他性角度）：
    • 其他线程已经加了读锁：可以进入
    • 其他线程已经加了写锁：不能进入
[2]进入写锁的条件
  • 同一个线程内（可重入性角度）：
    • 目前无锁：可以进入
    • 已经有读锁：不能进入（锁不能升级，权限不拿扩大）
    • 已经有写锁：可以进入
  • 不同线程之间（排他性角度）：
    • 其他线程已经加了读锁：不能进入
    • 其他线程已经加了写锁：不能进入

③重要特性

[1]公平选择性

支持非公平（默认）和公平的锁获取方式，吞吐量还是非公平优于公平。

[2]重进入

读锁和写锁都支持线程重进入：

  • 同一个线程：加读锁后再加读锁
  • 同一个线程：加写锁后再加写锁
[3]锁降级

在同一个线程内：读锁不能升级为写锁，但是写锁可以降级为读锁。

2、ReadWriteLock 接口

全类名：java.util.concurrent.locks.ReadWriteLock

源码如下：

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading.
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing.
     */
    Lock writeLock();
}

readLock() 方法用来获取读锁，writeLock() 方法用来获取写锁。也就是说将文件的读写操作分开，分成两种不同的锁来分配给线程，从而使得多个线程可以同时进行读操作。

该接口下我们常用的实现类是：java.util.concurrent.locks.ReentrantReadWriteLock

3、ReentrantReadWriteLock 和 Lock 的关系

images

4、ReentrantReadWriteLock 类的整体结构

public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable {

    /** 读锁 */
    private final ReentrantReadWriteLock.ReadLock readerLock;

    /** 写锁 */
    private final ReentrantReadWriteLock.WriteLock writerLock;

    final Sync sync;

    /** 使用默认（非公平）的排序属性创建一个新的 ReentrantReadWriteLock */
    public ReentrantReadWriteLock() {
        this(false);
    }

    /** 使用给定的公平策略创建一个新的 ReentrantReadWriteLock */
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

    /** 返回用于写入操作的锁 */
    public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }

    /** 返回用于读取操作的锁 */
    public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }

    abstract static class Sync extends AbstractQueuedSynchronizer {}

    static final class NonfairSync extends Sync {}

    static final class FairSync extends Sync {}

    public static class ReadLock implements Lock, java.io.Serializable {}

    public static class WriteLock implements Lock, java.io.Serializable {}
}

ReentrantReadWriteLock 中有五个内部类，五个内部类之间也是相互关联的。内部类的关系如下图所示。

images

  • Sync 继承自 AQS
  • NonfairSync 和 FairSync 是 Sync 类的子类
  • ReadLock 和 WriteLock 实现了Lock接口

总体结构图：

images

5、效果对比

①情景设定

多个线程对同一个数据执行读操作。

②synchronized 方式

[1]测试代码
public synchronized void readOperation() {
    for (int i = 0; i < 5; i++) {
        try {
            TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
        System.out.println(Thread.currentThread().getName() + " is reading");
    }
}

public static void main(String[] args) {

    ReadWriteLockDemo01 demo = new ReadWriteLockDemo01();

    for (int i = 0; i < 5; i++) {
        new Thread(()->{
            demo.readOperation();
        }, "thread" + i).start();
    }

}
[2]执行效果

每个线程都必须拿到锁才可以执行：

thread0 is reading
thread0 is reading
thread0 is reading
thread0 is reading
thread0 is reading
thread4 is reading
thread4 is reading
thread4 is reading
thread4 is reading
thread4 is reading
thread3 is reading
thread3 is reading
thread3 is reading
thread3 is reading
thread3 is reading
thread2 is reading
thread2 is reading
thread2 is reading
thread2 is reading
thread2 is reading
thread1 is reading
thread1 is reading
thread1 is reading
thread1 is reading
thread1 is reading

③ReentrantReadWriteLock 方式

[1]测试代码
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private ReentrantReadWriteLock.ReadLock readLock = lock.readLock();

public void readOperation() {
    try {
        readLock.lock();
        for (int i = 0; i < 5; i++) {
            TimeUnit.SECONDS.sleep(1);
            System.out.println(Thread.currentThread().getName() + " is reading");
        }
    } catch (InterruptedException e) {
    } finally {
        readLock.unlock();
    }
}

public static void main(String[] args) {

    ReadWriteLockDemo01 demo = new ReadWriteLockDemo01();

    for (int i = 0; i < 5; i++) {
        new Thread(() -> {
            demo.readOperation();
        }, "thread" + i).start();
    }

}
[2]执行效果

读锁允许各个线程交替执行，大大提升了效率：

thread0 is reading thread2 is reading thread3 is reading thread4 is reading thread1 is reading thread2 is reading thread1 is reading thread4 is reading

……

TIP

注意：

  • 如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
  • 如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

6、典型案例

①情景设定

使用 ReentrantReadWriteLock 进行读和写操作

操作测试目标
场景一多个线程同时获取读锁读锁可以共享
场景二多线程获取写锁写锁不能共享
场景三一个线程先获取读锁后其他线程获取写锁读排斥写
场景四一个线程获取写锁后其他线程获取读锁写排斥读
场景五同一个线程获取读锁后再去获取写锁读权限不能升级为写权限
场景六同一个线程获取写锁后再去获取读锁写权限可以降级为读权限
场景七同一个线程获取读锁之后再去获取读锁读锁可重入
场景八同一个线程获取写锁之后再去所获写锁写锁可重入
场景九同一个线程获取写锁之后再去获取读锁再继续获取写锁写锁里面读写都可获取

①场景一：『读』可共享

结论: 多个线程可以同时获取读锁

[1]功能代码
// 场景一：『读』可共享
class Situation01 {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = lock.readLock();

    // 只要都是加读锁的操作，各个线程间不需要彼此等待，可以同时并发执行
    public void read() {

        try {
            // 加锁
            readLock.lock();
            System.out.println(Thread.currentThread().getName() + " 开始执行读操作");
            try { TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
            System.out.println(Thread.currentThread().getName() + " 结束执行读操作");

        } finally {

            // 释放锁
            readLock.unlock();
        }
    }
}
[2]测试代码
// 场景一：创建 Situation01 对象
Situation01 situation01 = new Situation01();
//创建十个线程
for (int i = 0; i < 10; i++) {
    new Thread(()->{
        situation01.read();
    }, "thread" + i).start();
}
[3]打印效果

thread0 开始执行读操作
thread1 开始执行读操作
thread2 开始执行读操作
thread3 开始执行读操作
thread4 开始执行读操作
thread5 开始执行读操作
thread6 开始执行读操作
thread7 开始执行读操作
thread8 开始执行读操作
thread9 开始执行读操作
thread6 结束执行读操作
thread7 结束执行读操作
thread8 结束执行读操作
thread9 结束执行读操作
thread2 结束执行读操作
thread3 结束执行读操作
thread4 结束执行读操作
thread0 结束执行读操作
thread5 结束执行读操作
thread1 结束执行读操作

②场景二：『写』互排斥

结论：多个线程同时获取写锁，同一时间只有一个线程能获取到写锁

[1]功能代码
// 场景二：『写』互排斥
class Situation02 {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();

    public void write() {

        try {

            writeLock.lock();
            System.out.println(Thread.currentThread().getName() + " 开始执行写操作");
            try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
            System.out.println(Thread.currentThread().getName() + " 结束执行写操作");

            System.out.println();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            writeLock.unlock();

        }
    }

}
[2]测试代码
// 场景二：创建 Situation02 对象
Situation02 situation02 = new Situation02();

for (int i = 0; i < 10; i++) {
    new Thread(()->{
        situation02.write();
    }).start();
}
[3]打印效果

Thread-0 开始执行写操作
Thread-0 结束执行写操作

Thread-1 开始执行写操作
Thread-1 结束执行写操作

Thread-2 开始执行写操作
Thread-2 结束执行写操作

Thread-3 开始执行写操作
Thread-3 结束执行写操作
……

③场景三：『读』排斥『写』

结论：当对象具有读锁时，其他线程无法加上写锁

[1]功能代码
class Situation03 {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();


    // 只要都是加读锁的操作，各个线程间不需要彼此等待，可以同时并发执行
    public void read() {

        try {

            // 加锁
            readLock.lock();

            System.out.println(Thread.currentThread().getName() + " 开始执行读操作");

            TimeUnit.SECONDS.sleep(5);

            System.out.println(Thread.currentThread().getName() + " 结束执行读操作");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            // 释放锁
            readLock.unlock();

        }

    }

    public void write() {

        try {

            writeLock.lock();

            System.out.println(Thread.currentThread().getName() + " 开始执行写操作");

            TimeUnit.SECONDS.sleep(1);

            System.out.println(Thread.currentThread().getName() + " 结束执行写操作");

            System.out.println();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            writeLock.unlock();

        }
    }
}
[2]测试代码
// 场景三：创建 Situation03 对象
Situation03 situation03 = new Situation03();

// 创建一个线程使用读锁
new Thread(()->{
    situation03.read();
}, "thread-read").start();

// 创建三个线程使用写锁
new Thread(()->{ situation03.write(); }, "thread-write 01").start();
new Thread(()->{ situation03.write(); }, "thread-write 02").start();
new Thread(()->{ situation03.write(); }, "thread-write 03").start();
[3]打印效果

thread-read 开始执行读操作
thread-read 结束执行读操作
thread-write 01 开始执行写操作
thread-write 01 结束执行写操作

thread-write 02 开始执行写操作
thread-write 02 结束执行写操作

thread-write 03 开始执行写操作
thread-write 03 结束执行写操作

④场景四：『写』排斥『读』

结论：当对象具有写锁时，其他线程无法加上读锁

[1]功能代码
class Situation04 {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();

    // 只要都是加读锁的操作，各个线程间不需要彼此等待，可以同时并发执行
    public void read() {

        try {

            // 加锁
            readLock.lock();

            System.out.println(Thread.currentThread().getName() + " 开始执行读操作");

            TimeUnit.SECONDS.sleep(1);

            System.out.println(Thread.currentThread().getName() + " 结束执行读操作");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            // 释放锁
            readLock.unlock();

        }

    }

    public void write() {

        try {

            writeLock.lock();

            System.out.println(Thread.currentThread().getName() + " 开始执行写操作");

            TimeUnit.SECONDS.sleep(5);

            System.out.println(Thread.currentThread().getName() + " 结束执行写操作");

            System.out.println();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            writeLock.unlock();

        }
    }
}
[2]测试代码
Situation04 situation04 = new Situation04();

// 创建一个线程执行写操作
new Thread(()->{ situation04.write(); }, "thread-write").start();

// 创建三个线程执行读操作
new Thread(()->{ situation04.read(); }, "thread-read 01").start();
new Thread(()->{ situation04.read(); }, "thread-read 02").start();
new Thread(()->{ situation04.read(); }, "thread-read 03").start();
[3]打印效果

thread-write 开始执行写操作
thread-write 结束执行写操作

thread-read 01 开始执行读操作
thread-read 02 开始执行读操作
thread-read 03 开始执行读操作
thread-read 01 结束执行读操作
thread-read 03 结束执行读操作
thread-read 02 结束执行读操作

⑤场景五：『锁升级』不允许

结论：同一个线程中如果读锁尚未释放就不允许获取写锁，这说明读锁不能升级为写锁。

[1]功能代码
class Situation05 {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();

    public void readThenWrite() {

        try {
            readLock.lock();

            System.out.println(Thread.currentThread().getName() + " 正在读取数据");

            writeLock.lock();

            System.out.println(Thread.currentThread().getName() + " 正在写入数据");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            writeLock.unlock();

            readLock.unlock();

        }

    }

}
[2]测试代码
Situation05 situation05 = new Situation05();

// 创建一个线程调用 Situation05 对象读写方法
new Thread(()->{ situation05.readThenWrite(); }).start();
[3]打印效果

Thread-0 正在读取数据

⑥场景六：『锁降级』

结论：同一个线程，拥有写锁后，即使写锁尚未释放也仍可再获取读锁，这说明写锁可以降级为读锁。

[1]功能代码
class Situation06 {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();

    public void writeThenRead() {

        try {
            writeLock.lock();

            System.out.println(Thread.currentThread().getName() + " 正在写入数据");

            // 同一个线程内：在写锁尚未释放时，再加读锁
            readLock.lock();

            System.out.println(Thread.currentThread().getName() + " 正在读取数据");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            readLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 读锁释放");

            writeLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 写锁释放");

        }

    }

}
[2]测试代码
        Situation06 situation06 = new Situation06();

        // 创建一个线程调用 Situation06 对象的读写方法
        new Thread(()->{ situation06.writeThenRead(); }).start();
[3]打印效果

Thread-0 正在写入数据
Thread-0 正在读取数据
Thread-0 写锁释放
Thread-0 读锁释放

⑦场景七：『读锁可重入』

结论：同一个线程内，在读锁尚未释放时，再加读锁——可以。

[1]功能代码
class Situation07 {

 	//创建读写锁对象
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    //通过读写锁对象获取到的读锁对象
    private Lock readLock = readWriteLock.readLock();

    public void readThenRead() {

        try {
            // 第一个读锁
            readLock.lock();

            System.out.println(Thread.currentThread().getName() + " 开始第一次读取数据");

            // 同一个线程内：在读锁尚未释放时，再加读锁
            readLock.lock();

            System.out.println(Thread.currentThread().getName() + " 开始第二次读取数据");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            readLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 读锁释放");

            readLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 读锁释放");

        }

    }

}
[2]测试代码
Situation07 situation07 = new Situation07();

new Thread(()->{ situation07.readThenRead(); }).start();
[3]打印效果

Thread-0 开始第一次读取数据
Thread-0 开始第二次读取数据
Thread-0 读锁释放
Thread-0 读锁释放

⑧场景八：『写锁可重入』

结论：同一个线程内，在写锁尚未释放时，再加写锁——可以。

[1]功能代码
class Situation08 {

 	//创建读写锁对象
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    //通过读写锁对象获取到的写锁对象
    private Lock writeLock = readWriteLock.writeLock();


    public void writeThenWrite() {

        try {
            // 第一个读锁
            writeLock.lock();

            System.out.println(Thread.currentThread().getName() + " 开始第一次写入数据");

            // 同一个线程内：在读锁尚未释放时，再加读锁
            writeLock.lock();

            System.out.println(Thread.currentThread().getName() + " 开始第二次写入数据");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            writeLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 写锁释放");

            writeLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 写锁释放");

        }

    }

}
[2]测试代码
        Situation08 situation08 = new Situation08();

        new Thread(()->{ situation08.writeThenWrite(); }).start();
[3]打印效果

Thread-0 开始第一次写入数据
Thread-0 开始第二次写入数据
Thread-0 写锁释放
Thread-0 写锁释放

⑨场景九『写读写三重入』

在一个写锁里面加读锁，再在读锁里面加写锁。

结论：同一个线程内，在写锁尚未释放时，读写锁都可以加。

[1]功能代码
 	//创建读写锁对象
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    //通过读写锁对象获取到的写锁对象
    private Lock writeLock = readWriteLock.writeLock();
    //通过读写锁对象获取到的读锁对象
    private Lock readLock = readWriteLock.readLock();

    //声明一个方法，在加了写锁之后再加写锁
    public void WriteReadWrite() {

        try {
            //加读锁
            writeLock.lock();
            System.out.println("加了写锁");
            try {
                readLock.lock();
                System.out.println("加了内层读锁");
                try {
                    writeLock.lock();
                    System.out.println("加了内内层写锁");
                } finally {
                    writeLock.unlock();
                    System.out.println("释放了内内层写锁");

                }
            } finally {
                readLock.unlock();
                System.out.println("释放内层读锁");
            }
        } finally {
            writeLock.unlock();
            System.out.println("释放写锁");
        }
    }
[2]测试代码
public static void main(String[] args) {
        Demo09WtireReadWrite demo09WtireReadWrite = new Demo09WtireReadWrite();
        demo09WtireReadWrite.WriteReadWrite();
    }
[3]打印效果

加了写锁
加了内层读锁
加了内内层写锁
释放了内内层写锁
释放内层读锁
释放写锁

第五节 线程间通信

1、核心语法

  • ReentrantLock 同步锁：将执行操作的代码块设置为同步操作，提供原子性保证

  • Condition 对象

    ：对指定线程进行等待、唤醒操作

    • await() 方法：让线程等待
    • signal() 方法：将线程唤醒

2、案例演示

①题目要求

两个线程分别对一个 int 类型的数据执行 + 1 和 - 1 的操作，要求严格交替执行。

②代码实现

public class Demo03LockConditionWay {

    // 创建同步锁对象
    private Lock lock = new ReentrantLock();

    // 通过同步锁对象创建控制线程间通信的条件对象
    private Condition condition = lock.newCondition();

    private int data = 0;

    // 声明方法执行 + 1 操作
    public void doIncr() {

        try {

            // 使用 lock 锁对象加锁
            lock.lock();

            // 为了避免虚假唤醒问题：使用 while 结构进行循环判断
            // 判断当前线程是否满足执行核心操作的条件
            while (data == 1) {

                // 满足条件时，不该当前线程干活，所以进入等待状态
                condition.await();
            }
            // 不满足上面的条件时，说明该当前线程干活了，所以执行核心操作
            System.out.println(Thread.currentThread().getName() + " 执行 + 1 操作，data = " + ++data);
            // 自己的任务完成后，叫醒其它线程
            condition.signalAll();
        }finally {

            // 释放锁
            lock.unlock();

        }
    }

    // 声明方法执行 - 1 操作
    public void doDecr() {

        try {
            // 使用 lock 锁对象加锁
            lock.lock();

            // 为了避免虚假唤醒问题：使用 while 结构进行循环判断
            // 判断当前线程是否满足执行核心操作的条件
            while (data == 0) {
                // 满足条件时，不该当前线程干活，所以进入等待状态
                condition.await();
            }

            // 不满足上面的条件时，说明该当前线程干活了，所以执行核心操作
            System.out.println(Thread.currentThread().getName() + " 执行 - 1 操作，data = " + --data);

            // 自己的任务完成后，叫醒其它线程
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {

            // 释放锁
            lock.unlock();

        }
    }

    public static void main(String[] args) {

        // 1、创建当前类的对象
        Demo03LockConditionWay demo = new Demo03LockConditionWay();

        // 2、创建四个线程，两个 + 1，两个 - 1
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                demo.doIncr();
            }
        }, "thread-add A").start();

        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                demo.doDecr();
            }
        }, "thread-sub A").start();

        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                demo.doIncr();
            }
        }, "thread-add B").start();

        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                demo.doDecr();
            }
        }, "thread-sub B").start();

    }

}

执行效果：

thread-add A 执行 + 1 操作，data = 1
thread-sub A 执行 - 1 操作，data = 0
thread-add A 执行 + 1 操作，data = 1
thread-sub A 执行 - 1 操作，data = 0
thread-add A 执行 + 1 操作，data = 1
thread-sub A 执行 - 1 操作，data = 0
thread-add B 执行 + 1 操作，data = 1
thread-sub B 执行 - 1 操作，data = 0
thread-add B 执行 + 1 操作，data = 1
thread-sub B 执行 - 1 操作，data = 0
thread-add B 执行 + 1 操作，data = 1

3、定制化通信

传统的 synchronized、wait()、notifyAll() 方式无法唤醒一个指定的线程。而 Lock 配合 Condition 的方式能够唤醒指定的线程，从而执行指定线程中指定的任务。

①语法基础

  • ReentrantLock 同步锁：将执行操作的代码块设置为同步操作，提供原子性保证

  • Condition 对象

    ：对指定线程进行等待、唤醒操作

    • await() 方法：让线程等待
    • signal() 方法：将线程唤醒

②案例

[1]题目要求

要求四个线程交替执行打印如下内容：

  • 线程1：打印连续数字
  • 线程2：打印连续字母
  • 线程3：打印 * 符
  • 线程4：打印 $ 符
[2]代码实现
public class Demo03Condition {

    // 控制总体的操作步骤
    private int step = 1;

    // 负责打印数字的线程要打印的数字
    private int digital = 1;

    // 负责打印字母的线程要打印的字母
    private char alphaBet = 'a';

    // 同步锁对象
    private Lock lock = new ReentrantLock();

    // 条件对象：对应打印数字的线程
    private Condition conditionDigital = lock.newCondition();

    // 条件对象：对应打印字母的线程
    private Condition conditionAlphaBet = lock.newCondition();

    // 条件对象：对应打印星号的线程
    private Condition conditionStar = lock.newCondition();

    // 条件对象：对应打印 $ 的线程
    private Condition conditionDollar = lock.newCondition();

    // 声明一个方法专门打印数字
    public void printDigital() {
        try {
            lock.lock();

            // 只要 step 对 4 取模不等于 1，就不该当前方法干活
            while (step % 4 != 1) {

                // 使用专门的条件对象，让当前线程进入等待
                // 将来还用同一个条件对象，调用 singal() 方法就能精确的把这里等待的线程唤醒
                conditionDigital.await();
            }

            // 执行要打印的操作
            System.out.print(digital++);

            // 精准唤醒打印字母的线程
            conditionAlphaBet.signal();

            step++ ;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printAlphaBet() {
        try {
            lock.lock();

            while (step % 4 != 2) {
                conditionAlphaBet.await();
            }

            System.out.print(alphaBet++);

            conditionStar.signal();

            step++ ;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printStar() {
        try {
            lock.lock();

            while (step % 4 != 3) {
                conditionStar.await();
            }

            System.out.print("*");

            conditionDollar.signal();

            step++ ;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printDollar() {
        try {
            lock.lock();

            while (step % 4 != 0) {
                conditionDollar.await();
            }

            System.out.println("$");

            conditionDigital.signal();

            step++ ;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {

        Demo03Condition demo = new Demo03Condition();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                demo.printDigital();
            }
        }).start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                demo.printAlphaBet();
            }
        }).start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                demo.printStar();
            }
        }).start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                demo.printDollar();
            }
        }).start();

    }

}

打印效果：

1a*$
2b*$
3c*$
4d*$
5e*$
6f*$
7g*$
8h*$
9i*$
10j*$

③思考题

曾经有这样一道笔试题：一个线程打印连续数字，一个线程打印连续字母。要求打印两个数字，然后打印两个字母，如此往复。

12ab34cd56ef78gh ……

public class ThinkingThread {
    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private char alphabet = 'a';
    private int digital = 1;
    private int steep = 1;


    public void printDigital(){
        new Thread(()->{
            while (true){
                try {
                    lock.lock();
                    if (steep %2 != 1){
                        conditionA.await(); 没到条件当前线程阻塞
                    }
                    //核心逻辑
                    if (digital > 25) digital = 1;
                    System.out.print(digital++);
                    System.out.print(digital++);
                    steep++;

                    conditionB.signal();  //唤醒字母编程
//                    try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }).start();
    }
    public void printAlphabet(){
        new Thread(()->{
            while (true){
                try {
                    lock.lock();
                    if (steep %2 != 0){
                        conditionB.await();  //没到条件当前线程阻塞
                    }
                    //核心逻辑
                    if (alphabet > 'a'+25) alphabet = 'a';
                    System.out.print(alphabet++);
                    System.out.print(alphabet++);
                    steep++;

                    conditionA.signal(); //执行完 唤醒打印数字线程
//                    try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {}
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }).start();
    }

    public static void main(String[] args) {
        ThinkingThread thinkingThread = new ThinkingThread();
        thinkingThread.printAlphabet();
        thinkingThread.printDigital();
    }
}

第六节 Lock 与 synchronized 对比

1、相同点

  • 都支持独占锁
  • 都支持可重入

2、不同点

Lock 系列 API 用法synchronized 用法
加锁/解锁手动自动
支持共享锁√×
支持尝试获取锁失败
后执行特定操作		√×
灵活√×
便捷×√
响应中断lockInterruptibly() 方式支持阻塞状态响应中断sleep() 睡眠后支持响应中断
代码风格面向对象面向过程
底层机制AQS（volatile + CAS + 线程的双向链表）= 非阻塞同步阻塞同步

3、使用建议

①从功能效果的角度来看

Lock 能够覆盖 synchronized 的功能，而且功能更强大。

images

②从开发便捷性的角度来看

  • synchronized：自动加锁、解锁，使用方便
  • Lock：手动加锁、解锁，使用不那么方便

③从性能角度

二者差不多。

④使用建议

synchronized 够用，那就使用 synchronized；如果需要额外附加功能则使用 Lock：

  • 公平锁
  • 共享锁
  • 尝试获取锁
  • 以支持响应中断的方式获取锁
  • ……
龙龙龙呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
AntiZhaPian:假的国家反诈中心
04-18
AntiZhaPian 假的国家反诈中心 安装 下载app-release.apk安装即可。 特性 点击我的---点击查看个人信息 >即可查看个人信息，点击我的---头像即可修改个人信息。 注意 1.其余按钮和内容均为贴图。 2.本App不需要任何权限。 3.仅支持Android 7.1 以上的系统。 编译 解压source.zip，在Android Studio中打开即可。
免费接口及资源
qq_25460159的博客
09-28 3756
手机号码归属地API接口： https://www.juhe.cn/docs/api/id/11 历史上的今天API接口： https://www.juhe.cn/docs/api/id/63 股票数据API接口： https://www.juhe.cn/docs/api/id/21 全国WIFI接口： https://www.juhe.cn/docs/api/id/18 星座运势接口： https://www.juhe.cn/docs/api/id/58 黄金数据接口： https:
锁对象
qq_38844728的博客
04-16 570
有两种机制防止代码块受并发访问的干扰。Java语言提供一个synchronized关键字达到这一目的，并且Java SE 5.0引入了ReentrantLook类。synchronized关键字自动提供一个锁以及相关的"条件"，对于大多数需要显式锁的情况，这是很便利的。java.util.concurrent框架为这些基础机制提供了独立的类。 如果使用锁来保护模拟银行转账中的Bank类的tran...
这款国产API神器工具也太强了吧...让我放弃了postman
java李阳勇的博客
07-19 2万+
今天我发现了一款国产化的API工具，去官网看了下它的中文页面，觉得很干净、倍感亲切，我感觉Eolink结合了postman 和 swagger 的优点。摒弃了不足、甚至发生了公开踩踏事件，最近国产API管理工具越来越卷，但最后还是要回归产品，产品好才真的好。我给大家推荐Eolink，低调又强大。Eolink是结合了 API 设计、文档管理、自动化测试、监控、研发管理和团队协作的一站式 API 生产平台，还集成 Gitlab、钉钉、企业微信、Jenkins、飞书等平台，简直就是一个六边形战士，没有任何短板！.
响应式卡片悬停效果 html+css
你好呀，很高兴你在看这里~
01-21 7347
话不多，看效果先： 卡片悬停，响应式卡片，简约效果。 实现： 1. 定义标签，.kapian为最底层盒子，然后两个子盒子一个放图片，一个放文本： <div class="kapian"> <div class="tu"> <img src="3.2.png"> </div> <div class="wenben"> <h2
JUC多线程学习个人笔记
07-08
锁机制：JUC提供了Lock接口和Condition接口，可以实现更细粒度的锁控制和线程的等待和唤醒机制。 并发工具类：JUC提供了一些并发编程的工具类，如Semaphore、CountDownLatch、CyclicBarrier等，可以实现线程间的协作...
JUC学习笔记（Java多线程）
07-04
JUC学习笔记（Java多线程）
JUC代码收集，java高并发多线程学习
03-31
JUC代码收集，java高并发多线程学习
JUC代码演示 Java多线程并发
最新发布
05-03
JUC代码演示 Java多线程并发 源于B站https://www.bilibili.com/video/BV1Kw411Z7dF/?p=32&spm_id_from=333.1007.top_right_bar_window_history.content.click课程自我项目记录。 适合有一定基础的朋友。
多线程以及juc,lock
07-20
多线程以及juc,lock
仿大哥网电影程序
12-28
1:该插件适用于max4.0官方播放器版 2:智能多浏览器检测是否安装百度影音 3:自动缓冲下一集 4:自动跳转下一集 5:自定义下载地址 6:自定义缓冲广告 7:自定义暂停广告 8:支持设置首次缓冲广告时间 使用方法: 1:先备份你的js/play.js 以防万一 2:修改js/bdhd-tiapian.html里面的 "贴片计费ID" 3:修改js/play.js 顶部"百度影音配置"里面加载的贴片地址与下载地址 4:上传整个js文件夹并覆盖,测试百度影音('安装检测>缓冲广告>暂停广告')
html桌面卡牌效果,html+css实现响应式卡片悬停效果
weixin_29660659的博客
06-03 884
话不多，看效果先：卡片悬停，响应式卡片，简约效果。实现：1. 定义标签，.kapian为最底层盒子，然后两个子盒子一个放图片，一个放文本： The aurora borealisnaturalAurora Borealis is a colorful luminous phenomenon that appears over the high magnetic latitu...
免费资源网站大全
热门推荐
糖果云专栏
12-17 25万+
网盘类：网盘类百搭，放第一个了 推荐 盘多多：    http://www.panduoduo.net 去转盘：    http://www.quzhuanpan.com Bdsola:       http://www.3134.cc 西林街：    http://www.xilinjie.com 潜力股 探索云盘搜索：   http://tansuo233.com BDY搜：    http:...
图形卡片分组游戏
weixin_45807332的博客
08-03 1549
掌握类的继承、多态性使用方法以及接口的应用。 具体需求参考作业指导书。 2020-OO第07次作业-2指导书V1.0.pdf 输入格式: 在一行上输入一串数字（1~4，整数），其中，1代表圆形卡片，2代表矩形卡片，3代表三角形卡片，4代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。例如：1 3 4 2 1 3 4 2 1 3 0 根据第一行数字所代表的卡片图形类型，依次输入各图形的相关参数，例如：圆形卡片需要输入圆的半径，矩形卡片需要输入矩形的宽和长，三角形卡片需要输入三角形的三条边长，梯形需要
java trylock lock_Java多线程：tryLock()方法
weixin_42354992的博客
02-16 685
Java多线程：tryLock()方法tryLock(long time, TimeUnit unit) 的作用在给定等待时长内锁没有被另外的线程持有，并且当前线程也没有被中断,则获得该锁，通过该方法可以实现锁对象的限时等待。package com.wkcto.lock.reentrant;import java.util.concurrent.TimeUnit;import java.util....
锁的等级：方法锁、对象锁、类锁。
change的博客
03-12 1542
（1）基础Java中的每一个对象都可以作为锁。对于同步方法，锁是当前实例对象。对于静态同步方法，锁是当前对象的Class对象。对于同步方法块，锁是Synchonized括号里配置的对象。    当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。那么锁存在哪里呢？锁里面会存储什么信息呢？（2）同步的原理JVM规范规定JVM基于进入和退出 Monitor 对象来实现方法同步...
Java多线程-09 （Lock锁之ReentrantLock可重入锁）
小北呱的博客
08-09 447
synchronized被称为内部锁，在 JDK5 中增加了Lock 锁接口,lock 关键字可确保当一个线程位于代码的临界区时，另一个线程不会进入该临界区。 如果其他线程尝试进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放。这也是多线程编程中一种保护线程安全的重要机制，它也被称为外部所，此接口有多个实现类,下面我们就来学习下Lock接口的一些实现类 1.1 锁的可重入性 锁的可重入是指,当一个线程获得一个对象锁后,再次请求该对象 锁时是可以获得该对象的锁的. ...
这才是实现分布式锁的正确姿势！
勇往直前的专栏
03-26 891
都9102年了，你还在手写分布式锁吗？ 经常被问到”如何实现分布式锁”，看来这是大家的一个痛点。 其实Java世界的”半壁江山”——Spring早就提供了分布式锁的实现。早期，分布式锁的相关代码存在于Spring Cloud的子项目Spring Cloud Cluster中，后来被迁到Spring Integration中。 Spring Cloud Cluster的GitHub：htt...
ReentrantLock中一些方法介绍使用
weixin_43960044的博客
11-05 386
Lock中一些方法介绍使用 一、.getHoldCount(); .getQueueLength();.getWaitQueueLength(condition); lock.getHoldCount(); 返回当前保持此锁的线程个数，即调用lock() 方法的次数 lock.getQueueLength(); 返回正在等待获取此锁的线程个数，例如：有5个线程使用此锁，其中一个线程调用了await() 其他线程都在等待，则该方法返回4. lock.getWaitQueueLength(condition)
黑马juc并发编程md笔记
09-22
黑马程序员的JUC并发教程一是关于并发编程的课程，包括了进程与线程、并行与并发、Java线程等内容。其中涵盖了创建和运行线程、线程的运行原理、线程的方法、线程状态等知识点。并发是指多个程序在同一时间段内在同...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

龙龙龙呀

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

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

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

打赏作者

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

抵扣说明：

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

余额充值