JUC高级十二-ReentrantLock、ReentrantReadWriteLock、StampedLock

无锁→独占锁→读写锁→邮戳锁

1. 关于锁的大厂面试题

  • 你知道Java里面有哪些锁?
  • 你说你用过读写锁，锁饥饿问题是什么？
  • 有没有比读写锁更快的锁？
  • StampedLock知道吗?(邮戳锁/票据锁)
  • ReentrantReadWriteLock有锁降级机制策略你知道吗？

2. 读写锁

读写锁定义为一个资源能够被多个读线程访问，或者被一个写线程访问，但是不能同时存在读写线程。

2.1 ReentrantReadWriteLock分析

由ReentrantLock与ReentrantReadWriteLock的对比

  • ReentrantLock实现的是Lock接口
  • ReentrantReadWriteLock实现的是ReadWriteLock接口

image-20230423153136682

ReadWriteLock接口

  • 有一个读锁一个写锁

image-20230423153304047

2. 读写锁演变

无锁无序->加锁->读写锁

image-20230423154226987

  1. 无锁时期一旦多线程,肯定会出现线程安全问题
  2. 加锁时期读读操作也只能单线程操作-----解决了线程安全问题但是性能太低
  3. 读写锁时期:高并发的情况下大部分的请求都是查询请求,即读多写少的情况,如果读读也互斥了那么效率极低,而且读操作不会影响数据一致性可以不互斥—读写锁诞生.
    • 缺点:
      1. 因为读写锁读写互斥,假设100个线程99个都是读线程只有一个写线程,写线程很难抢到机会,就会出现锁饥饿问题
      2. 锁降级:为了让当前线程感知到数据的变化，目的是保证数据可见性,写锁会降级为写锁(写后立刻读)

2.3 『读写锁』意义和特点

  • 『读写锁ReentrantReadWriteLock』并不是真正意义上的读写分离，它只允许读读共存，而读写和写写依然是互斥的，
  • 大多实际场景是“读/读”线程间并不存在互斥关系，只有"读/写"线程或"写/写"线程间的操作需要互斥的。因此引入ReentrantReadWriteLock。
  • 一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁，但不能同时存在写锁和读锁
    • 也即一个资源可以被多个读操作访问或一个写操作访问，但两者不能同时进行。
  • 只有在读多写少情境之下，读写锁才具有较高的性能体现。

2.4 ReentrantLock加锁实例

package site.zhourui.readWriteLockAndStampedLock;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
class MyResource {
    Map<String,String> map = new HashMap<>();
    //=====ReentrantLock 等价于 =====synchronized
    Lock lock = new ReentrantLock();
    //=====ReentrantReadWriteLock 一体两面，读写互斥，读读共享
    ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void write(String key,String value)
    {
        lock.lock();
        try
        {
            System.out.println(Thread.currentThread().getName()+"\t"+"---正在写入");
            map.put(key,value);
            //暂停毫秒
            try { TimeUnit.MILLISECONDS.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t"+"---完成写入");
        }finally {
            lock.unlock();
        }
    }
    public void read(String key)
    {
        lock.lock();
        try
        {
            System.out.println(Thread.currentThread().getName()+"\t"+"---正在读取");
            String result = map.get(key);
            //后续开启注释修改为2000，演示一体两面，读写互斥，读读共享，读没有完成时候写锁无法获得
            try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t"+"---完成读取result："+result);
        }finally {
            lock.unlock();
        }
    }

}

public class ReadWriteLockDemo {

    public static void main(String[] args)
    {
        MyResource myResource = new MyResource();

        for (int i = 1; i <=10; i++) {
            int finalI = i;
            new Thread(() -> {
                myResource.write(finalI +"", finalI +"");
            },String.valueOf(i)).start();
        }

        for (int i = 1; i <=10; i++) {
            int finalI = i;
            new Thread(() -> {
                myResource.read(finalI +"");
            },String.valueOf(i)).start();
        }

    }
}

执行结果:

不光读写互斥,读读也是互斥的

image-20230423161721493

2.5 ReentrantReadWriteLock实例实现读读共享

只需要把ReentrantLock换成对应的读写锁

image-20230423162057055

执行结果:

读写仍然互斥,但是读读不会互斥了

image-20230423162216884

2.5.1 读锁占用时写锁是无法获取的

将读锁sleep参数修改为2000

image-20230423162814562

在执行10个读线程后再次写线程

image-20230423162915561

执行结果:

在读锁没有释放的时,写锁是不能获取的

image-20230423162948429

2.6 读写锁的锁降级

image-20230423163152485

从写锁→读锁，ReentrantReadWriteLock可以降级

锁降级：将写入锁降级为读锁(类似Linux文件读写权限理解，就像写权限要高于读权限一样)

2.6.1 读写锁降级规则

  • 锁降级：遵循获取写锁→再获取读锁→再释放写锁的次序，写锁能够降级成为读锁。
  • 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁。

image-20230423163423459

2.6.2 读写锁降级的作用

锁降级是为了让当前线程感知到数据的变化，目的是保证数据可见性

2.6.3 代码实例

package site.zhourui.readWriteLockAndStampedLock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class LockDownGradingDemo {
    public static void main(String[] args)
    {
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

        ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
        ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();


        writeLock.lock();
        System.out.println("-------正在写入");


        readLock.lock();
        System.out.println("-------正在读取");

        writeLock.unlock();

    }

}

执行结果：

当,当前线程没有释放写锁时,仍然能够该线程仍然能够获取写锁:锁降级

注意之前的读写互斥是说的多线程之间,这里是一个线程的情况获取写锁还能获取读锁这叫锁降级

image-20230423163734702

2.7 锁不可升级

如果有线程在读，那么写线程是无法获取写锁的，是悲观锁的策略

image-20230423165025359

2.8 总结

  • 写锁和读锁是互斥的（这里的互斥是指线程间的互斥，当前线程可以获取到写锁又获取到读锁，但是获取到了读锁不能继续获取写锁），这是因为读写锁要保持写操作的可见性。
  • 因为，如果允许读锁在被获取的情况下对写锁的获取，那么正在运行的其他读线程无法感知到当前写线程的操作。

因此，
分析读写锁ReentrantReadWriteLock，会发现它有个潜在的问题：读锁全完，写锁有望；写锁独占，读写全堵；
如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁，见前面Case《code演示LockDownGradingDemo》即ReadWriteLock读的过程中不允许写，只有等待线程都释放了读锁，当前线程才能获取写锁，也就是写入必须等待，这是一种悲观的读锁，o(╥﹏╥)o，人家还在读着那，你先别去写，省的数据乱。

2.9 Oracle公司ReentrantWriteReadLock源码总结

锁降级 下面的示例代码摘自ReentrantWriteReadLock源码中：
ReentrantWriteReadLock支持锁降级，遵循按照获取写锁，获取读锁再释放写锁的次序，写锁能够降级成为读锁，不支持锁升级。
解读在最下面:

image-20230423165504760

image-20230423165534559

3. 邮戳锁StampedLock 也叫票据锁

  • StampedLock是JDK1.8中新增的一个读写锁，也是对JDK1.5中的读写锁ReentrantReadWriteLock的优化。
  • stamp（戳记，long类型）
    • 代表了锁的状态。当stamp返回零时，表示线程获取锁失败。并且，当释放锁或者转换锁的时候，都要传入最初获取的stamp值。
  • 它是由锁饥饿问题引出

3.1 锁饥饿问题

ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了，假如当前1000个线程，999个读，1个写，有可能999个读取线程长时间抢到了锁，那1个写线程就悲剧了 因为当前有可能会一直存在读锁，而无法获得写锁，根本没机会写

3.1.1 如何缓解锁饥饿问题？

  • 使用“公平”策略可以一定程度上缓解这个问题
    • 但是“公平”策略是以牺牲系统吞吐量为代价的
  • 邮戳锁
    • 乐观读来解决问题

3.2 StampedLock 和ReentrantReadWriteLock的区别

  • ReentrantReadWriteLock

    允许多个线程同时读，但是只允许一个线程写，在线程获取到写锁的时候，其他写操作和读操作都会处于阻塞状态，
    读锁和写锁也是互斥的，所以在读的时候是不允许写的，读写锁比传统的synchronized速度要快很多，
    原因就是在于ReentrantReadWriteLock支持读并发

  • StampedLock

    ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。
    但是，StampedLock采取乐观获取锁后，其他线程尝试获取写锁时不会被阻塞，这其实是对读锁的优化，
    所以，在获取乐观读锁后，还需要对结果进行校验。

3.3 StampedLock的特点

  • 所有获取锁的方法，都返回一个邮戳（Stamp），Stamp为零表示获取失败，其余都表示成功；
  • 所有释放锁的方法，都需要一个邮戳（Stamp），这个Stamp必须是和成功获取锁时得到的Stamp一致；
  • StampedLock是不可重入的，危险(如果一个线程已经持有了写锁，再去获取写锁的话就会造成死锁)
  • StampedLock有三种访问模式
    • ①Reading（读模式）：功能和ReentrantReadWriteLock的读锁类似
    • ②Writing（写模式）：功能和ReentrantReadWriteLock的写锁类似
    • ③Optimistic reading（乐观读模式）：无锁机制，类似于数据库中的乐观锁，支持读写并发，很乐观认为读取时没人修改，假如被修改再实现升级为悲观读模式

3.4 示例

3.4.1 传统读写功能

package site.zhourui.readWriteLockAndStampedLock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.StampedLock;

public class StampedLockDemo {
    static int number = 37;
    static StampedLock stampedLock = new StampedLock();

    public void write()
    {
        long stamp = stampedLock.writeLock();
        System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程准备修改");
        try
        {
            number = number + 13;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            stampedLock.unlockWrite(stamp);
        }
        System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程结束修改");
    }

    //悲观读
    public void read()
    {
        long stamp = stampedLock.readLock();
        System.out.println(Thread.currentThread().getName()+"\t come in readlock block,4 seconds continue...");
        //暂停几秒钟线程
        for (int i = 0; i <4 ; i++) {
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t 正在读取中......");
        }
        try
        {
            int result = number;
            System.out.println(Thread.currentThread().getName()+"\t"+" 获得成员变量值result：" + result);
            System.out.println("写线程没有修改值，因为 stampedLock.readLock()读的时候，不可以写，读写互斥");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            stampedLock.unlockRead(stamp);
        }
    }
    public static void main(String[] args)
    {
        StampedLockDemo resource = new StampedLockDemo();

        new Thread(() -> {
            resource.read();
        },"readThread").start();

        new Thread(() -> {
            resource.write();
        },"writeThread").start();
    }

}

执行结果:

读完再写,实现了读(悲观读)写锁的功能

image-20230423181558430

3.4.2 乐观读写功能

package site.zhourui.readWriteLockAndStampedLock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.StampedLock;

public class StampedLockDemo {
    static int number = 37;
    static StampedLock stampedLock = new StampedLock();

    public void write()
    {
        long stamp = stampedLock.writeLock();
        System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程准备修改");
        try
        {
            number = number + 13;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            stampedLock.unlockWrite(stamp);
        }
        System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程结束修改");
    }

    //悲观读
    public void read()
    {
        long stamp = stampedLock.readLock();
        System.out.println(Thread.currentThread().getName()+"\t come in readlock block,4 seconds continue...");
        //暂停几秒钟线程
        for (int i = 0; i <4 ; i++) {
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t 正在读取中......");
        }
        try
        {
            int result = number;
            System.out.println(Thread.currentThread().getName()+"\t"+" 获得成员变量值result：" + result);
            System.out.println("写线程没有修改值，因为 stampedLock.readLock()读的时候，不可以写，读写互斥");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            stampedLock.unlockRead(stamp);
        }
    }

    //乐观读
    public void tryOptimisticRead()
    {
        long stamp = stampedLock.tryOptimisticRead();
        int result = number;
        //间隔4秒钟，我们很乐观的认为没有其他线程修改过number值，实际靠判断。
        System.out.println("4秒前stampedLock.validate值(true无修改，false有修改)"+"\t"+stampedLock.validate(stamp));
        for (int i = 1; i <=4 ; i++) {
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t 正在读取中......"+i+
                    "秒后stampedLock.validate值(true无修改，false有修改)"+"\t"
                    +stampedLock.validate(stamp));
        }
        if(!stampedLock.validate(stamp)) {
            System.out.println("有人动过--------存在写操作！");
            stamp = stampedLock.readLock();
            try {
                System.out.println("从乐观读 升级为 悲观读");
                result = number;
                System.out.println("重新悲观读锁通过获取到的成员变量值result：" + result);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                stampedLock.unlockRead(stamp);
            }
        }
        System.out.println(Thread.currentThread().getName()+"\t finally value: "+result);
    }

    public static void main(String[] args)
    {
        StampedLockDemo resource = new StampedLockDemo();

        new Thread(() -> {
//            resource.read();
            resource.tryOptimisticRead();
        },"readThread").start();

        // 2秒钟时乐观读失败，6秒钟乐观读取成功resource.tryOptimisticRead();，修改切换演示
        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            resource.write();
        },"writeThread").start();
    }
}

执行结果:

在读线程执行时,写线程仍然能抢到锁

image-20230423182103657

3.4.2.1 乐观读未升级情况

image-20230423182545533

执行结果:

将写的在读后6秒才开启,读操作早在写操作执行之前就执行完成了,所以不会出现重新悲观读

image-20230423182731408

3.5 缺点

  • StampedLock 不支持重入，没有Re开头
  • StampedLock 的悲观读锁和写锁都不支持条件变量（Condition），这个也需要注意。
  • 使用 StampedLock一定不要调用中断操作，即不要调用interrupt() 方法

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/13534.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

ChatGPT | 申请与使用new bing的实用教程

ChatGPT | 申请与使用new bing的实用教程

1. 教程参考&#xff1a; https://juejin.cn/post/7199557716998078522 2.在参考上述教程遇到的问题与解决 2.1 下载dev浏览器的网址打不开 egde dev下载地址&#xff08;上面网站上的&#xff09;我电脑打不开 换用下面的网址即可 https://www.microsoftedgeinsider.com/z…
阅读更多...
九种 OOM 常见原因及解决方案(IT枫斗者)

九种 OOM 常见原因及解决方案(IT枫斗者)

九种 OOM 常见原因及解决方案(IT枫斗者) 什么是OOM&#xff1f; OOM&#xff0c;全称“Out Of Memory”&#xff0c;翻译成中文就是“内存用完了”&#xff0c;来源于java.lang.OutOfMemoryError。看下关于的官方说明&#xff1a;Thrown when the Java Virtual Machine canno…
阅读更多...
代码随想录算法训练营第三十六天|435. 无重叠区间、763.划分字母区间 、56. 合并区间

代码随想录算法训练营第三十六天|435. 无重叠区间、763.划分字母区间 、56. 合并区间

文章目录 重叠问题435. 无重叠区间763.划分字母区间:star:56. 合并区间 重叠问题 这几道题都是判断区间重叠&#xff0c;区别就是判断区间重叠后的逻辑。 435. 无重叠区间 链接:代码随想录 解题思路&#xff1a; 这道题和射气球的题几乎思路一样 不断求出重叠的最小右区间&a…
阅读更多...
通俗讲解什么是Socket通讯

通俗讲解什么是Socket通讯

Socket通讯原理 1、什么是Socket&#xff1f; Socket&#xff0c;即套接字。就是两台主机之间逻辑连接的端点。&#xff08;通俗来说&#xff1a;网络上的两个程序通过一个双向的通信连接实现数据的交换&#xff0c;这个连接的一端称为一个socket&#xff09;。 Socket是一套…
阅读更多...
CSS基础——盒子模型

CSS基础——盒子模型

目录 简介 盒子模型组成 内容区 内边距 边框 border-width border-color border-style border 外边距 负值 auto 简写属性 垂直外边距的重叠 浏览器默认设置 内联元素的盒子 简介 在网页中&#xff0c;一切都是可以看作为“盒子”。 在css处理网页的时候&…
阅读更多...
常见的四种排名函数的用法（sql）

常见的四种排名函数的用法（sql）

四个排名函数&#xff1a; 1.row_number 2.rank 3.dense_rank 4.ntile 1. ROW_NUMBER&#xff08;排名场景推荐&#xff09; 1.1 介绍 在 SQL 中&#xff0c;ROW_NUMBER() 是一个窗口函数&#xff0c;它为结果集中的每一行分配一个唯一的序号。该函数的语法如下&#xff1a; …
阅读更多...
内网穿透实现在外远程连接RabbitMQ服务

内网穿透实现在外远程连接RabbitMQ服务

文章目录 前言1.安装erlang 语言2.安装rabbitMQ3. 内网穿透3.1 安装cpolar内网穿透(支持一键自动安装脚本)3.2 创建HTTP隧道 4. 公网远程连接5.固定公网TCP地址5.1 保留一个固定的公网TCP端口地址5.2 配置固定公网TCP端口地址 转载自远控源码文章&#xff1a;无公网IP&#xff…
阅读更多...
srm采购管理系统有那些功能

srm采购管理系统有那些功能

srm采购管理系统&#xff0c;是通过系统的手段对采购过程进行管理和控制&#xff0c;实现降低成本、提高效益、提高企业核心竞争力的目的。那么 srm采购管理系统有哪些功能呢&#xff1f; 计划管理 srm采购管理系统提供了各种物料需求计划的功能&#xff0c;以帮助企业制定并控…
阅读更多...
设置环境变量

设置环境变量

文章目录 window设置linux设置python设置 window设置 命令行设置 set 临时设置setx 永久设置 # 打开一个cmd命令行 set # 查看所有环境变量 set FLASK_APPsuperset # 临时设置&#xff0c;当前窗口有效 set FLASK_APP%FLASK_APP%;777 # # 查看 echo %FLASK_APP%# 永久设置…
阅读更多...
k8s安装部署apollo配置中心

k8s安装部署apollo配置中心

一、文章大纲 二、安装MySQL5.7 三、创建apollo-config 四、创建apollo-admin 五、创建apollo-portal 六、查看apollo各个组件服务状态 七、访问apollo 八、nginx代理配置转发#注意 一定要先启动apollo-config&#xff0c;再启动apollo-admin&#xff0c;最后启动apollo-porta…
阅读更多...
matrix部署

matrix部署

一、环境描述 首先matrix是一个去中心化的聊天服务&#xff0c;matrix实现了端对端的加密&#xff0c;这意味着不仅其他人无法查看你的聊天内容&#xff0c;哪怕你更换了一个终端&#xff0c;你也需要私钥才能够查看你的聊天记录。 这是终极的隐私保护方案&#xff0c;因为一旦…
阅读更多...
深入理解机器学习——过拟合（Overfitting）与欠拟合（Underfitting）

深入理解机器学习——过拟合（Overfitting）与欠拟合（Underfitting）

分类目录&#xff1a;《深入理解深度学习》总目录 机器学习的主要挑战是我们的算法必须能够在先前未观测的新输入上表现良好&#xff0c;而不只是在训练集上表现良好。在先前未观测到的输入上表现良好的能力被称为泛化&#xff08;Generalization&#xff09;。通常情况下&…
阅读更多...
20、单元测试

20、单元测试

文章目录 1、JUnit5 的变化2、JUnit5常用注解3、断言&#xff08;assertions&#xff09;1、简单断言2、数组断言3、组合断言4、异常断言5、超时断言6、快速失败 4、前置条件&#xff08;assumptions&#xff09;5、嵌套测试6、参数化测试7、迁移指南 【尚硅谷】SpringBoot2零基…
阅读更多...
医院体检PEIS系统源码

医院体检PEIS系统源码

一、医院体检系统概述 1. 医院体检系统概述 目前&#xff0c;大多数的体检还停留在手工操作上&#xff0c;如单位体检时手工书写体检人员信息、医生手工书写体检结果、检验报告打印后进行手工粘贴等&#xff0c;这样造成极大的工作量&#xff0c;效率低下&#xff0c;而且极易…
阅读更多...
OpenCV 安卓编程示例：1~6 全

OpenCV 安卓编程示例：1~6 全

原文&#xff1a;OpenCV Android Programming By Example 协议&#xff1a;CC BY-NC-SA 4.0 译者&#xff1a;飞龙 本文来自【ApacheCN 计算机视觉 译文集】&#xff0c;采用译后编辑&#xff08;MTPE&#xff09;流程来尽可能提升效率。 当别人说你没有底线的时候&#xff0c;…
阅读更多...
npm和yarn的相同点和不同点

npm和yarn的相同点和不同点

官网 npmhttps://www.npmjs.com Home | Yarn - Package ManagerFast, reliable, and secure dependency management.https://yarnpkg.com Fast, disk space efficient package manager | pnpmFast, disk space efficient package managerhttps://pnpm.io 使用场景 npm&#x…
阅读更多...
发布会前准备新闻通稿的重要性，为什么媒体不会原稿发布报道？

发布会前准备新闻通稿的重要性，为什么媒体不会原稿发布报道？

传媒如春雨&#xff0c;润物细无声&#xff0c;大家好&#xff0c;我是51媒体 胡老师。 最近有宣传的小伙伴问胡老师&#xff0c;为什么我们精心准备的新闻通稿&#xff0c;媒体没有按照稿子发布呢&#xff1f;今天就与大家交流下这方面的经验。 一&#xff0c;发布会前准备新…
阅读更多...
4月20日第壹简报，星期四，农历三月初一，谷雨

4月20日第壹简报，星期四，农历三月初一，谷雨

4月20日第壹简报&#xff0c;星期四&#xff0c;农历三月初一&#xff0c;谷雨坚持阅读&#xff0c;静待花开1. 已致29人死亡&#xff0c;26人为患者&#xff01;北京长峰医院火灾事故因院内施工作业火花引发&#xff0c;院长王某玲等12人被刑拘。2. 海南发布旅游产品参考价格&…
阅读更多...
教你轻松申请Azure OpenAI

教你轻松申请Azure OpenAI

Azure OpenAI 和 OpenAI 官方提供的服务基本是一致的&#xff0c;但是目前前者还是处于预览版的状态&#xff0c;一些功能还没有完全开放。 优点&#xff1a; 不受地域限制&#xff0c;国内可以直接调用。可以自己上传训练数据进行训练&#xff08;据说很贵&#xff09;。Azu…
阅读更多...
低代码开发重要工具：jvs-logic（逻辑引擎）可视化设计要素

低代码开发重要工具：jvs-logic（逻辑引擎）可视化设计要素

逻辑引擎可视化的交互 可视化的服务编排是逻辑引擎的核心功能&#xff0c;逻辑引擎的界面可视化设计是为了方便用户使用和操作逻辑引擎而设计的。一个好的界面设计能够提高用户的工作效率和使用体验&#xff0c;同时也能增加软件的可靠性和可维护性。 以下是逻辑引擎界面可视化…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站