当前位置: 首页 > article >正文

JUC学习笔记

文章目录

  • 生产者消费者问题
  • 8锁现象
  • 集合类不安全
  • Callable
    • 创建线程的三种方式
  • 常用辅助类
    • CountDownLatch
    • Cyclibarrier
    • Samphore

本篇博客是之前学习JUC时记录的内容,对于并发编程知识只是浅浅谈及,并不深入。也算是给自己开新坑。建一个JUC的专栏,后续学习有地方记录。

并发:多个线程操作同一个资源类,把资源丢入线程。

  • 传统Synchronized,本质是锁加队列。
    在这里插入图片描述
  • lock:是一个接口。

lock的实现类有:

  1. ReentrantLock(可重入锁)
  2. ReentrantReadWriteLock.ReadLock(可重入读写锁中的读锁)
  3. ReentrantReadWriteLock.WriteLock(可重入读写锁中的写锁)

ReentrantLock默认实现是非公平锁,可以创建时指定为公平锁。

    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

公平锁:按照先来后到的顺序依次执行,有一定的次序。
非公平锁:与公平锁相反,不按照一定的次序执行。

synchronized与lock的区别:

  1. Synchronized 是Java的关键字,Lock是Java的接口,对应有接口的实现类ReentrantLock、ReentrantReadWriteLock。
  2. Synchronized 不可以判断获取锁的状态,Lock可以判断获取锁的状态。
  3. Synchronized 会自动释放锁,Lock需要手动释放锁,不释放则死锁。
  4. Synchronized 线程1(获得锁,阻塞),线程2(等待,死等),Lock锁不一定会等待下去,基于内部的tryLock()函数实现。
  5. Synchronized 可重入锁,不可以中断的,非公平的,Lock可重入锁,可以判断锁,非公平(可以自己设置)
  6. Synchronized 适合锁少量的代码同步问题,Lock适合锁大量的同步代码。

生产者消费者问题

生产者和消费者的Synchronized版:
基本步骤:判断等待、执行业务、唤醒(通知)


public class Demo1 {
    public static void main(String[] args) {
        // 创建资源
        Resources resources = new Resources();
        // 执行并发,创建线程,将资源放置到线程中
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    resources.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"Producer").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    resources.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"Consumer").start();
    }
}

class Resources{
    private int num = 0;
    public synchronized void increment() throws InterruptedException {
        // 判断等待
        while(num != 0){
            this.wait();
        }
        // 执行业务
        ++num;
        System.out.println(Thread.currentThread().getName() + "---" + num);
        // 通知其他线程
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        // 判断等待
        while(num == 0){
            this.wait();
        }
        // 执行业务
        --num;
        System.out.println(Thread.currentThread().getName() + "---" + num);
        // 通知其他线程
        this.notifyAll();
    }
}

上面判断条件能否改为if,不能:

if只会判断一次,随后释放锁,另一个线程获得锁后进行if判断,同时处于等待,两个线程均处于等待状态,随后其他线程执行唤醒操作,进入if里面wait的两个线程都执行后面的业务逻辑。if只在进入的时候判断一次,唤醒后if里面存在多个线程此时也不会判断。
if只判断一次,在等待的时候另一个线程修改了数据,那么wait后就不会进行If判断。
使用while判断当多个生产者进入循环并执行等待操作,随后其他线程执行唤醒操作后,生产者仍然会再次进行判断num!=0进而决定是否执行后续业务代码,防止其他生产者更改num后当前生产者仍然执行++num操作。

生产者和消费者的Lock版:

public class Demo2 {
    public static void main(String[] args) {
        // 创建资源
        Resources2 resources2 = new Resources2();
        // 执行并发,创建线程,将资源放置到线程中
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    resources2.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Producer1").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    resources2.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Producer2").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    resources2.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Producer3").start();
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    resources2.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Consumer").start();
    }
}

class Resources2{
    private int num = 0;
    // 创建锁
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    public void increment() throws InterruptedException {
        // 加锁
        lock.lock();
        try {
            // 判断等待
            while(num != 0){
                condition.await();
            }
            // 执行业务
            ++num;
            System.out.println(Thread.currentThread().getName() + "---" + num);
            // 通知其他线程
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }
    public void decrement() throws InterruptedException {
        // 加锁
        lock.lock();
        try {
            // 判断等待
            while(num == 0){
                condition.await();
            }
            // 执行业务
            --num;
            System.out.println(Thread.currentThread().getName() + "---" + num);
            // 通知其他线程
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }
}

使用condition实现的精准唤醒和通知线程:

package condition;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Condition的精准唤醒
 */
public class Demo1 {
    public static void main(String[] args) {
        // 创建资源
        Resource3 resource3 = new Resource3();
        // 创建线程,将资源传给线程,执行对应的并发操作
        new Thread(()->{
            for (int i =0; i < 10; i++) {
                try {
                    resource3.printA();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i =0; i < 10; i++) {
                try {
                    resource3.printB();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i =0; i < 10; i++) {
                try {
                    resource3.printC();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
    }
}
class Resource3{
    // 创建锁
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int num = 1;
    public void printA() throws InterruptedException {
        // 加锁
        lock.lock();
        try {
            while(num != 1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + ":num=" + num + "AAAAAA");
            num = 2;
            // 唤醒下一个
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB() throws InterruptedException {
        // 加锁
        lock.lock();
        try {
            while(num != 2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + ":num=" + num + "BBBBBB");
            num = 3;
            // 唤醒下一个
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC() throws InterruptedException {
        // 加锁
        lock.lock();
        try {
            while(num != 3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + ":num=" + num + "CCCCCC");
            num = 1;
            // 唤醒下一个
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

上面代码的逻辑是使用Condition唤醒对应的线程,但本身存在一个很大的漏洞,只使用一个Condition仍可以实现上面的流程,由于有个控制变量num的存在,唤醒所有线程后也只会执行num值对应的线程。

8锁现象

集合类不安全

Callable

创建线程的三种方式

常用辅助类

CountDownLatch

Cyclibarrier

Samphore


http://www.kler.cn/a/393654.html

相关文章:

  • Docker 篇-Docker 详细安装、了解和使用 Docker 核心功能(数据卷、自定义镜像 Dockerfile、网络)
  • flutter 发版的时候设置版本号
  • Scala入门基础(17.1)Set集习题
  • Web大学生网页作业成品——婚礼婚纱网页设计与实现(HTML+CSS)(6个页面)
  • 软件测试面试2024最新热点问题
  • unity基础,点乘叉乘。
  • 零基础Java第十六期:抽象类接口(二)
  • 【NLP】2024 年十大 RAG 框架 Github
  • Redis设计与实现 学习笔记 第十七章 集群
  • 2024 kali操作系统安装Docker步骤
  • 【论文复现】交通路口智能监测平台实现
  • Ajax 获取进度和中断请求
  • 华为OD机试真题-仿LISP计算
  • GitHub每日最火火火项目(11.14)
  • 服务器硬件介绍
  • 自动驾驶系列—从数据采集到存储:解密自动驾驶传感器数据采集盒子的关键技术
  • Ubuntu上nginx常用命令
  • 电子制造行业Top5贴片机品牌
  • [DB] Project-1-MySQL
  • 「QT」几何数据类 之 QVector2D 二维向量类
  • 本地编译ChatNio的问题解决
  • Ubuntu22.04中使用CMake配置运行boost库示例程序
  • 《目标检测》——基础理论知识(目标检测的数据集、评价指标:IOU、mAP、非极大抑制NMS)
  • uni-app收藏按钮组件实现⑬
  • WebAPI性能监控-MiniProfiler与Swagger集成
  • 鸿蒙next版开发:相机开发-预览(ArkTS)