2021.10.18 每日学习打卡

最新推荐文章于 2024-09-21 10:38:43 发布
最新推荐文章于 2024-09-21 10:38:43 发布
阅读量121 收藏
点赞数
分类专栏： 打卡学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TimorHasug/article/details/120844176
版权

线程方法

  1. 更改线程优先级 setPriority（int newPriority）

  2. 指定的毫米数内让当前执行的线程休眠（static void sleep（long millis））

  3. 等待该线程终止（void join（））

  4. 暂停当前正在执行的线程对象，并执行其他线程 static void yield（）

  5. 中断线程（勿用，容易搞出事）

  6. 测试线程是否处于活动状态

停止线程的方法

一般使用标志flag，让线程自己停止

package com.wang.Thread.state;
//测试停止线程
​
//1.利用次数，让线程正常停止
//2.利用标志位
//3.不要使用stop或destroy等JDK不建议使用的方法
public class TestStop implements Runnable{
​
    private boolean flag = true;
    @Override
    public void run(){
        int i = 0;
        while (flag){
            System.out.println("Run Thread"+i++);
        }
    }
​
    //设置一个公开的方法停止线程（转换标志位）
    public void stop(){
        this.flag = false;
    }
​
    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i==500){
                testStop.stop();
                System.out.println("线程停止了");
            }
        }
    }
}
​
​

线程的休眠

  • sleep制定当前线程的阻塞毫秒数

  • sleep存在异常interruptedException

  • sleep时间到达后线程进入就绪状态

  • sleep可以模拟网络延时，倒计时等

  • 每一个对象都有一把锁，sleep不会释放锁

package com.wang.Thread.state;
​
import java.text.SimpleDateFormat;
import java.util.Date;
​
//模拟倒计时
public class TestSleep2 {
    public static void main(String[] args) {
​
    //打印当前系统时间
        Date startTime = new Date(System.currentTimeMillis());
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis());//更新当前时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
​
//模拟倒计时
    public static void tenDown() throws InterruptedException {
        int num = 10;
​
        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0)
                break;;
        }
    }
}
​

线程的礼让

  • 让当前正在执行的线程暂停，但不阻塞

  • 将线程从运行转为就绪

  • 让CPU重新调度，礼让不一定成功，看CPU“心情”

package com.wang.Thread.state;
​
​
//测试礼让线程，礼让不一定成功
public class TestYield {
​
​
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}
​
​
class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread()+"线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread()+"线程停止执行");
    }
}

线程强制执行

  • Join合并线程，待此线程完成后，再执行其他线程，其他线程阻塞

  • 插队

package com.wang.Thread.state;
//测试join方法，想象为插队
public class TestJoin implements Runnable{
​
​
    @Override
    public void run() {
        //测试使用时一定要循环次数大，才比较明显
        for (int i = 0; i < 10000; i++) {
            System.out.println("插队的来了"+i);
​
        }
    }
​
    public static void main(String[] args) throws InterruptedException {
        //启动我们的线程
         TestJoin testJoin = new TestJoin();
        Thread thread1 = new Thread(testJoin);
        thread1.start();
        for (int i = 0; i < 1000; i++) {
            if(i==200){
                thread1.join();
            }
            System.out.println("main"+i);
        }
​
​
​
    }
}
​
​
​

线程状态观测

  1. NEW

  2. RUNNABLE

  3. BLOCKED

  4. WAITTING

  5. TIMED_WAITING

  6. TERMINATED

package com.wang.Thread.state;
//观察测试线程的状态
public class TestState {
​
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("OOOOOOOO");
        });
        
        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);//new
​
        //观察启动后
        thread.start();
        System.out.println(state);//run
        //只要线程不终止，就一直输出状态
        while(state!=Thread.State.TERMINATED){
            Thread.sleep(10);
            state = thread.getState();
            System.out.println(state);
        }
        //死亡之后的线程无法再次启动
    }
}
​

  • 线程死亡后就不能再次启动

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行

  • 优先级用数字表示1-5-10

  • getPriority() setPriority()

package com.wang.Thread.state;
//测试线程的优先级
public class TestPriority {
​
    public static void main(String[] args) {
        MyPriority myPriority = new MyPriority();
​
        Thread t1 = new Thread(myPriority);
        Thread t0 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        t0.setPriority(2);
        t0.start();
        t1.start();
        t2.setPriority(Thread.MIN_PRIORITY);
        t2.start();
        t3.setPriority(8);
        t3.start();
        t4.setPriority(Thread.NORM_PRIORITY);
        t4.start();
        t5.setPriority(Thread.MAX_PRIORITY);
        t5.start();
​
        //主线程优先级
        System.out.println(Thread.currentThread().getName()+"--"+Thread.currentThread().getPriority());
    }
​
}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--"+Thread.currentThread().getPriority());
    }
}

优先级高的是可以先跑，但是不一定先运行，只是概率高，还是看CPU的调度

守护线程daemon

  • 线程分为用户线程和守护线程

  • 虚拟机必须确保用户线程执行完毕

  • 虚拟机不用等待守护线程执行完毕

  • 如：后台记录操作日志，监控内存，垃圾回收等

package com.wang.Thread.state;
//测试守护线程
//god bless u
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();
​
        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认是false表示是用户线程，正常的线程都是用户线程
        thread.start();
        new Thread(you).start();
    }
}
​
​
class You implements Runnable{
​
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("一生开心的活着");
        }
        System.out.println("goodbye world");
    }
}
​
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑着你");
        }
    }
}
​
​

线程同步 *

多个线程操作同一个对象(并发发生时) 秒杀机制 宏观上并行，微观上并发

需要访问该对象的线程进入该对象的对象等待池排队

  • 锁机制(synchronized)

    • 一个线程持有锁会导致其他线程挂起

    • 多线程竞争，会额外的消耗系统资源

    • 优先级高的等待优先级低的，导致优先级倒置，性能问题

不安全的案例:

package com.wang.Thread.syn;
//不安全的买票
public class UnsafeBuyTicket {
​
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"dd").start();
        new Thread(buyTicket,"ss").start();
        new Thread(buyTicket,"aa").start();
    }
}
​
​
class BuyTicket implements Runnable{
    //票
    private int ticketNums = 10;
    boolean flag = true;
    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
​
    private void buy() throws InterruptedException {
        //判断是否有票
        if(ticketNums<=0){
            flag = false;
            return;
        }
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"买到了"+ticketNums--);
    }
}

同步方法

synchronized关键字机制

  • synchronize方法控制对this对象（默认对象）的访问

  • 每个对象都有一把锁

  • 每个synchronize方法都要拿到这个锁才能执行

  • 结束时释放该锁

同步方法锁的太多，浪费资源

package com.wang.Thread.syn;
//安全的买票
public class UnsafeBuyTicket {
​
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"dd").start();
        new Thread(buyTicket,"ss").start();
        new Thread(buyTicket,"aa").start();
    }
}
​
​
class BuyTicket implements Runnable{
    //票
    private int ticketNums = 10;
    boolean flag = true;
    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
//变成同步方法,锁的是this
    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if(ticketNums<=0){
            flag = false;
            return;
        }
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"买到了"+ticketNums--);
    }
}

同步块

  • synchronized（Obj）{}

    • 称为同步监视器

    • Obj可以是任何对象，但是推荐使用共享资源做Obj

    • 锁的是实际改变的对象

    • {}内为要锁住对象之后，才能进行的操作

package com.wang.Thread.syn;
​
import com.wang.OOP.A;
//安全，使用了synchronized
// 同步块
public class UnsafeBank {
​
    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"买房钱");
        Drawing woman = new Drawing(account,100,"女方");
        Drawing man = new Drawing(account,50,"男方");
        man.start();
       woman.start();
​
    }
}
​
class Account{
    int money;
    String name;
​
    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
​
class Drawing extends Thread{
    Account account;
    //取了多少钱
    int drawingMoney;
    //现在手里的钱
    int nowMoney;
​
    public Drawing(Account account,int drawingMoney,String name){
        this.account = account;
        this.drawingMoney = drawingMoney;
        this.nowMoney = nowMoney;
    }
​
    public void run(){
        synchronized (account){
            if(account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"没这么多钱");
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money = account.money - drawingMoney;
            nowMoney = nowMoney + drawingMoney;
            System.out.println("余额为"+account.money);
            System.out.println(this.getName()+"手里有"+nowMoney);
        }
        }
​
}

JUC 的CopyOnWriteArrayList

package com.wang.Thread.syn;
​
import java.util.concurrent.CopyOnWriteArrayList;
//测试JUC安全类型的集合
public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            });
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}
​

死锁

package com.wang.Thread;
//死锁
//等待对方释放资源
public class DeadLock {
    public static void main(String[] args) {
        Makeup girl1 = new Makeup(1,"wang");
        Makeup girl2 = new Makeup(0,"li");
        girl1.start();
        girl2.start();
    }
​
}
​
class  LipStick{
​
}
​
class Mirror{
​
}
​
class Makeup extends Thread{
​
    static LipStick lipStick = new LipStick();
    static Mirror mirror = new Mirror();
​
    int choice;
    String girlName;
    @Override
    public void run() {
        makeup();
    }
​
     Makeup(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }
    private void makeup(){
        if(choice==0){
            synchronized (lipStick){
                System.out.println(this.girlName+"拿到口红");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
​
​
            } synchronized (mirror){
                System.out.println(this.girlName+"拿到镜子");
            }
        }
        else{
            synchronized (mirror){
                System.out.println(this.girlName+"拿到镜子");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
​
​
            }  synchronized (lipStick){
                System.out.println(this.girlName+"拿到口红");
            }
        }
        }
​
    }
​

Lock(ReentrantLock)

和synchronized一模一样

  • ReentrantLock类实现了Lock，常用

  • 用于同步问题中加锁

  • Lock锁性能更好

生产者消费者问题

synchronized不能用来实现不同线程之间的消息传递

  1. 缓冲区解决方式

  2. 信号灯法

线程通信

  1. wait() 表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁

  2. wait(long timeout) 指定等待的毫秒数

  3. notify() 唤醒一个处于等待状态的线程

  4. notifyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

均是Object类的方法，都只能在同步方法或同步代码块中使用

package com.wang.Advanced;
​
import java.awt.*;
​
//测试生产者消费者模型
//利用缓冲区，管程法
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
​
    }
​
}
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container = container;
    }
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了"+i+"只鸡");
            container.push(new Chicken(i));
        }
    }
}
​
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer container){
        this.container = container;
    }
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("吃了"+container.pop().id+"只鸡");
        }
    }
}
​
class Chicken{
    int id;//产品编号
​
    public Chicken(int id) {
        this.id = id;
    }
}
​
//缓冲区
class SynContainer{
    Chicken[] chickens = new Chicken[10];
    int count = 0;
    //生产者放入产品
    public synchronized void push(Chicken chicken){
        if(count == chickens.length){
            //通知等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            chickens[count] = chicken;
            this.notifyAll();
        }
        //放入产品
        chickens[count] = chicken;
        count++;
        //通知消费
​
    }
​
​
    //消费者取出产品
​
    public synchronized Chicken pop(){
        if(count==0){
            //等待生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken = chickens[count];
        this.notifyAll();
        return chicken;
​
    }
}

信号灯法

缓存为1的管程法

线程池

提升性能

思路：提前创建许多线程放入线程池，使用时获取，用完放回，避免频繁销毁创建

  • 提升响应速度-----减少创建线程的时间

  • 降低资源消耗-----重复利用池中的线程

  • 便于线程管理

    • corePoolSize 核心池的大小

    • maximumPoolSize 最大线程数

    • keepAliveTime 线程没有任务时最多保持多长时间后停止

package com.wang.Advanced;
​
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
​
//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        //newFixedThreadPool参数为大小
        ExecutorService service = Executors.newFixedThreadPool(10);
​
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
​
        //2.关闭连接
        service.shutdown();
    }
​
}
​
class MyThread implements Runnable{
    @Override
    public void run() {
​
            System.out.println(Thread.currentThread().getName());
        
    }
}
​

总结线程的三种创建方法

package com.wang.Advanced;
​
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
​
//回顾线程的创建
public class ThreadSummary {
    public static void main(String[] args) {
        new MyThread1().start();
​
        new Thread(new MyThread2()).start();
​
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
        new Thread(futureTask).start();
        try {
            Integer integer = futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
​
​
//1.继承Thread类
​
class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("MY THREAD1");
    }
}
//2.实现Runnable接口
class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("MY THREAD2");
    }
}
​
//3.实现Callable接口
class MyThread3 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("MY THREAD3");
        return 100;
    }
}
东东冲冲冲
关注
专栏目录
2021入职一年教师述职报告.docx
11-17
9. 自我提升与敬业精神：教师提到OA办公系统的使用，以及每日的微笑打卡，体现其敬业精神和自我提升的决心，为学生树立了良好的榜样。 10. 学生状态的追踪与反馈：教师与任课老师保持沟通，了解学生的学习状态变化...
2021最新手账系列-一面一题B5.pdf
05-04
10. 学习辅助：在学习时记录要点、整理复习资料，利用手账提高学习效率。 考虑到给定文件的【标签】仅标为“手账”，可以推断，文件标题“2021最新手账系列-一面一题B5.pdf”可能是指一份以日历或规划表为模板，...
每日打卡2021.10.17
TimorHasug的博客
10-18 146
多线程 线程简介 Process 和 Thread（进程和线程） 进程包含多个线程 即使自己没有创建线程，后台也会有多个线程，如主线程，GC线程（Garbage Collection） 线程是CPU调度和执行的基本单位 main（）称之为主线程，为系统的入口，用于执行整个程序 线程的运行和调度器安排调度，调度器是与os紧密相关的，先后顺序不能人为干预 模拟多线程（单核但是切换快，感觉像是同时运行） 真正的多线程（多核）
每日学习打卡-汇总处
大林程序员
04-03 3378
无，就是一个打卡而已
auto.js B0037 每日答题代码 2021-10-24
weixin_33595571的博客
10-24 387
toast("每日答题") var question = "" var Title = "" function GetQuestion(){ sleep(1000) // className("android.view.View").text("查看提示").findOne().click(); // sleep(1000) widget = className("android.view.View").find(); log(widget.length) .
考研进度记录表（2021.6-2021.11）
沉鱼叶的博客
05-30 1657
考研进度记录表
2021-10-15每日刷题打卡
AnubisL的博客
10-15 710
一、信息学oj-1356：计算(calc) (1)题目描述 小明在你的帮助下，破密了Ferrari设的密码门，正要往前走，突然又出现了一个密码门，门上有一个算式，其中只有“(”，“)”，“0-9”，“+”，“-”，“*”，“/”，“^”，求出的值就是密码。小明数学学得不好，还需你帮他的忙。(“/”用整数除法) 【输入】 共1行，为一个算式。 【输出】 共1行，就是密码。 【输入样例】 1+(3+2)*(7^2+6*9)/(2) 【输出样例】 258 ...
每日学习打卡：Java网络编程
weixin_44016361的博客
08-05 111
网络编程 概述 网络编程三要素：IP地址、端口号、协议 InetAddress类：为了方便我们对ip地址的获取和操作，Java提供了一个InetAddress类供我们使用 static InetAddress getByName(String host) 确定主机名称的ip地址，主机名称可以是机器名称或ip地址 String getHostName() 获取此ip地址的主机名 String getHostAddress() 返回文本显示中的ip地址字符串 import java.net.InetAddr
BUUCTF 每日打卡 2021-7-26
weixin_52446095的博客
07-26 436
引言 填坑 [watevrCTF 2019]Swedish RSA 加密代码如下： flag = bytearray(raw_input()) flag = list(flag) length = len(flag) bits = 16 ## Prime for Finite Field. p = random_prime(2^bits-1, False, 2^(bits-1)) file_out = open("downloads/polynomial_rsa.txt", "w") file_out.
2021-11-17每日刷题打卡
fnmdpnmsl的博客
11-17 262
2021-11-17每日刷题打卡 力扣——每日一题 318. 最大单词长度乘积 给定一个字符串数组 words，找到 length(word[i]) * length(word[j]) 的最大值，并且这两个单词不含有公共字母。你可以认为每个单词只包含小写字母。如果不存在这样的两个单词，返回 0。 示例 1: 输入: [“abcw”,“baz”,“foo”,“bar”,“xtfn”,“abcdef”] 输出: 16 解释: 这两个单词为 “abcw”, “xtfn”。 这题我用了两个方法，第一个是几分钟前还不
BUUCTF 每日打卡 2021-4-1
weixin_52446095的博客
04-01 1130
引言 四月的第一天，今天就鸽了 当然，是骗人的 周四课虽然不多，但数分高代在同一天属实难顶 传统知识+古典密码 题干如下： 小明某一天收到一封密信，信中写了几个不同的年份 辛卯，癸巳，丙戌，辛未，庚辰，癸酉，己卯，癸巳。 信的背面还写有“+甲子”，请解出这段密文。 key值：CTF{XXX} 一看是干支纪年法，一查表 得到列表：[28, 30, 23, 8, 29, 10, 16, 30] 看着应该是 ascii 码 +甲子 即每个数加60（每个数加1就没有什么意义了） 上面这部分是传统知识，题目还提到古
2021最新手账系列-12款功能页.pdf
05-04
7. 习惯打卡页：用于培养和记录个人习惯，如早睡早起、喝水、运动等，通过每日打卡来监督习惯的养成。 8. 月计划、周计划、日计划：这是手账中最常见的规划工具，帮助用户从月度、周度、日度三个不同的时间维度来...
(2021年整理)关于公司全面推行“钉钉”软件的通知.pdf
03-11
为确保审批流程的及时性，各部门负责人需每日（包括节假日）在晚上10点前检查审批信息。非工作时间发出的申请，可以使用DING功能提醒审批人。此外，各负责人需在周例会上对全体员工进行“钉钉”软件的培训和学习，...
2020-2021学年一年级中秋国庆假期指导手册.pdf
02-04
- **打卡制度**：家长需要每天在群里上传孩子完成作业的照片，记录孩子的进步。 #### 四、具体练习内容示例 - **练习一**： - 描写“1”的正确写法。 - 圈出特定数量的动物。 - 涂色练习。 - 生活语文复习：...
Java企业面试题3
m0_74972727的博客
09-15 881
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 184
Arthas sysenv（查看JVM的环境变量）
JDK17新增语法特性
2201_76124988的博客
09-20 519
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 174
faiss版本 faiss-v1.7.4。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值