第四章：Java琐事

news2025/7/18 21:14:25

  • 乐观锁和悲观锁
    • 悲观锁
    • 乐观锁
  • 八种案例演示synchronized到底锁的是什么
  • 字节码角度分析 Synchronized
    • synchronized 同步代码块
    • synchronized 同步方法
  • 为什么任意一个对象都可以是锁？
  • 公平锁和非公平锁
      • 为什么会有公平锁/非公平锁的设计？为什么默认是非公平？
  • 可重入锁（递归锁）
    • 隐式锁synchronized
    • 显示锁Lock
  • 死锁及排查
    • 演示死锁
    • 死锁的排查
      • 命令行
      • 图形化界面
  • 总结
  • 以下相当于一些前置知识
      • 图形化界面
  • 总结
  • 以下相当于一些前置知识

乐观锁和悲观锁

悲观锁

  • 悲观锁认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改。

  • 悲观锁的实现方式

    • synchronized关键字
    • Lock的实现类都是悲观锁

  • 适合写操作多的场景，先加锁可以保证写操作时数据正确。显示的锁定之后再操作同步资源。

//=============悲观锁的调用方式
public synchronized void m1()
{
    //加锁后的业务逻辑......
}

// 保证多个线程使用的是同一个lock对象的前提下
ReentrantLock lock = new ReentrantLock();
public void m2() {
    lock.lock();
    try {
        // 操作同步资源
    }finally {
        lock.unlock();
    }
}

乐观锁

  • 乐观锁认为自己在使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有别的线程更新了这个数据。如果这个数据没有被更新，当前线程将自己修改的数据成功写入。如果数据已经被其他线程更新，则根据不同的实现方式执行不同的操作
  • 乐观锁的实现方法：
    • 版本号机制Version。（只要有人提交了就会修改版本号，可以解决ABA问题）
    • 最常采用的是CAS算法，Java原子类中的递增操作就通过CAS自旋实现的。
  • 适合读操作多的场景，不加锁的性能特点能够使其操作的性能大幅提升。
//=============乐观锁的调用方式
// 保证多个线程使用的是同一个AtomicInteger
private AtomicInteger atomicInteger = new AtomicInteger();
atomicInteger.incrementAndGet();

八种案例演示synchronized到底锁的是什么

阿里巴巴多锁的要求：

  • 【强制】高并发时，同步调用应该去考量锁的性能损耗。能用无锁数据结构，就不要用锁；能锁区块，就不要锁整个方法体；能用对象锁，就不要用类锁。
  • 简单一句话：能不用就不用，即使用尽量将 synchronized 的同步代码快缩小。

演示八种案例：

/**
 *
 * Author: YZG
 * Date: 2022/11/13 21:22
 * Description:
 * 1 标准访问，先打印短信还是邮件
 * --------- sendSMS
 * --------- sendEmail
 *
 * 2停4秒在短信方法内，先打印短信还是邮件
 * --------- sendSMS
 * --------- sendEmail
 * 3新增普通的hello方法,是先打短信还是hello
 *
 * --------- sendHello
 * --------- sendSMS
 * 4现在有两部手机，先打印短信还是邮件
 *
 *--------- sendEmail
 * --------- sendSMS
 *
 * 5两个静态同步方法, 1部手机,先打印短信还是邮件
 *--------- sendSMS
 * --------- sendEmail
 *
 * 6两个静态同步方法, 2部手机，先打印短信还是邮件
 *--------- sendSMS
 * --------- sendEmail
 *
 * 7 1个静态同步方法1个普通同步方法，1部手机，先打印短信还是邮件
 *--------- sendEmail
 * --------- sendSMS
 *
 * 8 1个静态同步方法, 1个普通同步方法, 2部手机,先打印短信还是邮件
 *--------- sendEmail
 * --------- sendSMS
 */
public class Demo06 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        // Phone phone2 = new Phone();

        new Thread(Phone::sendEMS,"t1").start();

        TimeUnit.MILLISECONDS.sleep(20);

        new Thread(phone::sendEmail,"t2").start();
    }
}

class Phone {

    public synchronized void sendEMS(){
        // try {
        //     TimeUnit.SECONDS.sleep(4);
        // } catch (InterruptedException e) {
        //     e.printStackTrace();
        // }
        System.out.println("--------- sendSMS");
    }

    public  synchronized  void sendEmail() {
        System.out.println("--------- sendEmail");
    }

    public  void sendHello() {
        System.out.println("--------- sendHello");
    }
}

总结

  • 对于普通同步方法，锁是当前实例对象。
  • 对于静态同步方法，锁是当前类的Class对象。
  • 对于同步方法块,锁是Synchoni zed括号里配置的对象

字节码角度分析 Synchronized

反编译指令：

  • 文件反编译javap -c ***.class文件反编译，-c表示对代码进行反汇编

  • 假如需要更多信息 javap -v ***.class ，-v即-verbose输出附加信息（包括行号、本地变量表、反汇编等详细信息）

JVM 指令的学习笔记： JVM

synchronized 同步代码块

代码

public class LockSyncTest {

    private Object obj = new  Object();

    public void m1() {
        synchronized (obj) {
            System.out.println("hello");
        }

    }

    public static void main(String[] args) {

    }
}

字节码

image-20221121162454284

结论：

synchronized 经过编译之后，会在同步代码块前后生成 monitorenter 和 monitorexit 俩个指令。在执行 monitorenter 指令时，会尝试获取对象锁，如果对象锁被占用，或者锁对象的持有线程是当前线程，锁的计数器就会 +1，响应的执行 monitorexit 指令时，锁的计数器会 -1 ， 计数器为 0 时 表示 锁已经被释放。

第二个 monitorexit 是为了防止同步代码块出现异常。

synchronized 同步方法

代码：

    public synchronized void m2() {
            System.out.println("hello");

    }

字节码；

image-20221121163633383

image-20221121163739471

结论：

通过字节码我们可以看，同步方法是隐式的，不需要JVM生成字节码指令，在是在访问标志中指出。调用方法时，调用指令会检查方法的 ACC_ SYNCHRONIZED 访问标志是否设置。

  • 如果设置了，执行线程将先持有同步锁，然后执行方法。最后在方法完成(无论是正常完成还是非正常完成)时释放同步锁。

静态同步方法与普通同步方法的区别就是访问标识中加了 static

image-20221121164119749

为什么任意一个对象都可以是锁？

在 Java 中任意一个对象都可以是锁，这是为什么呢？

多线程的锁，其实本质上就是给一块内存空间的访问添加访问权限，因为Java中是没有办法直接对某一块内存进行操作的，又因为Java是面向对象的语言，一切皆对象，所以具体的表现就是某一个对象承担锁的功能，每一个对象都可以是一个锁。

其实看到对象的内存结构就很清晰明了，每个对象的对象头都包含 锁状态标志 和 线程持有的锁

image-20221121165342470

另一方面，从C源码中可以看出：

  • ObjectMonitor.java→ObjectMonitor.cpp→objectMonitor.hpp
    • ObjectMonitor.cpp中引入了头文件，（include）objectMonitor.hpp
140行
  ObjectMonitor() {
    _header       = NULL;
    _count        = 0; //用来记录该线程获取锁的次数
    _waiters      = 0,
    _recursions   = 0;//锁的重入次数
    _object       = NULL;
    _owner        = NULL; //------最重要的----指向持有ObjectMonitor对象的线程，记录哪个线程持有了我
    _WaitSet      = NULL; //存放处于wait状态的线程队列
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;
    FreeNext      = NULL ;
    _EntryList    = NULL ;//存放处于等待锁block状态的线程队列
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
    _previous_owner_tid = 0;
  }
  • 追溯底层可以发现每个对象天生都带着一个对象监视器。

公平锁和非公平锁

公平锁：多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。

  • 优点：所有的线程都能得到资源，不会饿死在队列中。
  • 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。

非公平锁：多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。

  • 优点：可以减少CPU唤醒线程的开销，整体的吞吐效率会高点，CPU也不必取唤醒所有线程，会减少唤起线程的数量。
  • 缺点：可能导致队列中间的线程一直获取不到锁或者长时间获取不到锁，导致饿死。

synchronized 为非公平锁，ReentrantLock默认也是非公平锁，可通过设置参数 true 创建公平锁

买票案例代码：

//第一步  创建资源类，定义属性和和操作方法
class LTicket {
    //票数量
    private int number = 30;

    // 设置公平锁
    private final ReentrantLock lock = new ReentrantLock(true);
    //卖票方法
    public void sale() {
        //上锁
        lock.lock();
        try {
            //判断是否有票
            if(number > 0) {
                System.out.println(Thread.currentThread().getName()+" ：卖出"+(number--)+" 剩余："+number);
            }
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

public class Demo07 {
    //第二步 创建多个线程，调用资源类的操作方法
    //创建三个线程
    public static void main(String[] args) {

        LTicket ticket = new LTicket();

        new Thread(()-> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"AA").start();

        new Thread(()-> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"BB").start();

        new Thread(()-> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"CC").start();
    }
}

为什么会有公平锁/非公平锁的设计？为什么默认是非公平？

  1. 恢复挂起的线程到真正锁的获取还是有时间差的，从开发人员来看这个时间微乎其微，但是从CPU的角度来看，这个时间差存在的还是很明显的。所以非公平锁能更充分的利用CPU 的时间片，尽量减少 CPU 空闲状态时间。
  2. 使用多线程很重要的考量点是线程切换的开销，当采用非公平锁时，当1个线程请求锁获取同步状态，然后释放同步状态，因为不需要考虑是否还有前驱节点，所以刚释放锁的线程在此刻再次获取同步状态的概率就变得非常大，所以就减少了线程的开销。

可重入锁（递归锁）

什么是 “可重入”，可重入就是说某个线程已经获得某个锁，可以再次获取锁 (同一把锁) 而不会出现 死锁。

synchronized 和 ReentrantLock 都是可重入锁

隐式锁synchronized

同步代码块方式：

public class LockSyncTest02 {
    public static void main(String[] args) {
        Object o = new Object();
        new Thread(() -> {
            synchronized (o) {
                System.out.println(Thread.currentThread().getName() + " .....外层调用");
                synchronized (o) {
                    System.out.println(Thread.currentThread().getName() + " .....中层调用");
                    synchronized (o) {
                        System.out.println(Thread.currentThread().getName() + " .....内层调用");
                    }
                }
            }
        }, "t1").start();
    }
}

输出结果：

t1 .....外层调用
t1 .....中层调用
t1 .....内层调用

同步方法方式：

public class LockSyncTest02 {

    public synchronized void m1() {
        System.out.println(Thread.currentThread().getName() + " .....m1 come in");
        m2();
        System.out.println(Thread.currentThread().getName() + " .....m1 end");

    }

    private synchronized void m2() {
        System.out.println(Thread.currentThread().getName() + " .....m2 come in");
        m3();
        System.out.println(Thread.currentThread().getName() + " .....m2 end");

    }

    private synchronized void m3() {
        System.out.println(Thread.currentThread().getName() + " .....m3 come in");
        System.out.println(Thread.currentThread().getName() + " .....m3 end");

    }

    public static void main(String[] args) {
        LockSyncTest02 lockSyncTest02 = new LockSyncTest02();
        lockSyncTest02.m1();
    }
}

输出结果：

main .....m1 come in
main .....m2 come in
main .....m3 come in
main .....m3 end
main .....m2 end
main .....m1 end

Process finished with exit code 0

显示锁Lock

注意事项：

  • 由于Lock需要手动上锁释放锁，因此上锁和释放锁的次数一定要对应上。否则在多线程的场景下，很容易造成阻塞，甚至死锁。
public class Demo09 {
    public static void main(String[] args) {

        ReentrantLock lock = new ReentrantLock();
        try {
            lock.lock(); // 上锁
            System.out.println(Thread.currentThread().getName() + " 第一次获取锁");
            try {
                lock.lock(); // 上锁
                System.out.println(Thread.currentThread().getName() + " 第二次获取锁");
            } finally {
               lock.unlock(); // 解锁
            }
        } finally {
            lock.unlock(); // 解锁
        }
    }
}

演示 Lock 出现阻塞的情况：

由于主线程在第二次获取锁的时候，并没有手动释放锁，造成了t1线程一直处在阻塞状态

public class LockTest {
    public static void main(String[] args) {

        ReentrantLock lock = new ReentrantLock();
        try {
            lock.lock(); // 上锁
            System.out.println(Thread.currentThread().getName() + " 第一次获取锁");
            try {
                lock.lock(); // 上锁
                System.out.println(Thread.currentThread().getName() + " 第二次获取锁");
            } finally {
                // lock.unlock(); // 解锁
            }
        } finally {
            lock.unlock(); // 解锁
        }

        new Thread(() -> {
            lock.lock();
            System.out.println(Thread.currentThread().getName());
            lock.unlock();
        }, "t1").start();
    }
}

通过 jstack 命令查看 t1 线程的状态：

image-20221121174716248

image-20221121174643010一直在等待 main 线程释放锁。

死锁及排查

什么是死锁？

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

image-20221121175456095

演示死锁

public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        new Thread(() -> {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + " 占用 o1，试图获取o2");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (o2) {
                    System.out.println(Thread.currentThread().getName() + " 占用 o2");
                }
            }
        }, "t1").start();


        new Thread(() -> {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 占用 o2，试图获取o1");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (o1) {
                    System.out.println(Thread.currentThread().getName() + " 占用 o1");
                }
            }
        }, "t2").start();
    }
}

死锁产生的原因

  • 系统资源不足
  • 进程运行推进的顺序不合适
  • 资源分配不当

死锁的排查

更详细的JVM指令笔记： JVM

命令行

使用 jps + jstack

image-20221121180712515

可以看出死锁的线程：

image-20221121180743433

图形化界面

控制台输入 JConsole，弹出如图界面，它是jdk内置的一个监视控制台。

选中运行的类进行连接

image-20221121180900316

从这里也可以看出出现死锁

image-20221121181014482

总结

指针指向monitor对象（也称为管程或监视器锁）的起始地址。每个对象都存在着一个monitor与之关联，当一个monitor被某个线程持有后，它便处于锁定状态。在Java虚拟机(HotSpot)中，monitor是由ObjectMonitor实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp,C++实现的）

在这里插入图片描述

以下相当于一些前置知识

写锁（独占锁）/读锁（共享锁）—— 见第十四章

自旋锁SpinLock —— 见第八章

无锁-独占锁-读写锁-邮戳锁 —— 见第十四章

无锁-偏向锁-轻量锁-重量锁 —— 见第十二章

各位彭于晏，如有收获点个赞不过分吧…✌✌✌

图形化界面

控制台输入 JConsole，弹出如图界面，它是jdk内置的一个监视控制台。

选中运行的类进行连接

[外链图片转存中…(img-KOjAC3Uj-1669382823739)]

从这里也可以看出出现死锁

[外链图片转存中…(img-Duv6zL7X-1669382823739)]

总结

指针指向monitor对象（也称为管程或监视器锁）的起始地址。每个对象都存在着一个monitor与之关联，当一个monitor被某个线程持有后，它便处于锁定状态。在Java虚拟机(HotSpot)中，monitor是由ObjectMonitor实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp,C++实现的）

在这里插入图片描述

以下相当于一些前置知识

写锁（独占锁）/读锁（共享锁）—— 见第十四章

自旋锁SpinLock —— 见第八章

无锁-独占锁-读写锁-邮戳锁 —— 见第十四章

无锁-偏向锁-轻量锁-重量锁 —— 见第十二章

各位彭于晏，如有收获点个赞不过分吧…✌✌✌

Alt

扫码关注公众号 【我不是秃神】 回复 JUC 可下载 MarkDown 笔记

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

计算机毕业设计jspKTV点歌系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

计算机毕业设计jspKTV点歌系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

一、源码特点 JSP KTV点歌系统 是一套完善的web设计系统&#xff0c;对理解JSP java编程开发语言有帮助&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要采用B/S模式开发。开发环境为TOMCAT7.0,Myeclipse8.5开 发&#xff0c;数据库为Mysql&#xff0c;使用jav…
阅读更多...
Transformer Fusion for Indoor RGB-D Semantic Segmentation非官方自己实现的代码

Transformer Fusion for Indoor RGB-D Semantic Segmentation非官方自己实现的代码

声明&#xff1a;文章没有官方的代码&#xff0c;这里自己浅显的分析一下。 首先看一下encoder&#xff0c;就是swin transformer&#xff0c;假设RGB的维度为(1,3,480,480),Depth维度为(1,1,480,480)。维度分别变为**(1,64,120,120)—>(1,64,120,120)—>(1,128,60,60)—…
阅读更多...
关于conda、虚拟环境、镜像通道、pip、pycharm解释器配置的一些总结

关于conda、虚拟环境、镜像通道、pip、pycharm解释器配置的一些总结

目录conda与虚拟环境相关命令查看当前存在哪些虚拟环境创建虚拟环境克隆虚拟环境删除指定虚拟环境删除指定虚拟环境中某个包设置国内镜像添加Anaconda的TUNA镜像添加USTC仓库镜像设置搜索时显示通道地址Conda 附加库查看channels恢复默认镜像&#xff08;即删除手动配置的全部镜…
阅读更多...
TCP/IP五层协议栈(1)

TCP/IP五层协议栈(1)

1.应用层协议 应用层协议相对来说比较简单,因为其他层的协议属于硬件上的.相对程序员来说已经固定了.不需要自己设计和实现了. 设计应用层协议有两个要点 要约定好传输的数据还要约定好数据的格式 1.1.协议模板 虽说可以自己设计,不过当前已经有很多模板被大佬设计好了.这…
阅读更多...
51单片机语音进店迎宾器统计进店人数可定制播报铃声（可选PCB）

51单片机语音进店迎宾器统计进店人数可定制播报铃声（可选PCB）

实践制作DIY- GC0115-语音进店迎宾器统计进店人数 一、功能说明&#xff1a; 基于51单片机设计-语音进店迎宾器统计进店人数 功能介绍&#xff1a; 硬件组成&#xff1a;STC89C52&#xff08;AT89C51/52&#xff09;单片机串口语音播报模块2个红外对射传感器一个按键&#x…
阅读更多...
C++不知算法系列之高精度数值处理算法

C++不知算法系列之高精度数值处理算法

1. 前言 什么是高精度数值处理算法&#xff1f; 高精度数值指因受限于计算机硬件的制约&#xff0c;超过计算机所能存储范围的数值。既然不能存储&#xff0c;更谈不上运算。 对此类数值的加、减、乘、除运算需要提供针对性的算法方能获取到结果。此类算法的设计思路因有别于…
阅读更多...
VMware环境配置

VMware环境配置

文章目录一、环境配置1、修改主机名&#xff0c;然后切换到root用户2、确认主机网关a.确认windows主机网关b.确认虚拟机主机网关3、修改网络配置4、设置DNS域名解析的配置文件resolv.conf。5、修改hosts文件6、重启网络服务7、验证网络服务a.虚拟机ping百度b.主机ping虚拟机二、…
阅读更多...
vscode使用restClient实现各种http请求

vscode使用restClient实现各种http请求

vscode使用restClient实现各种http请求 一&#xff0c;安装插件 首先&#xff0c;我们要在vscode的扩展中&#xff0c;搜索rest Client&#xff0c;然后安装它&#xff0c;这里我已经安装过了。 安装后&#xff0c;我们就可以使用rest client插件进行http各种操作了。 二&a…
阅读更多...
MySQL---权限控制和用户、角色管理详解

MySQL---权限控制和用户、角色管理详解

目录 一、MySQL用户登录 二、用户管理 三、权限控制 四、角色管理 一、MySQL用户登录 一般在本机上我们的登录命令&#xff1a; mysql -u root -p密码这里介绍命令的作用&#xff1a; -u 指定用户名 -h 指定主机地址&#xff08;默认为localhost&#xff09; -p 指定用…
阅读更多...
CHRONY - 时钟同步

CHRONY - 时钟同步

一、同步公网时间源 安装chrony： yum install chrony -y 查看chrony的重要配置文件：rpm -ql chrony 修改chrony配置文件： vim /etc/chrony.conf 查看修改了的配置文件 egrep -v "^#|^$" /etc/chrony.conf
阅读更多...
Baklib知识库|为什么知识共享工具对减少内部知识缺口至关重要

Baklib知识库|为什么知识共享工具对减少内部知识缺口至关重要

你的企业是否存在知识缺口&#xff1f; 知识缺口——没有对关键知识进行研究和记录&#xff0c;以有效地传播信息&#xff0c;并教育企业内外的用户——可能是寻求生产率最大化并最终实现利润增长的公司的一个关键缺陷。知识&#xff08;或数据、关键信息等&#xff09;是你的…
阅读更多...
你一定要知道的四个程序员接外包的网站，悄悄把技术变现！

你一定要知道的四个程序员接外包的网站，悄悄把技术变现！

说起程序员接外包的网站&#xff0c;你在网上一搜发现数不胜数&#xff0c;但真正有用的却很少。然后你想快速的找到几个靠谱的网站&#xff0c;去看了看接外包的攻略&#xff0c;你会发现排雷的又数不胜数。一时间你还真不知道要选哪一个。 接下来就为大家推荐几个我认为比较…
阅读更多...
165 pbi-utils 使用文档

165 pbi-utils 使用文档

165 pbi-utils 使用文档 一、背景 先来说一下为什么会有 pbi-utils 这个小工具吧。在我日常做演示的示例文件的时候&#xff0c;每次都要重新搞一次 Power BI Desktop&#xff0c;就想能不能像 PPT 模板那样&#xff0c;搞一个模板&#xff0c;然后更专心的去专注内容本身呢&…
阅读更多...
网络规划.1.扩展.IP地址规划

网络规划.1.扩展.IP地址规划

第一章 IPv4 Internet中有数百万台以上的主机和路由器&#xff0c;IP 地址可以确切地标识它们。- 一台主机至少拥有一-个IP地址。任何两台主机的IP地址不能相同&#xff0c;但是允许一台主机拥有多个IP地址。如果一台计算机虽然也连入Internet, 使用Internet 的某些功能&#…
阅读更多...
Android 开发中原始音频的录播和和自定义音频控制条的讲解及实战（超详细 附源码）

Android 开发中原始音频的录播和和自定义音频控制条的讲解及实战（超详细 附源码）

需要源码请点赞关注收藏后评论区留下QQ~~~ 一、原始音频的录播 语音通话功能要求实时传输&#xff0c;如果使用MediaRecorder与MediaPlayer组合&#xff0c;那么只能整句话都录完并编码好了才能传给对方去播放&#xff0c;这个时效性太差。 此时用到音频录制器AudioRecord与音…
阅读更多...
[附源码]Python计算机毕业设计二手书交易系统

[附源码]Python计算机毕业设计二手书交易系统

项目运行 环境配置&#xff1a; Pychram社区版 python3.7.7 Mysql5.7 HBuilderXlist pipNavicat11Djangonodejs。 项目技术&#xff1a; django python Vue 等等组成&#xff0c;B/S模式 pychram管理等等。 环境需要 1.运行环境&#xff1a;最好是python3.7.7&#xff0c;…
阅读更多...
企业如何提供安全方面的投资回报率？

企业如何提供安全方面的投资回报率？

为什么增加在恢复方面的投资可以提高投资回报率? 所有企业都会认可安全的重要性&#xff0c;但在安全上的投入却经常令人迷惑。 一方面&#xff0c;由于安全威胁在不断变化&#xff0c;所以&#xff0c;安全建设维护需要长期持续大量投入。另一方面&#xff0c;长期大量投入后…
阅读更多...
第6章 集成第3方依赖注入中间件“Autofac”

第6章 集成第3方依赖注入中间件“Autofac”

“Blog.Core-master”示例程序中接口及其具体实现类的注入操作&#xff0c;是通过第3方依赖注入中间件“Autofac”来以反射方式把Service.dll 程序集中所有接口及其具体实现类的实例依赖注入内置容器中。.Net(Core).x框架是中的内置依赖注入容器是不支持程序集注入的。 从最佳实…
阅读更多...
葡萄糖-聚乙二醇-人血清白蛋白,HAS-PEG-Glucose,人血清白蛋白-PEG-葡萄糖

葡萄糖-聚乙二醇-人血清白蛋白,HAS-PEG-Glucose,人血清白蛋白-PEG-葡萄糖

葡萄糖-聚乙二醇-人血清白蛋白,HAS-PEG-Glucose,人血清白蛋白-PEG-葡萄糖 人血清白蛋白(HSA)是一种高度水溶性的球状单体血浆蛋白&#xff0c;相对分子量为67KDa&#xff0c;由585个氨基酸残基、一个巯基和17个二硫键组成。在纳米颗粒载体中&#xff0c;HSA纳米颗粒与各种药物…
阅读更多...
直播预告丨中高频多因子库存储的最佳实践

直播预告丨中高频多因子库存储的最佳实践

因子挖掘是量化交易的基础。随着历史交易数据日益增多&#xff0c;交易市场量化竞赛的不断升级和进化&#xff0c;量化投研团队开始面对数据频率高、因子数量多的场景&#xff0c;以10分钟线10000个因子5000个股票为例&#xff0c;一年的因子数据约为 2.3T 左右&#xff0c;1分…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023