
**问题：PDF每页怎么批量添加两侧留白？pdf怎么调整上下边距？pdf扩展左右两侧边距？如何给pdf增加留白，方便备注？**


PDF扩展边距的操作非常简单，只需要打开

网站:  [pdf加白边 - 大宁工作室](https://www.douyacun.com)

微信小程序：大宁宝箱

![大宁宝箱](https://www.douyacun.com/images/blog/1/assert/daningbaoxiang.webp)

支持的多种样式，按比例自定义边距空白大小

1. 左右两侧边距空白，中间展示内容
2. 上下两侧留白，中间展示内容

3. 顶部留白，底部展示内容
4. 底部留白，顶部展示内容
5. 左侧留白，右侧展示内容
6. 右侧留白，左侧展示内容
7. 四周扩展白边，中间展示内容
8. 右边、下边增加空白边距，左上展示内容

扩展pdf边距，增加更多留白 操作步骤：

第一步：选择文件然后选择在哪一测增加边距

![pdf加白边-选择样式](/images/blog/1/tools/assert/pdf加白边-选择样式.jpg)

第二步：点击添加白边，等待处理完成后下载即可

![pdf加白边-下载预览](/images/blog/1/tools/assert/pdf加白边-下载预览.jpg)

在遇到以下场景时，可以考虑使用扩展pdf边距

1. 打印排版：在打印 PDF 文件时，可能会出现内容被裁剪或者排版不够美观的情况。通过扩展 PDF 的边距和增加留白，可以保证内容不会被裁剪，同时也可以调整排版，使其更加美观。
2. 添加注释：在 PDF 文件上添加注释或者批注时，可能需要额外的空间。通过增加 PDF 的左右两侧边距和增加留白，可以为注释或者批注留出更多的空间，从而更方便的添加和查看注释。
3. 电子书阅读：在使用电子书阅读器阅读 PDF 文件时，可能需要调整页面的大小和布局。通过扩展 PDF 的边距和增大左右两侧边距，可以让文本和图片更好的适应屏幕大小，从而提升阅读体验。
4. 印刷排版：在进行印刷排版时，可能需要对 PDF 文件进行调整，以便让它们更好地适应印刷机的要求。通过扩展 PDF 的边距和增加留白，可以调整页面的大小和布局，从而更好地适应印刷要求。
5. 转换文档格式：有些文档转换工具可能要求 PDF 文件必须具有一定的边距和留白才能进行转换。在这种情况下，通过扩展 PDF 的边距和增加留白，可以确保 PDF 文件可以被正确转换为其他格式。

总之，扩展 PDF 的边距，增加留白，增大左右两侧边距可以让我们更好的处理 PDF 文件，并提升阅读和印刷体验。


PDF扩展边距可以让您在文档的边缘留下更多的空间，以便于添加注释、标记或其他信息

如何修改pdf两侧边距，增加留白，方便备注？


网址：https://www.douyacun.com/pdf/delete-text

微信小程序：搜索 「**大宁宝箱**」



步骤概览

- 第一步：选择文件，上传文件
- 第二步：选择页面，分析文字
- 第三步：选择文字，删除文字
- 第四步：预览成果，下载文件

优势

- PDF删除文字速度快，准确度高
- 支持删除单页/整本文字
- 结果预览

问题：

- 无法精准删除，不影响其他位置、其他页面（努力优化）
- 第三步识别的文字  字体、颜色 信息无法展示 （后续优化）
- 点击选择文字时会选中多处？（后续优化）
- 只想删除某页的文字，整本内容都删除了？



##  第一步：选择文件

支持拖拽文件上传

![pdf删除文字-选择文件](/images/blog/1/tools/assert/pdf删除文字-选择文件.png)

文件上传完成后需要选择第几页来分析文字，如下图：

## 第二步：选择页面、分析PDF文字

![pdf删除文字-分析文字](/images/blog/1/tools/assert/pdf删除文字-分析文字.png)

> 选择第几页是为了快速分析文字，如果分析整本PDF会可能占用多的资源和时间

点击立即分析之后会提取第N页的文字内容，这里可以会提取文字字体编码、大小，后续会分析文字颜色，如下图：

![pdf删除文字-点击选中](/images/blog/1/tools/assert/pdf删除文字-点击选中.png)

这里有2种情况：

1. 每个字单独分开，如上
2. 几个字拼在一起，点击会全部删除

##  第三步：选择删除文字

点击文字选中需要删除的文字，会有中划线标记需要删除的文字，如上图。

问题：**点击选择文字时会选中多处？（如上图红线标记的地方）**

> PDF删除文字是通过匹配字体编码的方式进行删除的，如果是相同字体相同长度的文字，那选中的都会被删除掉
>
> 后续优化！



问题：**只想删除某页的文字，整本内容都删除了！**

> 这种情况多见于文字水印，PDF为了减小体积，对于相同的内容是可以以引用的方式加载
>
> 这里多半情形无需优化！

 

## 第四步：成果预览、下载文件

下方是原图和删除文字后的对比图，第二张是第四步成果预览的截图。

<img src="/images/blog/1/tools/assert/pdf删除文字-原文件.png" alt="pdf删除文字-原文件" style="width:40%;text-align:left" />

<img src="/images/blog/1/tools/assert/pdf删除文字-成果预览.png" alt="pdf删除文字-成果预览" style="zoom:40%;" />


如何快速在线 删除/清除/去除/隐藏 pdf文字字符串


大家如何去除 wps word导出来的pdf文件水印  "WPS PDF编辑试用" ,

![WPSPDF编辑试用](/images/blog/1/tools/assert/WPSPDF编辑试用.png)



一、通过网站去除"WPS PDF编辑试用"水印

1. 打开网站: https://www.douyacun.com/pdf/remove-watermark

2. 选择PDF文件，分析PDF文件，勾选 `WPS PDF编辑试用` 水印图片

![勾选WPSPDF编辑试用.png](/images/blog/1/tools/assert/勾选WPSPDF编辑试用.png)

3. 预览去除"WPS PDF编辑试用"水印的效果，点击下载文件即可

![预览WPSPDF编辑试用.png](/images/blog/1/tools/assert/预览WPSPDF编辑试用.png)

二、PDF工具箱使用教程

下载地址：

mac: [https://www.douyacun.com/s/pdftools](https://www.douyacun.com/s/pdftools)

windows: [https://www.douyacun.com/s/pdf_tools.exe](https://www.douyacun.com/s/pdf_tools.exe)

选择文件

图片水印：勾选“WPS PDF编辑试用”水印图片

![pdf工具箱-WPSPDF编辑试用.png](/images/blog/1/tools/assert/pdf工具箱-WPSPDF编辑试用.png)

文字水印：搜索并选中文字水印，取消其他不是水印的文字

预览保存：

![pdf工具箱-WPSPDf编辑试用-预览保存.png](/images/blog/1/tools/assert/pdf工具箱-WPSPDf编辑试用-预览保存.png)

PDF工具箱专业去除'wps pdf编辑试用'

wps pdf编辑试用—去水印/移除水印/删除水印/隐藏水印


**如何去除亿图图示/亿图脑图导出的pdf水印？**

> 亿图软件可让您轻松绘制流程图，思维导图，信息图，组织架构图，网络拓扑图，户型图，电路图等210种绘图类型，但是导出pdf是有水印存在的。

去除之后的pdf保留原有格式，无其他水印嵌入，多页也可以轻松去除，另外还可以去除 wps非会员水印、wps pdf编辑试用-非会员水印、迅捷pdf会员、扫描全能王 创建、亿图图示水印、夸克扫描王 等其他水印

![如何去除亿图脑图pdf水印步骤](/images/blog/1/tools/assert/如何去除亿图脑图pdf水印步骤.jpg)



**方法一：使用网站去除pdf水印** - [pdf去除水印-专业版](https://www.douyacun.com/pdf/remove-watermark)

**方法二：微信小程序去除pdf水印 - 「大宁宝箱」**

![大宁宝箱](https://www.douyacun.com/images/blog/1/assert/daningbaoxiang.jpeg)

步骤都是一样的：

1. 选择pdf文件
2. 分析pdf文件
3. 预览或下载去除水印后的pdf文件



下方是操作步骤的截图：

第一步：打开网站 [pdf去除水印-专业版](https://www.douyacun.com/pdf/remove-watermark) 选择文件上传文件

![如何去除亿图图示pdf水印-选择文件](/images/blog/1/tools/assert/如何去除亿图图示pdf水印-选择文件.jpg)

第二步：分析pdf文件，这一步会分析pdf文件中的文字水印、图片水印、图形水印，并自动展示是水印的图片，如下图，网站可以很快的就分析出亿图脑图的图片水印

![如何去除亿图图示pdf水印-分析文件](/images/blog/1/tools/assert/如何去除亿图图示pdf水印-分析文件.jpg)

第三步：立即清理pdf水印，支持多页pdf去除水印，并可以预览去除结果，pdf亿图脑图的水印去除的很干净

![如何去除亿图图示pdf水印-预览下载文件](/images/blog/1/tools/assert/如何去除亿图图示pdf水印-预览下载文件.jpg)



如果对您有帮助，感兴趣的小伙伴可以关注微信公众号「大宁工作室」


简简单单就可以去除亿图图示pdf水印

如何去除亿图图示pdf水印，简单一招搞定


网站：[PDF去水印](https://www.douyacun.com/pdf/remove-watermark)

微信小程序：扫描下方二维码<img src="/images/blog/1/tools/assert/gh_ef4d7d1f7966_258.jpeg" alt="gh_ef4d7d1f7966_258" style="zoom:33%;text-align:right" />

此类水印是常见的图片水印，水印是图片，后期添加到PDF上面去的。去除成功率较高。以下为常见案例：

**案例1：** 

pdf去水印：微信公众号：djky66 (顶尖考研祝您上岸)

<img src="/images/blog/1/tools/assert/微信公众号：djky66_顶尖考研祝您上岸-去水印前.png" alt="微信公众号：djky66_顶尖考研祝您上岸-去水印前" style="zoom:33%;text-align:left;"/>
<img src="/images/blog/1/tools/assert/微信公众号：djky66_顶尖考研祝您上岸-去水印后.png" alt="微信公众号：djky66_顶尖考研祝您上岸-去水印后" style="zoom:33%;text-align:right;"/>

**案例2:**

PDF去水印：华图教师

<img src="/images/blog/1/tools/assert/华图教师-去水印前.png" alt="华图教师-去水印前" style="zoom:25%;text-align:left" />
<img src="/images/blog/1/tools/assert/华图教师-去水印后.png" alt="华图教师-去水印后" style="zoom:25%;text-align:right;" />

**案例3:**

PDF去水印：夸克扫描王

<img src="/images/blog/1/tools/assert/夸克扫描王-去水印前.png" alt="夸克扫描王-去水印前" style="zoom:33%;text-align:left" />
<img src="/images/blog/1/tools/assert/夸克扫描王-去水印后.png" alt="夸克扫描王-去水印后" style="zoom:33%;" />



**案例4:**

PDF去水印：223网校

<img src="/images/blog/1/tools/assert/233网校-去水印前.png" alt="233网校-去水印前" style="zoom:25%;text-align:left" />
<img src="/images/blog/1/tools/assert/233网校-去水印后.png" alt="233网校-去水印后" style="zoom:25%;" />

2023年2月PDF去除水印成果展示


mac签名打包的坑比较深：有需求的朋友可以加微信  私聊



## app打包

python打包工具用的pyinstaller

```shell
bundle="com.douyacun.pdftools"
appname="PDF工具箱"
echo ">>>> 清理"
sudo rm -rf dist build
echo ">>>> 打包"
sudo pyinstaller \
  --windowed \
  --onedir \
  --icon=assert/icon.icns \
  --osx-bundle-identifier=${bundle} \
  main.py \
  --name ${appname}
sudo pyinstaller --clean --noconfirm $appname.spec
```

介绍一下打包参数：

--onedir 打包成目录，启动速度明显提示。最后可以打包成dmg

--osx-bundle-identifier 指定应用包名，签名需要用到



## app 签名

 [https://idmsa.apple.com/IDMSWebAuth/signin](https://idmsa.apple.com/IDMSWebAuth/signin)

签名证书的申请流程参考知乎：[https://zhuanlan.zhihu.com/p/431634112](https://zhuanlan.zhihu.com/p/431634112)

```shell
#echo ">>>> 签名修复"
sudo python for_codesign.py dist/PDF工具箱.app

#echo ">>>> 签名"
sudo codesign -s "Developer ID Application: * Enterprise Management Co., Ltd (P*)" -f --entitlements entitlements.plist --timestamp --all-architectures  --deep --options=runtime ～/Documents/github.com/pdf-tools/dist/PDF工具箱.app
```

签名脚本报错：

```
bundle format unrecognized, invalid, or unsuitabl

Contents/MacOS/PyQt5/Qt5/qml/QtQml/Models.2
```

这个错误就是因为codesign不支持目录名带 点 `Models.2`

解决方案就是：将 `Models.2`  改成 `Models_2` , 然后再将 `Models_2` 创建软链到 `Models.2`



pyintaller 给出的解决方案是将 `Models.2` 转移到 `/Contents/Resources/` 下，然后软链过来

https://github.com/pyinstaller/pyinstaller/wiki/Recipe-OSX-Code-Signing-Qt

此方案已经不通了，mac公证时要求所有用到的文件都需要签名：

```
The signature of the binary is invalid.
```



签名修复脚本：

```python
# -*- coding: utf-8 -*-
import os
import shutil
import sys
from pathlib import Path
from typing import Generator, List, Optional

from macholib.MachO import MachO


def find_problematic_folders(folder: Path) -> Generator[Path, None, None]:
    for path in folder.iterdir():
        if not path.is_dir() or path.is_symlink():
            # Skip simlinks as they are allowed (even with a dot)
            continue
        if "." in path.name:
            yield path
        else:
            yield from find_problematic_folders(path)


def main(args: List[str]) -> int:
    """
    修复mac签名
    - 重命名.2目录为 _2
    - 创建软链
    """
    for app in args:
        name = os.path.basename(app)
        print(f">>> [{name}] Fixing Qt folder names")
        path = Path(os.path.abspath(app)) / "Contents" / "MacOS"
        for folder in find_problematic_folders(path):
            dest = Path(str(folder).replace(".2", "_2"))
            shutil.move(folder, dest)
            os.symlink(dest, folder)
            print(f" !! Fixed {folder}")


if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))

```



## app打包dmg

我是用的dmg canvas

https://www.jianshu.com/p/f07a8351a14f



## dmg公证

 [https://appleid.apple.com/sign-in](https://appleid.apple.com/sign-in)

需要对应用创建专用密码

![image-20230111232411436](/images/blog/1/pyqt/assert/image-20230111232411436.png)

```
# 上传app
xcrun altool --notarize-app \
             --primary-bundle-id="com.douyacun.pdftools" \
             --username="账号" \
             --password="APP专用密码" \
             -t="osx" \
             --asc-provider="密钥证书编号" \
             --file "pdf工具箱.dmg"
# 查看公正结果
 xcrun altool --notarization-info "1669889c-3c11-45f3-ad0a-525e3565bdaf" -u "gqjk2021@163.com" --password "app专用密码"
```



No errors getting notarization info.

       Date: 2023-01-11 15:14:44 +0000
       Hash: 904cbbba016a86cf32cdfed8f3762da219d3f0230e7f4d5ac975264d8b34f319
       RequestUUID: 1669889c-3c11-45f3-ad0a-525e3565bdaf
       Status: in progress



解决安装时提示：安装包已损坏，无法打开 或 来自不明开发者的解决办法

pyqt5 mac打包签名公证


1. 从本地加载图片

```python
img = QImage("/Users/admin/Desktop/hello.png")
pimg = QPixmap.fromImage(image)
self.imgLabel.setPixmap(pimg)
```

2. 图片铺满QLabel

```python
img = QImage("/Users/admin/Desktop/hello.png")
pimg = QPixmap.fromImage(image)
self.imgLabel.setPixmap(pimg)
self.imgLabel.setScaledContents(True)
```

3. 等比例显示未知大小的图片

```python
img = QImage("/Users/admin/Desktop/hello.png")
pimg = QPixmap.fromImage(image)

fw = self.imgLabel.width() / width
fh = self.imgLabel.height() / height

factor = min(fw, fh)

width = int(width * factor)
height = int(height * factor)
nimg = img.scaled(width, height, QtCore.Qt.KeepAspectRatio, QtCore.Qt.SmoothTransformation)
self.imgLabel.setPixmap(nimg)
```



如何能像css那样max-width/max-height等比例缩放居中显示图片

pyqt5加载图片，等比例显示图片


# 批量下载视频文件，不影响GUI运行，GUI展示相应的进度

版本

- 平台
  - mac 11
  - windows 10

- QT：5.15.7

- aiohttp: 3.8.3
- qasync: 0.23.0

**思路一：**

启动一个线程QThread后台去执行，下载任务和下载进度 都是 通过pyqtSignal进行交互

```python
class DownloadThread(QtCore.QThread):
    def __init__(self):
        super(DownloadThread, self).__init__()

    def run(self) -> None:
        loop = qasync.QEventLoop(self)
        asyncio.set_event_loop(loop)
        loop.run_forever()


class Download(QtCore.QObject):
    url_signal = pyqtSignal(str)
    progress_signal = pyqtSignal(str)

    def __init__(self):
        super(Download, self).__init__()
        self.url_signal.connect(self.schedule)

		@asyncSlot(str)
    async def schedule(self, data):
        if data == "":
            return
        video = json.loads(data, object_hook=decodeVideo)
        loop = asyncio.get_event_loop()
        loop.set_exception_handler(self.exception_handle)
        session_timeout = aiohttp.ClientTimeout(total=None, sock_connect=10)
        async with aiohttp.ClientSession(loop=loop, timeout=session_timeout) as session:
            cwlist = [loop.create_task(self.fetch_limit(semaphore, session, video, dir)) for video in videos]
            await asyncio.gather(*cwlist)
          
    async def fetch(self, video):
      	filename = video.title if video.title else video.id
        file = path.join(dir, filename + ".mp4")
        try:
            with open(file, "wb+") as fd:
                logging.info("%s\t%s\t%s" % (video.title, video.video_url, file))
                # 在windows上这里会被卡住，不再仅需运行，替换使用requests都可以正常返回
                async with session.get(video.video_url, headers=self.getHeaders()) as resp:
                    video.content_length = resp.headers["Content-Length"]
                    logging.info("content-length: " + video.content_length)
                    logging.info("file: " + file)
                    async for chunk in resp.content.iter_chunked(chunk_size):
                        fd.write(chunk)
                        video.size += len(chunk)
                        video.progress = int(video.size / int(video.content_length) * 100)
                        self.progress_signal.emit(json.dumps(video, default=encodeVideo))
        except asyncio.exceptions.TimeoutError as e:
            print("fetch timeout: ", e)
                        
 class Batch(QtWidgets.QWidget):
    def __init__(self, context: Context):
        super(IndexBatch, self).__init__()
        self.context = context
        self.thread = DownloadThread()
        self.download = Download()
        self.download.moveToThread(self.thread)
        self.thread.start()
        self.setUi()                       
		
    def onDownload(self):
        for video in self._videos:
            if video.checked:
                self.download.url_signal.emit(json.dumps(video, default=encodeVideo),
                                              path.join(self.save_dir, self._author_nickname))
```

问题：

思路一的代码在mac上可以运行，session请求是可以响应的，但是在win10上，`async with session.get(video.video_url) as resp` 会被卡住不再执行，解决思路

- 使用`reqeusts.get(video.video_url)`是可以正常响应的
- aiohttp设置sock_connect没有收到`asyncio.exceptions.TimeoutError` 异常打印，可能是`async with session.get`没有进入到执行队列中去～

**思路二**

尝试去掉DownloadThread执行下载任务的思路，直接将下载任务放到异步执行队列(loop)中去

```python
class Download(QtCore.QObject):
    progress_signal = pyqtSignal(str)

    def __init__(self):
        super(Download, self).__init__()

    async def schedule(self, videos, dir: str):
        logging.info("download count: %d" % (len(videos)))
        loop = asyncio.get_event_loop()
        loop.set_exception_handler(self.exception_handle)
        session_timeout = aiohttp.ClientTimeout(total=None, sock_connect=10)
        async with aiohttp.ClientSession(loop=loop, timeout=session_timeout) as session:
            cwlist = [loop.create_task(self.fetch(semaphore, session, video, dir)) for video in videos]
            await asyncio.gather(*cwlist)

    def exception_handle(self, *args):
        logging.info("asyncio.exception.handle: {}" % args)

    async def fetch(self, session, video, dir):
        filename = video.title if video.title else video.id
        file = path.join(dir, filename + ".mp4")
        with open(file, "wb+") as fd:
          logging.info("%s\t%s\t%s" % (video.title, video.video_url, file))
          async with session.get(video.video_url, headers=self.getHeaders()) as resp:
            video.content_length = resp.headers["Content-Length"]
            async for chunk in resp.content.iter_chunked(chunk_size):
              fd.write(chunk)
              video.size += len(chunk)
              video.progress = int(video.size / int(video.content_length) * 100)
              self.progress_signal.emit(json.dumps(video, default=encodeVideo))
              
class Batch(QtWidgets.QWidget):
    def __init__(self, context: Context):
        super(IndexBatch, self).__init__()
        self.context = context
        self.download = Download()
        self.setUi()                       
		
    def onConnect(self):
        self._ui.download_btn.clicked.connect(self.onDownload)
        self.download.progress_signal.connect(self.onDownloadProcess)

    # 订阅Download下载进度更新进度条
    def onDownloadProcess(self, data):
        vd = json.loads(data, object_hook=decodeVideo)
        bar = self._progress_bar_dict[vd.id]
        bar.setValue(vd.progress)
        
    @asyncSlot()
    async def onDownload(self):
        videos = []
        for video in self._videos:
            if video.checked and video.progress == 0:
                videos.append(video)
        await self.download.schedule(videos, self.save_dir)
        
async def main():
    def close_future(future, loop):
        loop.call_later(10, future.cancel)
        future.cancel()

    loop = asyncio.get_event_loop()
    future = asyncio.Future()

    app = QApplication.instance()
    if hasattr(app, "aboutToQuit"):
        getattr(app, "aboutToQuit").connect(
            functools.partial(close_future, future, loop)
        )
    m = MainWindow()
    m.run()
    await future


if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling)
    try:
        qasync.run(main())
    except asyncio.exceptions.CancelledError:
        sys.exit(1)
```

**效果截图**

![pyqt5-asyncio-download](/images/blog/1/pyqt/assert/pyqt5-asyncio-download.png)



# 异步加载图片，不影响GUI运行, 待补充





异步批量下载和多线程还是有区别，就是协程和线程的区别

pyqt5异步批量下载




### 1. qtablewidget增加选择框？

```
cb = QtWidgets.QTableWidgetItem()
# item 转为checkbox，样式受checkbox样式影响
cb.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled)
# 居中
cb.setTextAlignment(QtCore.Qt.AlignCenter)
# 选中状态
cb.setCheckState(QtCore.Qt.Unchecked if not row.checked else QtCore.Qt.Checked)
# i：第i行，0：第0列，
self._table_widget.setItem(i, 0, cb)
```

样式：

```qss
/*---------qcheckbox-----------*/
QCheckBox {
}

QCheckBox::indicator {
    /* 选择框尺寸 */
}

QCheckBox::indicator::checked:pressed {
    image:url(:/resource/checkbox-checked.png);
}
QCheckBox::indicator::checked {
    image:url(:/resource/checkbox-checked.png);
}
```

效果：![qtablewidget-checkbox](/images/blog/1/pyqt/assert/qtablewidget-checkbox.png)



### 2. QTableWidget设置进度条QProgressBar

```python
bar = QtWidgets.QProgressBar()
bar.setMinimum(0)
bar.setMaximum(100)
bar.setValue(100)
bar.setTextVisible(True)
self._table_widget.setCellWidget(0, 4, bar)
```

样式

```css
QProgressBar {
    text-align: right;
    vertical-align: center;
    padding-right: 40px;
    color: $selectBackground;
}

QProgressBar::chunk {
    background-color: $selectBackground;
    width: 10px;
    margin: 0.5px;
    text-align: center;
}
```

效果![qtablewidget_qprocessbar](../../../../Desktop/qtablewidget_qprocessbar.png)



### QTableWidget导出excel，待整理

https://blog.csdn.net/weixin_41882459/article/details/108394548

qtablewidget增加选择框|QTableWidget设置进度条QProgressBar

pyqt5 qtablewidget用法总结


[toc]

# 全局锁

对整个数据实例加锁，FTWRL

```sql
flush table with read lock
```

使用这个语句后其他线程的语句会阻塞：数据更新语句，数据表定义语句和更新事务的提交语句

**使用场景**：全库逻辑备份，mysqldump导出的时候使用MVCC的一致性保证innodb导出数据，但是对于MyISAM来说是不支持的，备份只能通过FTWRL来保证

**为什么不用 set global readonly = true**

1.  readonly的值，一般被用作判断一个库是主库还是从库，修改global变量的方式影响面大，不建议使用
2.  异常处理机制上，如果执行FTWRT由于客户端发生异常断开，mysql会自动释放这个全局锁，而设置全局readonly后，如果客户端发生异常，则数据库会一直保持readonly状态，导致整个库事件处于不可写状态，风险较高

# 表级锁

mysql表级锁有两种: 

**表锁**

与FTWRL类似，可以用unlock tables主动释放锁，也可以在客户端断开的时候自动释放

```sql
lock tables t1 read, t2 write;
```

其他线程写t1，读写t2都会被阻塞，该线程也只能读t1，读写t2

不推荐使用，粒度太大，目前很少见到了

**MDL（元数据锁，meta data lock）**

MDL不需要显示使用，在访问一个表的时候会自动加上，MDL的作用是，保证读写的正确性，防止在一个查询在执行期间另一线程对这个表结构做变更，删除了一列，导致查询线程的结果和表结构对不上。

对表做CURD时，加MDL读锁；对表结构做变更操作时，加MDL写锁；

-   MDL读锁之间不互斥，可以并发读写
-   MDL写锁互斥，两个线程同时修改，只能等拿到锁的线程执行完成

| 时间点 | 会话A                                | 会话B                        | 会话C                             | 会话D                                                |
| ------ | ------------------------------------ | ---------------------------- | --------------------------------- | ---------------------------------------------------- |
| 1      | begin; <br />Select count(*) from t; |                              |                                   |                                                      |
| 2      |                                      | Select * from t where id =2; |                                   |                                                      |
| 3      |                                      |                              | alter  table t add column c3 int; |                                                      |
| 4      |                                      |                              |                                   | Show  processlist；B：copy to tmp table              |
| 5      |                                      |                              | 阻塞                              | Show  processlist;B：Waiting for table metadata lock |
| 6      | A：执行完毕                          |                              |                                   |                                                      |
| 7      |                                      | B: 执行完成                  |                                   | Show  processlist; B：rename table                   |
| 8      | Select  count(*) from t;             |                              |                                   |                                                      |
| 9      |                                      |                              | C：执行完毕                       |                                                      |
| 10     |                                      |                              |                                   | Show  processlist; A: Sending data                   |
| 11     | A:执行完毕                           |                              |                                   |                                                      |

session A先启动，这是会对t加一个MDL读锁，session B需要的也是加MDL读锁。读锁不互斥可以正常执行

而session C需要MDL写锁，而之后所有要在表t上申请MDL读锁的请求也会被session C阻塞。等于现在这个表t完全不可读写了，而客户端超时会有重试机制，新的session请求，这个库的线程很快就爆满。

**如何安全的进行表结构变更**

如果是热表的话，就麻烦了，虽然数据量不大，但是请求频繁。这时候kill掉未必管用，因为新的请求马上就来了，一般能遇到这种情况的公司都是有点实力的了，必定会有DBA的支撑了，很幸运和DBA聊了一下

一般表结构变更直接执行就好了，如果遇到一直拿不到MDL锁的情况, 考虑

-   处理慢查询，商量能不能kill
-   解决长事务，会一直占着MDL锁，[长事物解决方案](innodb事务#长事务)
-   对于热表的话，因为查询很频繁，会一直拿不到MDL写锁，考虑晚上执行，到这就很头疼了。
-   如果是上亿数据的大表（数据几千万，甚至过亿）的话, 或者说一直拿不到MDL写锁的话，推荐方案：
    -   [pt-online-schema-change](https://www.percona.com/doc/percona-toolkit/LATEST/pt-online-schema-change.html)
    -   [gh-ost](https://github.com/github/gh-ost)
    -   [阿里云-不锁表结构变更](https://help.aliyun.com/document_detail/98373.html)

主要原理：

-   1、创建临时表：CREATE TABLE tmp_table_table LIKE table_name
-   2、变更临时表结构： ALTER TABLE tmp_table_table XXXX
-   3、全量拷贝数据：INSERT IGNORE INTO tmp_table_table (SELECT %s FROM table_name FORCE INDEX (%s) WHERE xxx
-   4、增量数据binlog同步： UPDATA/INSRT/DELETE tmp_table_name
-   5、切换新旧表： RENAME TABLE table_name to old_tmp_table_table, tmp_table_name to table_name



# 行锁

**两阶段锁协议**

解锁阶段：事务提交或者回滚

加锁阶段：第一个变更开始

在innodb事务中，行锁是在需要的时候才加上的，但并不是不需要了就立即释放，而是要等到事务结束时才释放，这个就是两阶段锁协议

**加锁原则**

1.  原则1：加锁的基本单位是next-key lock。next-key lock是前开后闭区间。
2.  原则2：查找过程中访问到的对象才会加锁。
3.  优化1：索引上的等值查询，给唯一索引加锁的时候，next-key lock退化为行锁。
4.  优化2：索引上的等值查询，向右遍历时且最后一个值不满足等值条件的时候，next-key lock退化为间隙锁。
5.  一个bug：唯一索引上的范围查询会访问到不满足条件的第一个值为止。

## 三种算法

**幻像读**

innodb事物默认的隔离级别是REPEATBLE RRAD， 

幻想读是指在同一事物下，连续执行两次相同的sql，会有不同的结果，第二次sql可能会返回之前不存在的行。

next key lock是如何解决的?

```sql
select * from t where key > 20 for update;
```

next key lock会锁住(20, ∞]区间，在此事物未提交期间，key > 20记录都是不能插入的。

- Record Lock

单个行记录上锁，总是锁住索引记录。如果表在建立是并没有建立索引，innodb会使用隐式的主键来锁

索引可以是主键、唯一、普通索引

- Gap lock

间隙锁，锁定一个范围，但不包含记录本身。

- Next key lock

gap lock + record lock 锁定范围并锁定记录本身。

innodb对于行的查询采用的是这种方式，eg. 有一个索引，有10、11、13、20四个值，那么该索引被Next key lock的区间是

- (-∞, 10)
- [10, 11)
- [11, 13)
- [13, 20)
- [20, +∞)

**等值间隙锁**

```sql
CREATE TABLE `t` (
  `id` int(11) NOT NULL,
  `c` int(11) DEFAULT NULL,
  `d` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `c` (`c`)
) ENGINE=InnoDB;

insert into t values(0,0,0),(5,5,5),(10,10,10),(15,15,15),(20,20,20),(25,25,25);
```



| session A                             | session B                                | session C                             |
| ------------------------------------- | ---------------------------------------- | ------------------------------------- |
| begin;                                |                                          |                                       |
| update t set  d = d + 1 where id = 7; |                                          |                                       |
|                                       | insert into t  values(8,8,8);     block; |                                       |
|                                       |                                          | update t set d = d + 1 where id = 10; |

Session B 会被block，因为session A的加锁区间是(5,10]; 因为id=7不存在，退化为间隙锁。session B会被阻塞，10是开区间，这行是可以修改的。

**非唯一索引等值锁**

| session A                                         | session B                                     | session C                                   |
| ------------------------------------------------- | --------------------------------------------- | ------------------------------------------- |
| begin;                                            |                                               |                                             |
| select id from t where c = 5 lock in  share mode; |                                               |                                             |
|                                                   | update t set d = d + 1 where id = 5;          |                                             |
|                                                   | update t set d = d + 1 where c =  5; (block); |                                             |
|                                                   |                                               | insert into t values  (7,7,7);     (block); |

1. `update t set d = d + 1 where id = 5;` 为什么不会阻塞？

where条件是id = 5，session A `select id from t where c = 5 lock in  share mode;` 

lock in share mode只锁**覆盖索引**，不会影响主键索引。for update 就不一样了，系统会认为接下来会更新数据，顺便会对主键索引上满足条件的索引加锁。

如果session A查询是 `select d from t where c = 5 lock in share mode;`  session B的`update t set d = d + 1 where id = 5;`  就会被阻塞了。

2. `update t set d = d + 1 where c = 5; ` 为什么会阻塞？

加锁原则中的优化2: 索引上等值查询，向右遍历时且最后一个值不满足等值条件的时候，next-key lock退化为间隙锁。加锁的范围会变为 (c, 10];  session c `insert into t values  (7,7,7);`  也会被阻塞



## 死锁

并发线程出现循环资源依赖，涉及的线程都在等待别的线程释放资源时，就会导致这几个线程都进入等待的状态。超时以后客户端会又重试机制，这时mysql的连接数就上来了，负载飙升。

**死锁处理策略**：

- 超时策略：`innodb_lock_wait_timeout` 默认50s
- 死锁检测：`innodb_deadlock_detect` 默认时开启的

**避免死锁的建议**：

- 通过两阶段锁协议我们知道：行锁是在事务提交的时候才会释放锁，要把最可能造成锁冲突、最可能影响并发度的锁尽量往后放
- 控制访问相同资源的并发事务量，比如：抢购商品分成10条记录，或放入队列

## 乐观锁

[乐观锁应用场景](https://segmentfault.com/a/1190000008935924)

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，不会上锁，但是更新时会判断在此期间有没有人更新这个数据。实现方式有两种：

- 使用数据版本(version)记录机制实现
- 使用时间戳

```sql
SELECT * FROM table_name WHERE ... FOR UPDATE。
```

select： 读锁，共享锁
update \ insert \ delete : 每次都会自己加排他锁

一个商品A, 库存有10个， 一百人来抢，不要超卖
update table set num=num-1 where num=10;

select num from table;
update table set num=num-1 where num=9;

## 悲观锁: 

锁的是索引， 如果没有索引，直接锁表。

总是假设最坏的情况，每次去拿数据时总会假设别人会修改，所以每次在拿数据时都会加锁。别人想拿这条数据就会阻塞直到他拿到锁，

### 共享锁

读取的任何行上设置共享模式锁定，其他会话可以读取行，但是在事务提交之前不能修改它们，如果这些行中的任何一个被尚未提交的另一个事务修改，则查询等待直到该事务结束，然后使用最新职

```sql
-- 5.7
SELECT * FROM table_name WHERE ... lock in share mode
-- 8.0
SELECT * FROM table_name WHERE ... for share
```

### 排他锁 

排他锁也叫写锁，简称x锁，原理：一个事务获取了一个数据行的排他锁，其他事务就不能再获取该行的其他锁（排他锁或者共享锁），即一个事务在读取一个数据行的时候，其他事务不能对该数据行进行增删改查。

子查询中的行不会被锁定，除非在子查询中也指定了锁

```sql
SELECT * FROM table_name WHERE ... FOR UPDATE。
```

注意点:
- 对于select语句，innodb不会加任何锁，也就是可以多个并发去进行select的操作，不会有任何的锁冲突，因为根本没有锁。
- 对于insert，update，delete操作，innodb会自动给涉及到的数据加排他锁，只有查询select需要我们手动设置排他锁。
- 共享锁和排他锁都是锁的行记录，意向共享锁和意向排他锁锁定的是表。

悲观锁，每次在拿数据都会上锁，其他session想拿这个数据就会被阻塞知道它拿到锁

**脏读**

脏数据：未提交的数据

脏读：一个事物读取到了另一个事物未提交的数据

脏读违背了事物的隔离性，关注一下innodb是如何隔离事务的。

现在不会见到脏读了，数据隔离级别要设置成 READ UNCOMMITTED级别才可以，现在默认级别是READ REAPEATABLE

那么READ UNCOMMITTED只有特殊场景才会遇到，如：slave

**不可重复读**

不可重读读是指：在一个事物内多次读取同一数据集合，在这个事物还没有结束时，另一个事物对该数据集合做了一些DML操作。这样就发生了同一事物内两次读取同一数据集合，数据不一致。

不可重复读和脏读的区别是，脏读是读未提交，而不可重复读的已经提交

next key lock算法下，不仅锁住扫描到的索引，还锁住了这些索引覆盖的范围，这个范围内的插入是不允许的，这样就避免了另外一个事物在这个范围内插入数据，导致多次读取数据不一致。

**阻塞**

一个事物中的锁需要等待另一个事物中的锁释放他所占的资源，这就是阻塞

**innodb_lock_wait_timeout** 用来控制等待的时间默认50秒

**innodb_rollback_on_timeout** 用来设置在等待超时是否对进行中的事物进行回滚。



为啥数据库CPU会飙升，真的是业务上涨导致的吗，考虑过死锁吗？如何避免死锁？ 什么是MDL锁？

关键字