一文搞懂“ReentrantReadWriteLock——读写锁”

文章目录

  • 初识读写锁
  • ReentrantReadWriteLock类结构
    • 注意事项
  • ReentrantReadWriteLock源码分析
    • 读写状态的设计
    • HoldCounter 计数器
    • 读锁的获取
    • 读锁的释放
    • 写锁的获取
    • 写锁的释放
  • 锁降级

初识读写锁

Java中的锁——ReentrantLock和synchronized都是排它锁，意味着这些锁在同一时刻只允许一个线程进行访问，而读写锁在同一时刻可以允许多个读线程访问，在写线程访问的时候其他的读线程和写线程都会被阻塞。读写锁维护一对锁(读锁和写锁)，通过锁的分离，使得并发性提高。

关于读写锁的基本使用：在不使用读写锁的时候，一般情况下我们需要使用synchronized搭配等待通知机制完成并发控制(写操作开始的时候，所有晚于写操作的读操作都会进入等待状态)，只有写操作完成并通知后才会将等待的线程唤醒继续执行。

如果改用读写锁实现，只需要在读操作的时候获取读锁，写操作的时候获取写锁。当写锁被获取到的时候，后续操作(读写)都会被阻塞，只有在写锁释放之后才会执行后续操作。并发包中对ReadWriteLock接口的实现类是ReentrantReadWriteLock，这个实现类具有下面三个特点。

  • 具有与ReentrantLock类似的公平锁和非公平锁的实现：默认的支持非公平锁，对于二者而言，非公平锁的吞吐量优于公平锁；

  • 支持重入：读线程获取读锁之后能够再次获取读锁，写线程获取写锁之后能再次获取写锁，也可以获取读锁；

  • 锁能降级：遵循获取写锁、获取读锁再释放写锁的顺序，即写锁能够降级为读锁。

ReentrantReadWriteLock类结构

ReentrantReadWriteLock是可重入的读写锁实现类。在它内部，维护了一对相关的锁，一个用于读操作，另一个用于写操作。只要没有 写线程，读锁可以由多个 读线程 同时持有。也就是说，写锁是独占的，读锁是共享的。

// 读锁
private final ReentrantReadWriteLock.ReadLock readerLock;
// 写锁
private final ReentrantReadWriteLock.WriteLock writerLock;
// 公平锁或非公平锁
final Sync sync;

注意事项

  1. 读锁不支持条件变量
  2. 重入时升级不支持：持有读锁的情况下去获取写锁，会导致获取永久等待
  3. 重入时支持降级： 持有写锁的情况下可以去获取读锁

ReentrantReadWriteLock源码分析

读写状态的设计

设计的精髓：用一个变量如何维护多种状态

在 ReentrantLock 中，使用 AQS 中Node结点 int 类型的 state 来表示同步状态，表示锁被一个线程重复获取的次数。

但是，读写锁 ReentrantReadWriteLock 内部维护着一对读写锁，如果要用一个变量维护多种状态，需要采用 “按位切割使用” 的方式来维护这个变量，将其切分为两部分：高16位表示读，低16位表示写。

当state值不等于0的时候，如果写状态(state & 0x0000FFFF)等于0的话，读状态是大于0的，表示读锁被获取；如果写状态不等于0的话，读锁没有被获取。这个特点也在源码中实现。
在这里插入图片描述

exclusiveCount(int c) 方法，获得持有写状态的锁的次数。
sharedCount(int c) 方法，获得持有读状态的锁的线程数量。

static final int SHARED_SHIFT   = 16;
static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;/** 返回读锁数量 */
static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
/** 返回写锁数量  */
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

不同于写锁，读锁可以同时被多个线程持有。而每个线程持有的读锁支持重入的特性，所以需要对每个线程持有的读锁的数量单独计数，这就需要用到 HoldCounter 计数器

HoldCounter 计数器

  1. 读锁的内在机制其实就是一个共享锁。
  2. 一次共享锁的操作就相当于对HoldCounter 计数器的操作。
  3. 获取共享锁，则该计数器 + 1，释放共享锁，该计数器 - 1。
  4. 只有当线程获取共享锁后才能对共享锁进行释放、重入操作。

读锁的获取

实现共享式同步组件的同步语义需要通过重写AQS的tryAcquireShared方法和tryReleaseShared方法。

// 读锁加锁操作
public final void acquireShared(int arg) {// tryAcquireShared，尝试获取锁资源，获取到返回1，没获取到返回-1if (tryAcquireShared(arg) < 0)// doAcquireShared 前面没拿到锁，这边需要排队~doAcquireShared(arg);
}// tryAcquireShared方法
protected final int tryAcquireShared(int unused) {// 获取当前线程Thread current = Thread.currentThread();// 拿到stateint c = getState();// 拿写锁标识，如果 !=0，代表有写锁if (exclusiveCount(c) != 0 &&// 如果持有写锁的不是当前线程，排队去！getExclusiveOwnerThread() != current)// 排队！return -1;// 没有写锁！// 获取读锁信息int r = sharedCount(c);// 公平锁： 有人排队，返回true，直接拜拜，没人排队，返回false// 非公平锁：正常的逻辑是非公平直接抢，因为是读锁，每次抢占只要CAS成功，必然成功// 这就会出现问题，写操作无法在读锁的情况抢占资源，导致写线程饥饿，一致阻塞…………// 非公平锁会查看next是否是写锁的，如果是，返回true，如果不是返回falseif (!readerShouldBlock() &&// 查看读锁是否已经达到了最大限制r < MAX_COUNT &&// 以CAS的方式，对state的高16位+1compareAndSetState(c, c + SHARED_UNIT)) {// 拿到锁资源成功！！！if (r == 0) {// 第一个拿到锁资源的线程，用first存储firstReader = current;firstReaderHoldCount = 1;} else if (firstReader == current) {// 我是锁重入，我就是第一个拿到读锁的线程，直接对firstReaderHoldCount++记录重入的次数firstReaderHoldCount++;} else {// 不是第一个拿到锁资源的// 先拿到cachedHoldCounter，最后一个线程的重入次数HoldCounter rh = cachedHoldCounter;// rh == null： 我是第二个拿到读锁的！// 或者发现之前有最后一个来的，但不是我，将我设置为最后一个。if (rh == null || rh.tid != getThreadId(current))// 获取自己的重入次数，并赋值给cachedHoldCountercachedHoldCounter = rh = readHolds.get();// 之前拿过，现在如果为0，赋值给TLelse if (rh.count == 0)readHolds.set(rh);// 重入次数+1，// 第一个：可能是第一次拿// 第二个：可能是重入操作rh.count++;}return 1;}return fullTryAcquireShared(current);
}// 通过tryAcquireShared没拿到锁资源，也没返回-1，就走这
final int fullTryAcquireShared(Thread current) {HoldCounter rh = null;for (;;) {// 拿stateint c = getState();// 现在有互斥锁，不是自己，拜拜！if (exclusiveCount(c) != 0) {if (getExclusiveOwnerThread() != current)return -1;// 公平：有排队的，进入逻辑。   没排队的，过！// 非公平：head的next是写不，是，进入逻辑。   如果不是，过！} else if (readerShouldBlock()) {// 这里代码特别乱，因为这里的代码为了处理JDK1.5的内存泄漏问题，修改过~// 这个逻辑里不会让你拿到锁，做被阻塞前的准备if (firstReader == current) {// 什么都不做} else {if (rh == null) {// 获取最后一个拿到读锁资源的rh = cachedHoldCounter;if (rh == null || rh.tid != getThreadId(current)) {// 拿到我自己的记录重入次数的。rh = readHolds.get();// 如果我的次数是0，绝对不是重入操作！if (rh.count == 0)// 将我的TL中的值移除掉，不移除会造成内存泄漏readHolds.remove();}}// 如果我的次数是0，绝对不是重入操作！if (rh.count == 0)// 返回-1，等待阻塞吧！return -1;}}// 超过读锁的最大值了没？if (sharedCount(c) == MAX_COUNT)throw new Error("Maximum lock count exceeded");// 到这，就CAS竞争锁资源if (compareAndSetState(c, c + SHARED_UNIT)) {// 跟tryAcquireShared一模一样if (sharedCount(c) == 0) {firstReader = current;firstReaderHoldCount = 1;} else if (firstReader == current) {firstReaderHoldCount++;} else {if (rh == null)rh = cachedHoldCounter;if (rh == null || rh.tid != getThreadId(current))rh = readHolds.get();else if (rh.count == 0)readHolds.set(rh);rh.count++;cachedHoldCounter = rh; }return 1;}}
}
  1. 读锁共享，读读不互斥
  2. 读锁可重入，每个获取读锁的线程都会记录对应的重入数
  3. 读写互斥，锁降级场景除外
  4. 支持锁降级，持有写锁的线程，可以获取读锁，但是后续要记得把读锁和写锁读释放
  5. readerShouldBlock读锁是否阻塞实现取决公平与非公平的策略

读锁的释放

获取到读锁，执行完临界区后，要记得释放读锁（如果重入多次要释放对应的次数），不然会阻塞其他线程的写操作。

protected final boolean tryReleaseShared(int unused) {Thread current = Thread.currentThread();//如果当前线程是第一个获取读锁的线程if (firstReader == current) {// assert firstReaderHoldCount > 0;if (firstReaderHoldCount == 1)firstReader = null;elsefirstReaderHoldCount--; //重入次数减1} else {  //不是第一个获取读锁的线程HoldCounter rh = cachedHoldCounter;  if (rh == null || rh.tid != getThreadId(current))rh = readHolds.get();int count = rh.count;if (count <= 1) {readHolds.remove();if (count <= 0)throw unmatchedUnlockException();}--rh.count;  //重入次数减1}for (;;) {  //cas更新同步状态int c = getState();int nextc = c - SHARED_UNIT;if (compareAndSetState(c, nextc))// Releasing the read lock has no effect on readers,// but it may allow waiting writers to proceed if// both read and write locks are now free.return nextc == 0;}
}

写锁的获取

public final void acquire(int arg) {// 尝试获取锁资源（看一下，能否以CAS的方式将state 从0 ~ 1，改成功，拿锁成功）// 成功走人// 不成功执行下面方法if (!tryAcquire(arg) &&// addWaiter：将当前没按到锁资源的，封装成Node，排到AQS里// acquireQueued：当前排队的能否竞争锁资源，不能挂起线程阻塞acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();
}// 读写锁的写锁，获取流程
protected final boolean tryAcquire(int acquires) {// 拿到当前线程Thread current = Thread.currentThread();// 拿到stateint c = getState();// 拿到了写锁的低16位标识wint w = exclusiveCount(c);// c != 0：要么有读操作拿着锁，要么有写操作拿着锁if (c != 0) {// 如果w == 0，代表没有写锁，拿不到！拜拜！// 如果w != 0，代表有写锁，看一下拿占用写锁是不是当前线程，如果不是，拿不到！拜拜！if (w == 0 || current != getExclusiveOwnerThread())return false;// 到这，说明肯定是写锁，并且是当前线程持有// 判断对低位 + 1，是否会超过MAX_COUNT，超过抛Errorif (w + exclusiveCount(acquires) > MAX_COUNT)throw new Error("Maximum lock count exceeded");// 如果没超过锁重入次数， + 1，返回true，拿到锁资源。setState(c + acquires);return true;}// 到这，说明c == 0// 读写锁也分为公平锁和非公平锁// 公平：看下排队不，排队就不抢了// 走hasQueuedPredecessors方法，有排队的返回true，没排队的返回false// 非公平：直接抢！// 方法实现直接返回falseif (writerShouldBlock() ||// 以CAS的方式，将state从0修改为 1!compareAndSetState(c, c + acquires))// 要么不让抢，要么CAS操作失败，返回falsereturn false;// 将当前持有互斥锁的线程，设置为自己setExclusiveOwnerThread(current);return true;
}
  1. 写锁是一个支持重进入的排它锁。
  2. 如果当前线程已经获取了写锁，则增加写状态。
  3. 如果当前线程在获取写锁时，读锁已经被获取（读状态不为0）或者 该线程不是已经获取写锁的线程， 则当前线程进入等待状态。
  4. 写锁的获取是通过重写AQS中的tryAcquire方法实现的。

写锁的释放

写锁释放通过重写AQS的tryRelease方法实现

// 写锁的释放锁
public final boolean release(int arg) {// 只有tryRealse是读写锁重新实现的方法，其他的和ReentrantLock一致if (tryRelease(arg)) {Node h = head;if (h != null && h.waitStatus != 0)unparkSuccessor(h);return true;}return false;
}// 读写锁的真正释放
protected final boolean tryRelease(int releases) {// 判断释放锁的线程是不是持有锁的线程if (!isHeldExclusively())// 不是抛异常throw new IllegalMonitorStateException();// 对state - 1int nextc = getState() - releases;// 拿着next从获取低16位的值，判断是否为0boolean free = exclusiveCount(nextc) == 0;// 返回trueif (free)// 将持有互斥锁的线程信息置位nullsetExclusiveOwnerThread(null);// 将-1之后的nextc复制给statesetState(nextc);return free;
}

锁降级

锁降级是指将持有写锁的线程获取读锁后再释放写锁的过程。这样可以在保持数据一致性的同时，允许其他线程同时进行读操作，提高并发性能。

Java中的ReentrantReadWriteLock类支持锁降级。按照锁降级的规则，持有写锁的线程可以首先获取读锁，然后再释放写锁，以将写锁降级为读锁，不支持锁升级。

例如，以下是一个示例代码，演示了锁降级的过程：

import java.util.concurrent.locks.ReentrantReadWriteLock;public class ReentrantReadWriteLockTest {private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();private int data = 0;public void processWriteAndReadData() {lock.writeLock().lock(); // 获取写锁try {System.out.println(Thread.currentThread().getName() + "线程获取写锁");Thread.sleep(3000);// 执行数据处理操作data++;System.out.println(Thread.currentThread().getName() +"线程数据处理完成，当前值为: " + data);// 锁降级：获取读锁lock.readLock().lock();System.out.println(Thread.currentThread().getName() + "线程获取读锁");} catch (InterruptedException e) {throw new RuntimeException(e);} finally {lock.writeLock().unlock(); // 释放写锁System.out.println(Thread.currentThread().getName() + "线程释放写锁");}try {Thread.sleep(3000);// 执行读操作System.out.println(Thread.currentThread().getName() + "线程读取数据: " + data);} catch (InterruptedException e) {throw new RuntimeException(e);} finally {lock.readLock().unlock(); // 释放读锁System.out.println(Thread.currentThread().getName() + "线程释放读锁");}}public void processReadData() {lock.readLock().lock();try {System.out.println(Thread.currentThread().getName() + "线程获取读锁");System.out.println(Thread.currentThread().getName() + "线程读取数据，当前值为: " + data);} finally {lock.readLock().unlock();System.out.println(Thread.currentThread().getName() + "线程释放读锁");}}public static void main(String[] args) {ReentrantReadWriteLockTest reentrantReadWriteLockTest = new ReentrantReadWriteLockTest();new Thread(() -> {reentrantReadWriteLockTest.processWriteAndReadData();}, "t1").start();try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}new Thread(() -> {reentrantReadWriteLockTest.processReadData();}, "t2").start();}
}

以下是输出结果：

t1线程获取写锁
t1线程数据处理完成，当前值为: 1
t1线程获取读锁
t1线程释放写锁
t2线程获取读锁
t2线程读取数据，当前值为: 1
t2线程释放读锁
t1线程读取数据: 1
t1线程释放读锁

可以发现，通过锁降级，我们能够在保持数据一致性的同时，允许其他线程进行读操作，提高了并发性能。这是读写锁的一个重要特性。

  • 个人公众号
    个人公众号
  • 个人小游戏
    个人小游戏

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

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

相关文章

docker安装配置dnsmasq

docker安装配置dnsmasq

docker下载安装 参考&#xff1a;docker安装、卸载、配置、镜像 如果是低版本的额ubuntu&#xff0c;比如ubuntu16.04.7 LTS&#xff0c;为了加快下载速度&#xff0c;参考&#xff1a;Ubuntu16.04LTS安装Docker。 docker安装dnsmasq 下载dnsmasq镜像 首先镜像我们可以选择…
阅读更多...
代码随想录 动态规划-完全背包问题

代码随想录 动态规划-完全背包问题

52. 携带研究材料 时间限制&#xff1a;1.000S 空间限制&#xff1a;128MB 题目描述 小明是一位科学家&#xff0c;他需要参加一场重要的国际科学大会&#xff0c;以展示自己的最新研究成果。他需要带一些研究材料&#xff0c;但是他的行李箱空间有限。这些研究材料包括实验…
阅读更多...
Could not locate zlibwapi.dll. Please make sure it is in your library path!

Could not locate zlibwapi.dll. Please make sure it is in your library path!

背景 运行PaddleOCR时&#xff0c;用的CUDA11.6配的是cuDNN8.4。但是运行后却报错如下。 解决手段 去网上找到这两个文件&#xff0c;现在英伟达好像不能下载了&#xff0c;但是可以去网盘下载。然后把dll文件放入CUDA11.6文件下的bin目录&#xff0c;而lib文件放入CUDA11.6文…
阅读更多...
基于 RisingWave 和 Kafka 构建实时网络安全解决方案

基于 RisingWave 和 Kafka 构建实时网络安全解决方案

实时威胁检测可实时监控和分析数据&#xff0c;并及时对潜在的安全威胁作出识别和响应。与依赖定期扫描或回顾性分析的安全措施不同&#xff0c;实时威胁检测系统可提供即时警报&#xff0c;并启动自动响应来降低风险&#xff0c;而不会出现高延迟。 实时威胁检测有许多不同的…
阅读更多...
英特尔生态的深度学习科研环境配置-A770为例

英特尔生态的深度学习科研环境配置-A770为例

之前发过在Intel A770 GPU安装oneAPI的教程&#xff0c;但那个方法是用于WSL上。总所周知&#xff0c;在WSL使用显卡会有性能损失的。而当初买这台机器的时候我不在场&#xff0c;所以我这几天刚好有空把机器给重装成Ubuntu了。本篇不限于安装oneAPI&#xff0c;因为在英特尔的…
阅读更多...
【01】htmlcssgit网络基础知识

【01】htmlcssgit网络基础知识

一、html&css 防脱发神器 一图胜千言 使用border-box控制尺寸更加直观，因此，很多网站都会加入下面的代码 * {margin: 0;padding: 0;box-sizing: border-box; }颜色的 alpha 通道 颜色的 alpha 通道标识了色彩的透明度，它是一个 0~1 之间的取值，0 标识完全透明，1…
阅读更多...
探索什么便签软件好用，可以和手机同步的便签软件

探索什么便签软件好用，可以和手机同步的便签软件

在信息技术日新月异的今天&#xff0c;各类数字工具已经成为我们生活与工作的重要助手。便签软件作为一种简单却高效的辅助工具&#xff0c;悄然改变着人们的记录习惯与时间管理方式。而在诸多便签软件中&#xff0c;能够实现手机与电脑同步功能的产品尤显其独特的价值。那么&a…
阅读更多...
数据结构 之 哈希表习题 力扣oj(附加思路版)

数据结构 之 哈希表习题 力扣oj(附加思路版)

哈希表用法 哈希表&#xff1a;键 值对 键&#xff1a;可以看成数组下标&#xff0c;但是哈希表中的建可以是任意类型的&#xff0c;建不能重复,可以不是连续的 值&#xff1a;可以看成数组中的元素&#xff0c;值可以重复&#xff0c;也可以是任意类型的数据 #include<iost…
阅读更多...
R语言程序设计（零基础速通R语言语法和常见函数的使用）

R语言程序设计（零基础速通R语言语法和常见函数的使用）

目录 1.Rstudio中的一些快捷键 2.R对象的属性 3.R语言中常用的运算符​编辑 4.R的数据结构 向量 如何建立向量&#xff1f; 如何从向量里面提取元素&#xff1f; 矩阵 如何建立矩阵&#xff1f; 如何从矩阵里面提取元素&#xff1f; 数据框 如何建立数据框&#xf…
阅读更多...
python-pandas基础学习

python-pandas基础学习

可参考&#xff1a; pandas&#xff1a;http://pandas.pydata.org/docs/user_guide/10min.html 一、基础知识 DataFrame 方法&#xff0c;可以将一组数据&#xff08;ndarray、series, map, list, dict 等类型&#xff09;转化为表格型数据 import pandas as pd data {name: …
阅读更多...
前端三件套 | 综合练习：模拟抽奖活动，实现一个简单的随机抽取并显示三名获胜者

前端三件套 | 综合练习：模拟抽奖活动，实现一个简单的随机抽取并显示三名获胜者

随机运行结果如下&#xff1a; 参考代码如下&#xff1a; <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><tit…
阅读更多...
鸿蒙-自定义组件-语法

鸿蒙-自定义组件-语法

目录 语法组成 在学习自定义组件前&#xff0c;先看一下ArkTS的组成 装饰器 用于装饰类、结构、方法以及变量&#xff0c;并赋予其特殊的含义。如上述示例中Entry、Component和State都是装饰器 Entry 表示该自定义组件为入口组件 Component 表示自定义组件 State 表示组…
阅读更多...
python基础——字符串的常见操作方法【下标索引，index，count，len，replace，split，strip】

python基础——字符串的常见操作方法【下标索引，index，count，len，replace，split，strip】

&#x1f4dd;前言&#xff1a; 字符串是一种有序的&#xff0c;允许重复字符串存在的&#xff0c;不可修改的序列 这篇文章主要总结一下python中有关字符串的部分相关知识&#xff0c;以及字符串的常见操作方法&#xff1a; 1&#xff0c;和其他序列极其类似的操作方法 2&…
阅读更多...
2024/03/18(网络编程·day4)

2024/03/18(网络编程·day4)

一、思维导图 二、广播 广播发送端 #include<myhead.h> int main(int argc, const char *argv[]) {//1、创建套接字int sfd socket(AF_INET,SOCK_DGRAM,0);if(sfd -1){perror("socket error");return -1;}//2、设置允许广播int broadcast 1;if(setsockopt…
阅读更多...
嵌入式DSP教学实验箱操作教程：2-20 数模转换实验（模拟SPI总线输出电压值）

嵌入式DSP教学实验箱操作教程：2-20 数模转换实验（模拟SPI总线输出电压值）

一、实验目的 掌握GPIO模拟SPI总线的使用&#xff0c;了解AD5724的芯片特性和使用&#xff0c;并实现基于AD5724输出电压值。 二、实验原理 StarterWare StarterWare是一个免费的软件开发包&#xff0c;它包含了示例应用程序。StarterWare提供了一套完整的GPIO寄存器配置接…
阅读更多...
在吗？腾讯云服务器2024降价了61元一年，要么？

在吗？腾讯云服务器2024降价了61元一年，要么？

腾讯云服务器多少钱一年&#xff1f;61元一年起。2024年最新腾讯云服务器优惠价格表&#xff0c;腾讯云轻量2核2G3M服务器61元一年、2核2G4M服务器99元一年可买三年、2核4G5M服务器165元一年、3年756元、轻量4核8M12M服务器646元15个月、4核16G10M配置32元1个月、312元一年、8核…
阅读更多...
QT C++ QButtonGroup应用

QT C++ QButtonGroup应用

//QT 中&#xff0c;按钮数量比较少&#xff0c;可以分别用各按钮的信号和槽处理。 //当按钮数量较多时&#xff0c;用QButtonGroup可以实现共用一个槽函数&#xff0c;批量处理&#xff0c;减少垃圾代码&#xff0c; //减少出错。 //开发平台&#xff1a;win10QT6.2.4 MSVC…
阅读更多...
IDEA调试入门指南

IDEA调试入门指南

IDEA调试前准备 一、准备调试环境 在开始调试之前&#xff0c;确保你的IDEA已经正确安装并配置好。打开你的项目&#xff0c;确保所有的依赖都已正确加载&#xff0c;并且项目能够正常编译和运行。 二、设置断点 断点是调试过程中非常关键的一部分&#xff0c;它允许你在代…
阅读更多...
O2OA红头文件流转与O2OA版式公文编辑器基本使用

O2OA红头文件流转与O2OA版式公文编辑器基本使用

O2OA开发平台在流程管理中&#xff0c;提供了符合国家党政机关公文格式标准&#xff08;GB/T 9704—2012&#xff09;的公文编辑组件&#xff0c;可以让用户在包含公文管理的项目实施过程中&#xff0c;轻松地实现标准化公文格式的在线编辑、痕迹保留、手写签批等功能。并且可以…
阅读更多...
使用PySpider进行IP代理爬虫的技巧与实践

使用PySpider进行IP代理爬虫的技巧与实践

目录 前言 一、安装与配置PySpider 二、使用IP代理 三、IP代理池的使用 四、处理代理IP的异常 五、总结 前言 IP代理爬虫是一种常见的网络爬虫技术&#xff0c;可以通过使用代理IP来隐藏自己的真实IP地址&#xff0c;防止被目标网站封禁或限制访问。PySpider是一个基于P…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023