【面試(自己看)】一、JUC多线程及高并发(3)之 锁

最新推荐文章于 2024-07-23 12:23:52 发布
最新推荐文章于 2024-07-23 12:23:52 发布
阅读量151 收藏
点赞数
分类专栏： 并发编程 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hardworking_boy/article/details/105037948
版权

【大厂原题】
公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解, 请手写一个自旋锁

1 公平锁和非公平锁

1.1 是什么?
公平锁 是指多个线程按照申请锁的顺序来获取锁. 类似排队打饭,先来后到.
非公平锁 是指多个线程获取锁的顺序并不是按照申请锁的顺序, 有可能后申请的线程比先申请的线程优先获取锁,在高并发的情况下, 有可能会造成优先级反转或者饥饿现象

并发包中ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁, 默认是非公平锁(即传入false);

1.2 两者区别?
公平锁: Threads acquire a fair lock in the order in which they requested it
公平锁就是很公平,在并发环境中,每个线程在获取锁时会先查看此锁维护的等待队列, 如果为空, 或者当前线程是等待队列的第一个,就占有锁, 否则就会加入到等待队列中, 以后会按照FIFO的规则从队列中取到自己

非公平锁: a nonfair lock permits barging: threads requesting a lock can jump ahead of the queue of waiting threads if the lock happens to be available when it is requested;
非公平锁比较粗鲁, 上来就直接尝试占有锁, 如果尝试失败, 就再采用类似公平锁那种方式;

1.3 题外话
Java ReentrantLock而言, 通过构造函数指定该锁是否是公平锁, 默认是非公平锁. 非公平锁的优点在于吞吐量比公平锁大
对于syncronized而言, 也是一种非公平锁;


2 可重入锁

2.1 是什么
可重入锁也叫递归锁
指的是同一线程外层函数获得锁之后, 内层递归函数仍然能获取该做的代码, 在同一个线程在外层方法获取锁的时候, 进入内层方法会自动获取锁;
也就是说:线程可以进入任何一个它已经拥有的锁的所同步着的代码块;

ReentrantLock和syncronized就是两个典型的可重入锁

2.2 作用
可重入锁最大的作用就是避免死锁

2.3 可重入锁小Demo

syncronized是可重入锁

class Phone{
    public synchronized void sendSMS() throws Exception{
        System.out.println(Thread.currentThread().getName() + "\t invoke sendSMS");
        this.sendEmail();
    }
    public synchronized void sendEmail() throws Exception{
        System.out.println(Thread.currentThread().getName() + "\t ###invoke sendEmail");
    }
}

public class ReentrantLockDemo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"t1").start();

        new Thread(()->{
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"t2").start();
    }
	/* 打印结果
	   t1	 invoke sendSMS
	   t1	 ###invoke sendEmail
       t2	 invoke sendSMS
       t2	 ###invoke sendEmail			
	*/	
}

LocK中的ReentrantLock是可重入锁

class Fruit implements Runnable{
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        this.set();
    }

    public void set(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t invoke set");
            this.get();
        }catch (Exception e){e.printStackTrace();}
        finally {
            lock.unlock();
        }
    }
    public void get(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t ###invoke get");
        }catch (Exception e){e.printStackTrace();}
        finally {
            lock.unlock();
        }
    }
}

public class ReentrantLockDemo {
    public static void main(String[] args) {
        Fruit frult = new Fruit();
        Thread t3 = new Thread(frult,"t3");
        Thread t4 = new Thread(frult,"t4");
        t3.start();
        t4.start();
    }
    /* 执行结果
		t3	 invoke set
		t3	 ###invoke get
		t4	 invoke set
		t4	 ###invoke get
	*/
}

至此我们再温习一下可重入锁的定义👇
可重入锁也叫递归锁
指的是同一线程外层函数获得锁之后, 内层递归函数仍然能获取该做的代码, 在同一个线程在外层方法获取锁的时候, 进入内层方法会自动获取锁;
也就是说: 线程可以进入任何一个它已经拥有的锁的所同步着的代码块;

ReentrantLock和syncronized就是两个典型的可重入锁

可重入锁问题延伸
阅读一下代码,请问代码执行结果

class Fruit implements Runnable{
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        this.set();
    }

    public void set(){
        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t invoke set");
            this.get();
        }catch (Exception e){e.printStackTrace();}
        finally {
            lock.unlock();
            lock.unlock();
        }
    }
    public void get(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t ###invoke get");
        }catch (Exception e){e.printStackTrace();}
        finally {
            lock.unlock();
        }
    }
}

public class ReentrantLockDemo {
    public static void main(String[] args) {
        Fruit frult = new Fruit();
        Thread t3 = new Thread(frult,"t3");
        Thread t4 = new Thread(frult,"t4");
        t3.start();
        t4.start();
    }
}

我们可以看到Fruit类的set()方法中加了两把锁,这个时候如果执行main()方法会有什么问题?

以下答案👇

编译无错
运行也无错
记住,不管加几把锁,只要对应匹配解锁几次就没有问题!!!


3 自旋锁(spinLock)

自旋锁我们在CAS中讲过一点.
AtomicInteger 作为原子类中的一个例子,被我们拿出来举例, 我们知道 **AtomicInteger的CAS**实现就是Unsafe类 + 自旋

再重温下代码👇
在这里插入图片描述

3.1 是什么

自旋锁,是指尝试获取锁的线程不会立即阻塞,而是采用循环的方式去尝试获取锁, 这样的好处是减少线程上下文切换的消耗, 缺点是循环会消耗CPU

3.2 手写一个自旋锁

自旋锁Demo

public class SpinlockDemo {
    //原子引用线程
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println("线程"+Thread.currentThread().getName()+"\t come in ^_^");
        /**
         *  这里某线程进入CAS成功之后,其它线程再进入该方法到此处CAS取反就一直是true,就会卡在这里
         *  直到atomicReference Set进去的这个线程调用myUnlock方法,将atomicReference
         *  存储的线程引用值重新改为null
         */
        while (!atomicReference.compareAndSet(null, thread)){
            //就旋着
        }
    }

    public void myUnlock() {
        Thread thread = Thread.currentThread();
        //用完了,将原子引用改回到最初的值
        atomicReference.compareAndSet(thread,null);
        System.out.println("线程"+Thread.currentThread().getName()+"\t invoke myUnlock^_^");
    }

    public static void main(String[] args) throws InterruptedException {
        SpinlockDemo spinlockDemo = new SpinlockDemo();
        //线程A 获取自旋锁, 假设业务操作耗时五秒
        new Thread(()->{
            try {
                //获取自旋锁
                spinlockDemo.myLock();
                //业务操作5秒
                System.out.println("线程"+Thread.currentThread().getName()+"\t 开始业务操作");
                TimeUnit.SECONDS.sleep(5);
                System.out.println("线程"+Thread.currentThread().getName()+"\t 业务操作完成");
                //释放锁
                spinlockDemo.myUnlock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        //我们模拟中, 希望A先获取锁,因此在这里暂停1秒,保证线程A能够启动
        TimeUnit.SECONDS.sleep(1);

        //线程B 获取自旋锁, 进行业务操作,释放锁
        new Thread(()->{
            try {
                //获取自旋锁
                spinlockDemo.myLock();
                //业务操作1秒
                System.out.println("线程"+Thread.currentThread().getName()+"\t 开始业务操作");
                TimeUnit.SECONDS.sleep(1);
                System.out.println("线程"+Thread.currentThread().getName()+"\t 业务操作完成");
                //释放锁
                spinlockDemo.myUnlock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
    }
	/**打印结果
		线程 A	 come in ^_^               进入lock
		线程 A	 开始业务操作		           说明获取到了锁
		线程 B	 come in ^_^	           进入lock但是会在while()这里一直自旋,直到线程A释放锁
		线程 A	 业务操作完成
		线程 A	 invoke myUnlock^_^		   释放锁 	
		线程 B	 开始业务操作                线程B获取到了锁  
		线程 B	 业务操作完成
		线程 B	 invoke myUnlock^_^
	*/
}

4 读/写锁

共享锁(读锁)

指该锁可被多个线程所持有.

独占锁(写锁)

指该锁一次只能被一个线程所持有. 对ReentrantLock和Syncronized而言都是独占锁.

互斥锁

读锁的共享锁可保证并发读是非常高效的, 读写, 写读, 写写 的过程是互斥的

4.1 读写锁 是什么

多个线程同时读一个资源类没有任何问题, 所以为了满足并发量, 读取共享资源应该可以同时进行
但是
如果有一个线程想去写共享资源时, 就不应该再有其它线程可以对该资源进行读或写

高并发场景下的写操作要注意两点: 原子+独占, 整个过程必须是一个完整的统一体, 中间不允许被分割, 不允许被打断;

对ReentrantReadWriteLock其读锁是共享锁, 其写锁时独占锁
对ReentrantReadWriteLock读写分离,既保证了数据的一致性,又保证了并发性

4.2 读写锁小总结

读-读 能共存
读-写 不能共存
写-写 不能共存

4.3 读写锁小Demo

我们先看一下没有加锁的时候,5个线程写,5个线程读,会出现什么错乱的情况

/**
	无锁版,并发场景的读写
*/
/**
 * 该资源类加上 清理操作就变成 手写简单缓存的demo
  */
class DataCatch{
    private volatile Map<String, Object> map = new HashMap<>();

    public void write(String key, String val) {
        System.out.println("线程 "+Thread.currentThread().getName()+"\t 开始写入:{"+key+","+val+"}");
        //暂停一会线程,模拟执行业务操作
        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        map.put(key,val);
        System.out.println("线程 "+Thread.currentThread().getName()+"\t 写入完成");
    }

    public void read(String key) {
        System.out.println("线程 "+Thread.currentThread().getName()+"\t 开始读取");
        //暂停一会线程,模拟执行业务操作
        Object o = map.get(key);
        System.out.println("线程 "+Thread.currentThread().getName()+"\t 读取完成:"+o);
    }

    //加一个cleanmap的操作,就是清除缓存
}
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        DataCatch dc = new DataCatch();
        //5个线程执行写操作
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
            dc.write(tempInt+"",tempInt+"");
            },String.valueOf(i)).start();
        }

        //5个线程执行读操作
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
                dc.read(tempInt+"");
            },String.valueOf(i)).start();
        }
    }
    /* 看一下执行结果
		线程 1	 开始写入:{1,1}
		线程 4	 开始写入:{4,4}
		线程 3	 开始写入:{3,3}
		线程 0	 开始写入:{0,0}
		线程 2	 开始写入:{2,2}
		线程 1	 开始读取
		线程 2	 开始读取
		线程 2	 读取完成:null
		线程 1	 读取完成:null
		线程 0	 开始读取
		线程 0	 读取完成:null
		线程 3	 开始读取
		线程 3	 读取完成:null
		线程 4	 开始读取
		线程 4	 读取完成:null
		线程 1	 写入完成
		线程 4	 写入完成
		线程 2	 写入完成
		线程 3	 写入完成
		线程 0	 写入完成
	*/
}

线程的写操作,并非原子性,而写没有独占,
线程的读操作,读取数据错误,原因是还没有写入完成,就开始读导致的
此时在高并发场景下就是一个很严重的bug

我们再看一下通过可重入读写锁ReentrantReadWriteLock进行优化,其结果如何

/**
 ReentrantReadWriteLock版,并发场景的读写操作
*/
/**
 * 该资源类加上 清理操作就变成 手写简单缓存的demo
  */
class DataCatch{
    private volatile Map<String, Object> map = new HashMap<>();
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    public void write(String key, String val) {
        //读写锁->读锁加锁
        rwLock.writeLock().lock();
        //暂停一会线程,模拟执行业务操作
        try {
            System.out.println("线程 "+Thread.currentThread().getName()+"\t 开始写入:{"+key+","+val+"}");
            TimeUnit.MILLISECONDS.sleep(300);
            map.put(key,val);
            System.out.println("线程 "+Thread.currentThread().getName()+"\t 写入完成");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //读写锁->读锁释放锁
            rwLock.writeLock().unlock();
        }
    }

    public void read(String key) {
        rwLock.readLock().lock();
        try {
            System.out.println("线程 "+Thread.currentThread().getName()+"\t 开始读取");
            //暂停一会线程,模拟执行业务操作
            TimeUnit.MILLISECONDS.sleep(300);
            Object o = map.get(key);
            System.out.println("线程 "+Thread.currentThread().getName()+"\t 读取完成:"+o);
        }catch (Exception e){e.printStackTrace();}
        finally {
            rwLock.readLock().unlock();
        }

    }

    //加一个cleanmap的操作,就是清除缓存
}
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        DataCatch dc = new DataCatch();
        //5个线程执行写操作
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
            dc.write(tempInt+"",tempInt+"");
            },String.valueOf(i)).start();
        }

        //5个线程执行读操作
        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
                dc.read(tempInt+"");
            },String.valueOf(i)).start();
        }
    }
	/* 执行结果
	   	线程 0	 开始写入:{0,0}
		线程 0	 写入完成
		线程 1	 开始写入:{1,1}
		线程 1	 写入完成
		线程 3	 开始写入:{3,3}
		线程 3	 写入完成
		线程 2	 开始写入:{2,2}
		线程 2	 写入完成
		线程 4	 开始写入:{4,4}
		线程 4	 写入完成
		线程 0	 开始读取
		线程 1	 开始读取
		线程 2	 开始读取
		线程 3	 开始读取
		线程 4	 开始读取
		线程 2	 读取完成:2
		线程 4	 读取完成:4
		线程 0	 读取完成:0
		线程 3	 读取完成:3
		线程 1	 读取完成:1
	*/
}

看结果就知道啦, ReentrantReadWriteLock完全将写操作变成原子性+独占的,某个线程在进行写操作的时候,其它线程不能读更不能写
而对读操作并没有做独占限制



以上,就是我们多线程场景下锁相关的要点知识的梳理

turnsole_taurus
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
阿里面试失败后，一气之下我图解了Java中18把锁
华科硕士，大厂打工中。编程问题咨询，请私我
06-17 41万+
目录 乐观锁和悲观锁 独占锁和共享锁 互斥锁和读写锁 公平锁和非公平锁 可重入锁 自旋锁 分段锁 锁升级（无锁|偏向锁|轻量级锁|重量级锁） 锁优化技术（锁粗化、锁消除） 乐观锁和悲观锁 悲观锁 悲观锁对应于生活中悲观的人，悲观的人总是想着事情往坏的方向发展。 举个生活中的例子，假设厕所只有一个坑位了，悲观锁上厕所会第一时间把门反锁上，这样其他人上厕所只能在门外等候，这种状态就是「阻塞」了。 回到代码世界中，一个共享数据加了悲观锁，那线程每次想操作这个数据前都会假设其他线程.
JUC 多线程及高并发笔记
Spring MVC入门程序
04-07 1360
JUC 多线程及高并发 准备找工作的大四狗一枚，最近在学习多线程和高并发，总结了一些多线程高并发的高频知识点。个人认为从源码层面去理解比背题更加高效。笔记来自于听课后，根据理解自己整理。分享给有需要的人，大家共同学习，共进大厂。如有错误欢迎批评指正。抱拳了老铁
【Java面试题汇总】多线程、JUC、锁篇（2023版）
vincewm的博客
03-11 7263
线程和进程的区别、CAS的ABA问题、AQS、哪些地方使用了CAS、怎么保证线程安全、线程同步方式、synchronized的用法及原理、Lock、volatile、线程的六个状态、ThreadLocal、线程通信方式、创建方式、两种创建线程池的方法、线程池设置合适的线程数、线程安全的集合？ConcurrentHashMap、JUC
大厂高频面试题复习JAVA学习笔记-JUC多线程及高并发（上）
qq_51586702的博客
04-03 740
0 JUC基础概念 1 请谈谈你对volatile的理解 JMM（java内存模型） 2 CAS你知道吗? 3 原子类AtomicInteger的ABA问题谈谈?原子更新引用知道吗? 4 我们知道ArrayList是线程不安全，请编码写一个不安全的案例并给出解决方案。 5 公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解?请手写一个自旋锁 6 CountDownLatch/cyclicBarrier/semaphore使用过吗? 7 阻塞队列知道吗? 8 线程池用过吗?9 线程10 死锁编码及定位分析
Java并发指南18：JUC常见面试题及答案
Java技术江湖
05-06 2091
什么是 CAS 吗？ CAS（Compare And Swap）指比较并交换。CAS算法CAS(V, E, N)包含 3 个参数，V 表示要更新的变量，E 表示预期的值，N 表示新值。在且仅在 V 值等于 E值时，才会将 V 值设为 N，如果 V 值和 E 值不同，则说明已经有其他线程做了更新，当前线程什么都不做。最后，CAS 返回当前 V 的真实值。Concurrent包下所有类底层都是依靠CAS操作来实现，而sun.misc.Unsafe为我们提供了一系列的CAS操作。 CAS 有什么缺点？ AB
JUC多线程常见面试题汇总
sxn0121的博客
07-23 1067
如果工作队列满了，则判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。在上锁的过程中，如果有其他线程也来抢锁，则进入EntryList 进行阻塞，当获得锁的线程执行完了，释放了锁，就会唤醒EntryList 中等待的线程竞争锁，竞争的时候是非公平的。偏向锁：一段很长的时间内都只被一个线程使用锁，可以使用了偏向锁，在第一次获得锁时，会有一个CAS操作，之后该线程再获取锁，只需要判断mark word中是否是自己的线程id就可以，一旦锁发生了竞争，都会升级为重量级锁。
JUC多线程及高并发面试题
08-23 690
JUC多线程及高并发 [TOC] 一、请你谈谈对volatile的理解 ​ Package java.util.concurrent---> AtomicInteger Lock ReadWriteLock 1、volatile是java虚拟机提供的轻量级的同步机制 保证可见性、不保证...
多线程JUC并发篇常见面试详解
m0_49303490的博客
04-15 874
文章目录@[TOC](文章目录)**1、JUC 简介****2、线程和进程**3、并非与并行4、**线程的状态****5、wait/sleep的区别**6、**Lock 锁（重点）****1、Lock锁**2、公平非公平：**3、ReentrantLock 构造器**4、Lock 锁实现步骤：**7、synchronized 和 lock 锁的区别****8、生产者和消费者问题（通信问题）****1、Synchronized 版本****2、JUC 版本****9、八个有关锁的问题****关于锁的八个问题*
java多线程与死锁_JUC多线程与高并发面试题——死锁编码及定位分析
weixin_34639033的博客
02-16 126
一、什么是死锁死锁指的是，两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象。若无外力干涉，那它们都将无法继续推进下去，如果系统资源充足，进程的资源请求都能得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。 二、死锁Demopackage com.yuxx.juc;import java.util.concurrent.TimeUnit;class Hold...
JUC多线程及高并发包 （第2季）
紫蝶侠的博客
08-16 895
课程连接 百度
Java 多线程与并发(12-26)-JUC锁- ReentrantReadWriteLock详解.pdf
07-26
在Java多线程并发编程中，ReentrantReadWriteLock（可重入读写锁）是一个重要的同步工具，它属于Java并发包（java.util.concurrent.locks）中的一个类。这个锁提供了比标准的synchronized关键字更细粒度的控制，允许...
阿里内部高并发核心编程笔记：多线程、锁、JMM、JUC、设计模式
CXY_QIQI的博客
06-05 211
java学习 成长思维导图：骆驼祥子思维导图 - GitMind前两天看到一个大佬写的博客，提到高阶开发者必须掌握的技能，其中他明确提出了“精通多线程性能调优”。为什么多线程对开发人员如此重要？第一，不管你去面试哪家公司，java多线程是必问项，而且多线程使用范围广，无论如何是避不开的；第二，你对多线程掌握的越深入，意味着你能做的事情越多。从这张多线程的导图中我们可以看出：想要彻底搞懂多线程是需要掌握很多技术点的。我在面试的时候也经常看到一些朋友写“精通多线程性能调优”，但大多数人对精通存在一定误区。由于业
高并发JUC详解
weixin_48958124的博客
08-26 2076
多线程进阶之高并发编程
2进制3位数过去现在将来输赢公式代码.txt
09-07
2进制3位数过去现在将来输赢公式代码
福州大学在广东2021-2024各专业最低录取分数及位次表.pdf
最新发布
09-07
全国各大学在广东2021-2024各专业最低录取分数及位次表
WordPress 集网址、资源、资讯于一体的导航类主题开心版
09-07
WordPress 集网址、资源、资讯于一体的导航类主题开心版； 运行环境 PHP7.4 + MYSQL5.6
【Java学习】activemq消息中间件学习demo.zip
09-07
【Java学习】activemq消息中间件学习demo.zip 【Java学习】activemq消息中间件学习demo.zip 【Java学习】activemq消息中间件学习demo.zip
爬取淘宝热销(热门)手机支架商品信息公开透明的数据集
09-07
本资源专注于收集淘宝热销(热门)手机支架商品信息，内容涵盖商品的店铺所在省份、城市位置、商品的名称、销售价格、累积销量、单价（以人民币计价）、付款的顾客人数、是否提供包邮服务、是否为天猫平台的商品，以及相关的满减优惠情况。这些详细的数据点均来源于淘宝平台的公开透明信息，经过精确抓取和整理，旨在为分析电商平台上的新品推荐策略和消费者购买行为提供实用数据。 这些数据严格遵循淘宝平台的公开政策和隐私保护原则获取，确保了信息的合法性与合规性。然而，本资源仅作为学习参考之用，意在帮助研究人员、市场分析师或学生等理解电商领域的商品推荐机制、销售动态及市场趋势。 任何将此数据用于商业目的或其他未授权的活动都是不恰当的，甚至可能触犯相关法律条款。 在使用这些数据进行学术研究或个人学习时，用户应自觉遵守相关法律法规，尊重数据来源和版权，正确引用数据源，并不得用于任何形式的商业盈利。 注意：这是一份数据集
【目标检测数据集】斧子数据集2396张VOC+YOLO格式（含增强60%）.zip
09-07
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件) 图片数量(jpg文件个数)：2396 标注数量(xml文件个数)：2396 标注数量(txt文件个数)：2396 标注类别数：1 标注类别名称:["futou"] 每个类别标注的框数： futou 框数 = 2484 总框数：2484 使用标注工具：labelImg
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值