【尚硅谷周阳--JUC并发编程】【第十四章--ReentrantLock、ReentrantReadWriteLock、StampedLock讲解】

【尚硅谷周阳--JUC并发编程】【第十四章--ReentrantLock、ReentrantReadWriteLock、StampedLock讲解】

  • 一、面试题
  • 二、简单聊聊ReentrantReadWriteLock
    • 1、是什么?
      • 1.1、读写锁说明
      • 1.2、演变
      • 1.3、读写锁意义和特点
    • 2、特点
      • 2.1、优点
      • 2.2、code演示
      • 2.3、结论
      • 2.4、从写锁->读锁，ReentrantReadWriteLock锁降级
        • 2.4.1、《Java并发编程的艺术》中关于锁降级的说明
        • 2.4.2、读写锁降级演示
        • 2.4.3、写锁和读锁是互斥的
      • 2.5、读写锁之读写规矩，为什么要锁降级？
  • 三、StampedLock
    • 1、是什么？
    • 2、锁饥饿问题
      • 2.1、什么是锁饥饿问题？
      • 2.2、如何解决饥饿问题？
      • 2.3、StampedLock乐观读锁
    • 3、StampedLock的特点
    • 4、乐观读模式案例
      • 4.1、StampedLock可用作读写锁
      • 4.2、StampedLock支持读的过程中允许写锁的介入
    • 5、StampedLock的缺点

一、面试题

  1. 你知道Java里面有那些锁？
  2. 你说你用过读写锁，锁饥饿问题是什么？
  3. 有没有比读写锁更快的锁？
  4. StampedLock知道吗(邮戳锁/票据锁)
  5. ReentrantReadWriteLock有锁降级机制，你知道吗？

二、简单聊聊ReentrantReadWriteLock

1、是什么?

1.1、读写锁说明

  1. ReentrantReadWriteLock读写锁定义为：一个资源能够被读个线程访问，或者被一个写线程访问，但是不能同时存在读写线程。
  2. 一体两面，读写互斥，读读共享(写的时候不可以读，读的时候不能写)

1.2、演变

  • 无锁无序->加锁->读写锁演变复习
    • 无锁：资源访问不安全
    • ReentrantLock：串行锁，不管是读还是写，每次都是一个线程
    • ReadWriteLock(实现类：ReentrantReadWriteLock)：读写互斥，读读可以共享，多线程并发可以访问，大面积可以容许多个线程来读取。适用于读多写少的情况，但是容易造成写锁饥饿问题。需要注意锁降级。

1.3、读写锁意义和特点

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

2、特点

2.1、优点

  1. 可重入
  2. 读写兼顾

2.2、code演示

  • 使用ReentrantLock一次只有一个线程执行
class MyResource {// 资源类，模拟一个简单的缓存Map<String, String> map = new HashMap<>();// =========ReentrantLock 等价于 ======synchronizedReentrantLock lock = new ReentrantLock();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) {throw new RuntimeException(e);}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);// 暂停几秒try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() + "\t" + "完成读取" + "\t" + result);} finally {lock.unlock();}}
}public class ReentrantReadWriteLockDemo {public static void main(String[] args) {MyResource myResource = new MyResource();for (int i = 0; i < 10; i++) {int finalI = i;new Thread(() -> {myResource.write(finalI + "", finalI + "");}, String.valueOf(i)).start();}for (int i = 0; i < 10; i++) {int finalI = i;new Thread(() -> {myResource.read(finalI + "");}, String.valueOf(i)).start();}}}

串行执行，每次只有一个线程操作

  • 使用读写锁ReentrantReadWriteLock
class MyResource {// 资源类，模拟一个简单的缓存Map<String, String> map = new HashMap<>();// =========ReentrantReadWriteLock一体两面，读写互斥，读读共享ReadWriteLock rwLock = new ReentrantReadWriteLock();public void write(String key, String value) {rwLock.writeLock().lock();try {System.out.println(Thread.currentThread().getName() + "\t" + "正在写入");map.put(key, value);// 暂停几秒try {TimeUnit.MILLISECONDS.sleep(500);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() + "\t" + "完成写入");} finally {rwLock.writeLock().unlock();}}public void read(String key) {rwLock.readLock().lock();try {System.out.println(Thread.currentThread().getName() + "\t" + "正在读取");String result = map.get(key);// 暂停几秒try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() + "\t" + "完成读取" + "\t" + result);} finally {1rwLock.readLock().unlock();}}
}public class ReentrantReadWriteLockDemo {public static void main(String[] args) {MyResource myResource = new MyResource();for (int i = 0; i < 10; i++) {int finalI = i;new Thread(() -> {myResource.write(finalI + "", finalI + "");}, String.valueOf(i)).start();}for (int i = 0; i < 10; i++) {int finalI = i;new Thread(() -> {myResource.read(finalI + "");}, String.valueOf(i)).start();}}}

结果

  • 读未完成时，写无法获得锁
class MyResource {// 资源类，模拟一个简单的缓存Map<String, String> map = new HashMap<>();// =========ReentrantLock 等价于 ======synchronizedReentrantLock lock = new ReentrantLock();// =========ReentrantReadWriteLock一体两面，读写互斥，读读共享ReadWriteLock rwLock = new ReentrantReadWriteLock();public void write(String key, String value) {rwLock.writeLock().lock();try {System.out.println(Thread.currentThread().getName() + "\t" + "正在写入");map.put(key, value);// 暂停几秒try {TimeUnit.MILLISECONDS.sleep(500);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() + "\t" + "完成写入");} finally {rwLock.writeLock().unlock();}}public void read(String key) {rwLock.readLock().lock();try {System.out.println(Thread.currentThread().getName() + "\t" + "正在读取");String result = map.get(key);// 暂停几秒try {TimeUnit.MILLISECONDS.sleep(2000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() + "\t" + "完成读取" + "\t" + result);} finally {rwLock.readLock().unlock();}}
}public class ReentrantReadWriteLockDemo {public static void main(String[] args) {MyResource myResource = new MyResource();for (int i = 0; i < 10; i++) {int finalI = i;new Thread(() -> {myResource.write(finalI + "", finalI + "");}, String.valueOf(i)).start();}for (int i = 0; i < 10; i++) {int finalI = i;new Thread(() -> {myResource.read(finalI + "");}, String.valueOf(i)).start();}for (int i = 0; i < 3; i++) {int finalI = i;new Thread(() -> {myResource.write(finalI + "", finalI + "");}, "新写锁" + String.valueOf(i)).start();}}}

结果

2.3、结论

  • 一体两面，读写互斥，读读共享，读没有完成时候其他线程写锁无法获得

2.4、从写锁->读锁，ReentrantReadWriteLock锁降级

2.4.1、《Java并发编程的艺术》中关于锁降级的说明

说明

2.4.2、读写锁降级演示
  1. 可以降级
    锁降级是为了让当前线程感知到数据的变化，目的是保证数据可见性
    写锁降级
  2. 案例
  • 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁
/*** 锁降级：遵循获取写锁->在获取读锁->再释放写锁的次序，写锁能够降级成为读锁。** 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁** 读没有完成时候写锁无法获得锁，必须要等着读锁读完之后才有机会** @author 匍匐丶前进* @since 2024/3/29 16:56**/
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();System.out.println("------写入完成");readLock.unlock();System.out.println("------读取完成");}
}

结果

  • 读没有完成时候写锁无法获得锁，必须要等着读锁读完之后才有机会，读锁无法升级为写锁
/*** 锁降级：遵循获取写锁->在获取读锁->再释放写锁的次序，写锁能够降级成为读锁。** 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁** 读没有完成时候写锁无法获得锁，必须要等着读锁读完之后才有机会** @author 匍匐丶前进* @since 2024/3/29 16:56**/
public class LockDownGradingDemo {public static void main(String[] args) {ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();// 同一个线程readLock.lock();System.out.println("------读取");writeLock.lock();System.out.println("------写入");writeLock.unlock();System.out.println("------写入完成");readLock.unlock();System.out.println("------读取完成");}
}

结构

  1. 不可以升级
    读锁不能升级为写锁
2.4.3、写锁和读锁是互斥的

读写锁互斥
StampedLock

2.5、读写锁之读写规矩，为什么要锁降级？

  1. Oracle公司ReentrantReadWriteLock源码总结
    锁降级 下面的示例代码摘自ReentrantReadWriteLock源码中：
    ReentrantReadWriteLock支持锁降级，遵循按照获取写锁，获取读锁再释放写锁的次序，写锁能够降级为读锁，不支持锁升级
class CachedData {// 数据Object data;// 默认falsevolatile boolean cacheValid;final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();void processCachedData() {rwl.readLock().lock();// 查看缓存是否有数据if (!cacheValid) {// 在写锁之前必须要先释放读锁rwl.readLock().unlock();rwl.writeLock().lock();try {// 重新校验状态，因为其他写线程可能在这之前修改了状态(类似双端检索)if (!cacheValid) {// 写操作data = ...cacheValid = true;}// 锁降级-->在释放写锁之前占用读锁(理解为当前线程写完之后，需要获取当前最新data进行后续操作，不希望别其他线程在修改data)rwl.readLock().lock();} finally {// 释放写锁，继续持有读锁rwl.writeLock().unlock();}}try {// 完成读后操作use(data);} finally {// 释放读锁rwl.readLock().unlock();}}
}
  • 代码中声明了一个Volatile类型的cacheValid变量，保证其可见性。
  • 首先获取读锁，如果cache不可用，则释放读锁。获取写锁，在更改数据之前，再检查一次cacheValid的值，然后修改数据，将cacheValid置为true，然后在释放写锁前立刻抢夺获取读锁；此时，cache中数据可用，处理cache中数据，最后释放读锁。这个过程就是一个完整的锁降级的过程，目的是保证数据可见性。
  • 总结：一句话，同一个线程自己持有写锁时再去拿读锁，其本质相当于重入
  • 如果未被锁降级的步骤，即如果当前的线程C在修改完cache中的数据后，没有获取读锁而是直接释放了写锁，那么假设此时另一个线程D获取了写锁并修改了数据，那么C线程无法感知到数据已被修改，则数据出现错误。

三、StampedLock

  • 面试题：有没有比读写锁更快地锁？

1、是什么？

  1. StampedLock是JDK1.8中新增的一个读写锁，也是对JDK1.5中的读写锁ReentrantReadWriteLock的优化
  2. 邮戳锁又叫票据锁
  3. stamp(邮戳，long类型)
    代表了锁的状态。当stamp返回零时，表示线程获取锁失败。并且，当释放锁或者转换锁的时候，都要传入最初获取的stamp值

2、锁饥饿问题

2.1、什么是锁饥饿问题？

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

2.2、如何解决饥饿问题？

  • 使用“公平”策略可以一定程度上缓解这个问题
ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
  • 但是“公平”策略是以牺牲系统吞吐量为代价的。

2.3、StampedLock乐观读锁

  1. ReentrantReadWriteLock,允许多个线程同时读，但是只允许一个线程写，在线程获取到写锁的时候，其他写操作和读操作都会处于阻塞状态。读锁和写锁也是互斥的，所以在读的时候是不允许写的。读写锁比传统的synchronized速度要快很多，原因就是在于ReentrantReadWriteLock支持并发读，读读可以共享。
  2. ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。但是，StampedLock采用乐观锁获取锁后，其他线程尝试获取写锁时不会被阻塞，这其实是对读锁的优化，所以，在获取乐观锁后，还需要对结果进行校验。
  3. 一句话：对短的只读代码段，使用乐观模式通常可以减少争用并提高吞吐量。

3、StampedLock的特点

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

4、乐观读模式案例

  • 读的过程中也允许获取写锁介入

4.1、StampedLock可用作读写锁

public class StampedLockDemo {// StampedLock = ReentrantReadWriteLock + 读的过程中允许写锁的介入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;} 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 code lock,4 seconds continue...");for (int i = 0; i < 4; i++) {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() + "\t" + "正在读取中......");}try {int result = number;System.out.println(Thread.currentThread().getName() + "\t" + "获得成员变量值result：" + result);System.out.println("写线程没有修改成功，读锁时候写锁无法介入，传统的读写互斥");} finally {stampedLock.unlockRead(stamp);}}public static void main(String[] args) {StampedLockDemo resource = new StampedLockDemo();new Thread(() -> {resource.read();}, "readThread").start();// 暂停几秒try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}new Thread(() -> {System.out.println(Thread.currentThread().getName() + "\t" + "------come in");resource.write();}, "writeThread").start();try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() + "\t" + "number:" + number);}
}

结果

4.2、StampedLock支持读的过程中允许写锁的介入

public class StampedLockDemo {// StampedLock = ReentrantReadWriteLock + 读的过程中允许写锁的介入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;} finally {stampedLock.unlockWrite(stamp);}System.out.println(Thread.currentThread().getName() + "\t" + "写线程结束修改");}// 乐观读，读的过程中允许获取写锁介入public void tryOptimisticRead() {long stamp = stampedLock.tryOptimisticRead();int result = number;// 故意间隔四秒，很乐观认为读取中没有其他线程修改过number的值System.out.println("4秒前stampedLock.validate(stamp)方法值(true无修改，false有修改)" + "\t" + stampedLock.validate(stamp));for (int i = 0; i < 4; i++) {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() + "\t" + "正在读取......" + i+ "秒后stampedLock.validate(stamp)方法值(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);} finally {stampedLock.unlockRead(stamp);}}System.out.println(Thread.currentThread().getName() + "\t" + "finally vlaue" + result);}public static void main(String[] args) {StampedLockDemo resource = new StampedLockDemo();new Thread(() -> {resource.tryOptimisticRead();}, "readThread").start();try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {throw new RuntimeException(e);}new Thread(() -> {System.out.println(Thread.currentThread().getName() + "\t" + "------come in");resource.write();}, "writeLock").start();}
}

结果

5、StampedLock的缺点

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

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

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

相关文章

安装 kubesphere 插件报错Error: UPGRADE FAILED: \“ks-minio\“ has no deployed releases

安装 kubesphere 插件报错Error: UPGRADE FAILED: \“ks-minio\“ has no deployed releases

安装 kubesphere 插件报错Error: UPGRADE FAILED: “ks-minio” has no deployed releases TASK [common : Kubesphere | Creating manifests] ******************************** ok: [localhost] > (item{uname: ucustom-values-minio, ufile: ucustom-values-minio.yaml}…
阅读更多...
什么是nginx正向代理和反向代理？

什么是nginx正向代理和反向代理？

什么是代理&#xff1f; 代理(Proxy), 简单理解就是自己做不了的事情或实现不了的功能&#xff0c;委托别人去做。 什么是正向代理&#xff1f; 在nginx中&#xff0c;正向代理指委托者是客户端&#xff0c;即被代理的对象是客户端 在这幅图中&#xff0c;由于左边内网中…
阅读更多...
第十四届蓝桥杯（八题C++ 题目+代码+注解）

第十四届蓝桥杯（八题C++ 题目+代码+注解）

目录 题目一&#xff08;日期统计 纯暴力&#xff09;&#xff1a; 代码&#xff1a; 题目二&#xff08;01串的熵 模拟&#xff09;&#xff1a; 代码&#xff1a; 题目三&#xff08;治炼金属&#xff09;&#xff1a; 代码&#xff1a; 题目四&#xff08;飞机降落 深度…
阅读更多...
32-2 APP渗透 - 移动APP架构

32-2 APP渗透 - 移动APP架构

前言 app渗透和web渗透最大的区别就是抓包不一样 一、客户端： 反编译： 静态分析的基础手段，将可执行文件转换回高级编程语言源代码的过程。可用于了解应用的内部实现细节，进行漏洞挖掘和算法分析等。调试： 排查软件错误的一种手段，用于分析应用内部原理和行为。篡改/重打…
阅读更多...
机器学习理论知识补充

机器学习理论知识补充

文章目录 1、什么是线性回归1.1、损失函数 2、什么是逻辑回归2.2、损失函数 案例来源 1、什么是线性回归 用一个例子来解释什么是线性回归比较容易理解 假设你想在商场开一家店&#xff0c;想提前预测一下开这家店会不会赚钱&#xff0c;就需要计算成本和收入&#xff0c;成本…
阅读更多...
【2024系统架构设计】案例分析- 2 系统开发基础

【2024系统架构设计】案例分析- 2 系统开发基础

目录 一 基础知识 二 真题 一 基础知识 1 结构化的需求分析 结构化特点：自顶向下，逐步分解，面向数据。 三大模型：
阅读更多...
java将文件转成流文件返回给前端

java将文件转成流文件返回给前端

环境&#xff1a;jdk1.8&#xff0c;springboot2.5.3,项目端口号&#xff1a;9100 1.待转换的文件 一、路径 二、文件内容 2.controller中代码 package com.example.pdf.controller;import com.example.pdf.service.GetFileStreamService; import org.springframework.web.b…
阅读更多...
webpack练习之手写loader

webpack练习之手写loader

手写一个style-loader来把样式文件插入head里面&#xff0c;准备工作 vue webpack就自己弄了&#xff0c;webpack的一些配置也自己配置好 一、创建index.css文件 .box{width: 100px;height: 100px;background-color: red; }然后在vue的main.js文件中引入它 二、创建自定义l…
阅读更多...
Windows下载使用nc(netcat)命令

Windows下载使用nc(netcat)命令

‘nc’ 不是内部或外部命令&#xff0c;也不是可运行的程序&#xff1f; 点击链接地址&#xff0c;下载压缩包。 完成后解压 使用方式&#xff08;三种&#xff09;&#xff1a; 1、直接双击exe使用 2、把这个exe放到cmd启动的默认路径下 放到默认路径下&#xff0c;使用nc&a…
阅读更多...
时间滑动窗口限流

时间滑动窗口限流

限流算法——时间滑动窗口 背景&#xff1a; 在当今的微服务架构中&#xff0c;会存在流量剧增的情况&#xff0c;需要适当的限流才能保证我们服务不会被打崩&#xff0c;因此一些限流组件就随之诞生&#xff0c;主流的接口限流组件&#xff0c;如 spring cloud alibaba sent…
阅读更多...
图的基础和图的遍历（--蓝桥云）

图的基础和图的遍历（--蓝桥云）

图的基础概念 度数&#xff1a;出边入边的条数 有向边&#xff1a;有箭头 图的存储方式 //邻接表 List<int []> list[N] list<x>//存放x的所有出点的信息 list[i][j]{first,second}//其中first表示从i出发的某个出点的编号&#xff08;这个出点是i的第j个出点&…
阅读更多...
记录一个写自定义Flume拦截器遇到的错误

记录一个写自定义Flume拦截器遇到的错误

先说结论&#xff1a; 【结论1】配置文件中包名要写正确 vim flume1.conf ... a1.sources.r1.interceptors.i1.type com.atguigu.flume.interceptor.MyInterceptor2$MyBuilder ... 标红的是包名&#xff0c;表黄的是类名&#xff0c;标蓝的是自己加的内部类名。这三个都…
阅读更多...
百度蜘蛛池平台在线发外链-原理以及搭建教程

百度蜘蛛池平台在线发外链-原理以及搭建教程

蜘蛛池平台是一款非常实用的SEO优化工具&#xff0c;它可以帮助网站管理员提高网站的排名和流量。百度蜘蛛池原理是基于百度搜索引擎的搜索算法&#xff0c;通过对网页的内容、结构、链接等方面进行分析和评估&#xff0c;从而判断网页的质量和重要性&#xff0c;从而对网页进行…
阅读更多...
前端学习--品优购项目

前端学习--品优购项目

文章目录 前端学习--品优购项目1.案例铺垫文件建立与命名必备文件网站favicon图标网站TDK三大标签SEO优化常用命名 2.LOGO SEO优化3.实际代码4.申请免费域名 前端学习–品优购项目 1.案例铺垫 文件建立与命名 一个项目中为了方便实用和查找内容会有多个文件夹&#xff0c;比如…
阅读更多...
windows10搭建reactnative，运行android全过程

windows10搭建reactnative，运行android全过程

环境描述 win10,react-native-cli是0.73&#xff0c;nodeJS是20&#xff0c;jdk17。这都是完全根据官网文档配置的。react-native环境搭建windows。当然官网文档会更新&#xff0c;得完全按照配置来安装&#xff0c;避免遇到环境不兼容情况。 安装nodeJS并配置 这里文档有详…
阅读更多...
如何制作Word模板并用Java导出自定义的内容

如何制作Word模板并用Java导出自定义的内容

1前言 在做项目时会按照指定模板导出word文档，本文讲解分析需求后，制作word模板、修改模板内容，最终通过Java代码实现按照模板自定义内容的导出。 2制作word模板 2.1 新建word文档 新建word文档，根据需求进行编写模板内容，调整行间距和段落格式后将指定替换位置留空。…
阅读更多...
文件操作（随机读写篇）

文件操作（随机读写篇）

1. 铺垫 建议先看&#xff1a; 文件操作&#xff08;基础知识篇&#xff09;-CSDN博客 文件操作&#xff08;顺序读写篇&#xff09;-CSDN博客 首先要指出的是&#xff0c;本篇文章中的“文件指针”并不是指FILE*类型的指针&#xff0c;而是类似于打字时的光标的东西。 打…
阅读更多...
竞赛 python+深度学习+opencv实现植物识别算法系统

竞赛 python+深度学习+opencv实现植物识别算法系统

0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 基于深度学习的植物识别算法研究与实现 &#x1f947;学长这里给一个题目综合评分(每项满分5分) 难度系数&#xff1a;4分工作量&#xff1a;4分创新点&#xff1a;4分 &#x1f9ff; 更多…
阅读更多...
154 Linux C++ 通讯架构实战9 ，信号功能添加，信号使用sa_sigaction 回调，子进程添加，文件IO详谈，守护进程添加

154 Linux C++ 通讯架构实战9 ，信号功能添加，信号使用sa_sigaction 回调，子进程添加，文件IO详谈，守护进程添加

初始化信号 使用neg_init_signals(); 在nginx.cxx中的位置如下 //(3)一些必须事先准备好的资源&#xff0c;先初始化ngx_log_init(); //日志初始化(创建/打开日志文件)&#xff0c;这个需要配置项&#xff0c;所以必须放配置文件载入的后边&#xff1b;//(4)一些初…
阅读更多...
Web应用安全攻防战：识别十大威胁，掌握防护要点

Web应用安全攻防战：识别十大威胁，掌握防护要点

OWASP&#xff08;Open Worldwide Application Security Project&#xff09;是一家致力于应用安全威胁研究的非盈利机构。通过对超过20万个组织进行调研分析&#xff0c;该机构每三年左右就会发布一次《Web应用安全风险Top10》报告&#xff0c;这个报告已经成为全球企业开展We…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023