多线程基础——锁

城南孔乙己 城南孔乙己 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 2.4k累计阅读 2.4k平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄14年
关注
原创 最新推荐文章于 2026-07-03 11:22:03 发布 2.4k 阅读 AI 写同款· GEO 优化 ›
JAVA系列教程：多线程及锁 一.基本介绍 1.为什么需要多线程锁呢？ 当多个线程同时去访问某一共享资源时，就会出现资源之间的竞争，如果没有锁机制的保证，就可能会导致数据的不一致性 2.java内存模型 二.锁机制实现 1.使用synchronize关键字 a. 对静态方法加synchonize关键字 b. 静态代码块加synchronize关键字 c.普通方法加synchroni... 阅读详情

线程安全是程序设计中的术语，指某个函数、函数库在多线程环境中被调用时，能够正确地处理多个线程之间的全局变量，使程序功能正确完成。

假设有间银行只有 1000 元，而两个人同时提领 1000 元时就可能会拿到总计 2000 元的金额。为了避免这个问题，该间银行提款时应该使用互斥锁，即意味着针对同一个资源处理时，前一个人提领交易完成后才处理下一笔交易。但这种手法会使得效能降低。

线程安全的函数一般不应该修改全局对象。

锁的概念

在计算机科学中，锁是在执行多线程时用于强行限制资源访问的同步机制，即用于在并发控制中保证对互斥要求的满足。

互斥锁

互斥锁（英语：Mutual exclusion，缩写 Mutex）是一种用于多线程编程中，防止两条线程同时对同一公共资源（比如全局变量）进行读写的机制。该目的通过将代码切片成一个一个的临界区域（critical section）达成。

临界区域指的是一块对公共资源进行访问的代码，并非一种机制或是算法。一个程序、进程、线程可以拥有多个临界区域，但是并不一定会应用互斥锁。

一段代码（甲）正在分步修改一块数据。这时，另一条线程（乙）由于一些原因被唤醒。如果乙此时去读取甲正在修改的数据，而甲碰巧还没有完成整个修改过程，这个时候这块数据的状态就处在极大的不确定状态中，读取到的数据当然也是有问题的。更严重的情况是乙也往这块地方写数据，这样的一来，后果将变得不可收拾。因此，多个线程间共享的数据必须被保护。达到这个目的的方法，就是确保同一时间只有一个临界区域处于运行状态，而其他的临界区域，无论是读是写，都必须被挂起并且不能获得运行机会

乐观锁

在关系数据库管理系统里，乐观并发控制（又名“乐观锁”，Optimistic Concurrency Control，缩写“OCC”）是一种并发的方法。它假设多用户并发的事务在处理时不会彼此互相影响，各事务能够在不产生锁的情况下处理各自影响的那部分数据。在提交数据更新之前，每个事务会先检查在该事务读取数据后，有没有其他事务又修改了该数据。如果其他事务有更新的话，正在提交的事务会进行回滚。

乐观并发控制多数用于数据争用不大、冲突较少的环境中，这种环境中，偶尔回滚事务的成本会低于读取数据时锁定数据的成本，因此可以获得比其他并发控制方法更高的吞吐量。

乐观并发控制的事务包括以下阶段：

  • 读取：事务将数据读入缓存，这时系统会给事务分派一个时间戳。
  • 校验：事务执行完毕后，进行提交。这时同步校验所有事务，如果事务所读取的数据在读取之后又被其他事务修改，则产生冲突，事务被中断回滚。
  • 写入：通过校验阶段后，将更新的数据写入数据库。

乐观并发控制相信事务之间的数据竞争(data race)的概率是比较小的，因此尽可能直接做下去，直到提交的时候才去锁定，所以不会产生任何锁和死锁。但如果直接简单这么做，还是有可能会遇到不可预期的结果，例如两个事务都读取了数据库的某一行，经过修改以后写回数据库，这时就遇到了问题。

Java中的乐观锁基本都是通过 CAS 操作实现的，CAS 是一种更新的原子操作，比较当前值跟传入 值是否一样，一样则更新，否则失败。

CAS

比较并交换(compare and swap, CAS)，是原子操作的一种，可用于在多线程编程中实现不被打断的数据交换操作，从而避免多线程同时改写某一数据时由于执行顺序不确定性以及中断的不可预知性产生的数据不一致问题。 该操作通过将内存中的值与指定数据进行比较，当数值一样时将内存中的数据替换为新的值。

在使用上，通常会记录下某块内存中的旧值，通过对旧值进行一系列的操作后得到新值，然后通过CAS操作将新值与旧值进行交换。如果这块内存的值在这期间内没被修改过，则旧值会与内存中的数据相同，这时CAS操作将会成功执行 使内存中的数据变为新值。如果内存中的值在这期间内被修改过，则一般来说旧值会与内存中的数据不同，这时CAS操作将会失败，新值将不会被写入内存。

  • 应用

在应用中CAS可以用于实现无锁数据结构，常见的有无锁队列（先入先出）以及无锁栈（先入后出）。对于可在任意位置插入数据的链表以及双向链表，实现无锁操作的难度较大。

  • ABA问题

ABA问题是无锁结构实现中常见的一种问题，可基本表述为：

  1. 进程P1读取了一个数值A
  2. P1被挂起(时间片耗尽、中断等)，进程P2开始执行
  3. P2修改数值A为数值B，然后又修改回A
  4. P1被唤醒，比较后发现数值A没有变化，程序继续执行。

对于P1来说，数值A未发生过改变，但实际上A已经被变化过了，继续使用可能会出现问题。

JAVA，sun.misc.Unsafe提供了compareAndSwap系列函数

悲观锁

在关系数据库管理系统里，悲观并发控制（又名“悲观锁”，Pessimistic Concurrency Control，缩写“PCC”）是一种并发控制的方法。它可以阻止一个事务以影响其他用户的方式来修改数据。如果一个事务执行的操作读某行数据应用了锁，那只有当这个事务把锁释放，其他事务才能够执行与该锁冲突的操作。

悲观并发控制主要用于数据争用激烈的环境，以及发生并发冲突时使用锁保护数据的成本要低于回滚事务的成本的环境中。

悲观并发控制实际上是“先取锁再访问”的保守策略，为数据处理的安全提供了保证。但是在效率方面，处理加锁的机制会让数据库产生额外的开销，还有增加产生死锁的机会；另外，在只读型事务处理中由于不会产生冲突，也没必要使用锁，这样做只能增加系统负载；还有会降低了并行性，一个事务如果锁定了某行数据，其他事务就必须等待该事务处理完才可以处理那行数据。

java中的悲观锁就是Synchronized,AQS框架下的锁则是先尝试CAS乐观锁去获取锁，获取不到， 才会转换为悲观锁，如 RetreenLock

自旋锁

自旋锁是计算机科学用于多线程同步的一种锁，线程反复检查锁变量是否可用。由于线程在这一过程中保持执行，因此是一种忙等待。一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁。

自旋锁避免了进程上下文的调度开销，因此对于线程只会阻塞很短时间的场合是有效的。因此操作系统的实现在很多地方往往用自旋锁。Windows操作系统提供的轻型读写锁（SRW Lock）内部就用了自旋锁。显然，单核CPU不适于使用自旋锁，这里的单核CPU指的是单核单线程的CPU，因为，在同一时间只有一个线程是处在运行状态，假设运行线程A发现无法获取锁，只能等待解锁，但因为A自身不挂起，所以那个持有锁的线程B没有办法进入运行状态，只能等到操作系统分给A的时间片用完，才能有机会被调度。这种情况下使用自旋锁的代价很高。

获取、释放自旋锁，实际上是读写自旋锁的存储内存或寄存器。因此这种读写操作必须是原子的。通常用test-and-set等原子操作来实现。

如果持有锁的线程执行的时间超过自旋等待的最大时间扔没有释放锁，就会导致其它争用锁 的线程在最大等待时间内还是获取不到锁，这时争用线程会停止自旋进入阻塞状态。

自旋锁尽可能的减少线程的阻塞，这对于锁的竞争不激烈，且占用锁时间非常短的代码块来 说性能能大幅度的提升，因为自旋的消耗会小于线程阻塞挂起再唤醒的操作的消耗，这些操作会导致线程发生两次上下文切换！

但是如果锁的竞争激烈，或者持有锁的线程需要长时间占用锁执行同步块，这时候就不适合使用自旋锁了，因为自旋锁在获取锁前一直都是占用 cpu 做无用功，同时有大量线程在竞争一个锁，会导致获取锁的时间很长，线程自旋的消耗大于线程阻塞挂起操作的消耗， 其它需要 cup 的线程又不能获取到 cpu，造成 cpu 的浪费。所以这种情况下我们要关闭自旋锁；

适应性自旋锁

自旋锁的目的是为了占着 CPU 的资源不释放，等到获取到锁立即进行处理。但是如何去选择 自旋的执行时间呢？如果自旋执行时间太长，会有大量的线程处于自旋状态占用 CPU 资源，进而 会影响整体系统的性能。因此自旋的周期选的额外重要！

线程自旋是需要消耗 cup 的，说白了就是让 cup 在做无用功，如果一直获取不到锁，那线程 也不能一直占用 cup 自旋做无用功，所以需要设定一个自旋等待的最大时间。

JVM 对于自旋周期的选择，jdk1.5 这个限度是一定的写死的，在 1.6 引入了适应性自旋锁，适应 性自旋锁意味着自旋的时间不在是固定的了，而是由前一次在同一个锁上的自旋时间以及锁的拥 有者的状态来决定，基本认为一个线程上下文切换的时间是最佳的一个时间，同时 JVM 还针对当 前 CPU 的负荷情况做了较多的优化，如果平均负载小于 CPUs 则一直自旋，如果有超过(CPUs/2) 个线程正在自旋，则后来线程直接阻塞，如果正在自旋的线程发现 Owner 发生了变化则延迟自旋 时间（自旋计数）或进入阻塞，如果 CPU 处于节电模式则停止自旋，自旋时间的最坏情况是 CPU 的存储延迟（CPU A 存储了一个数据，到 CPU B 得知这个数据直接的时间差），自旋时会适当放 弃线程优先级之间的差异。

可重入锁

计算机科学中，可重入互斥锁（英语：reentrant mutex）是互斥锁的一种，同一线程对其多次加锁不会产生死锁。可重入互斥锁也称递归互斥锁（英语：recursive mutex）或递归锁（英语：recursive lock）。

如果对已经上锁的普通互斥锁进行“加锁”操作，其结果要么失败，要么会阻塞至解锁。而如果换作可重入互斥锁，当且仅当尝试加锁的线程就是持有该锁的线程时，类似的加锁操作就会成功。可重入互斥锁一般都会记录被加锁的次数，只有执行相同次数的解锁操作才会真正解锁。

递归互斥锁解决了普通互斥锁不可重入的问题：如果函数先持有锁，然后执行回调，但回调的内容是调用它自己，就会产生死锁。

在 JAVA 环境下 ReentrantLock 和 synchronized 都是 可重入锁

公平锁

公平锁是指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。公平锁的优点是等待锁的线程不会饿死。缺点是整体吞吐效率相对非公平锁要低，等待队列中除第一个线程以外的所有线程都会阻塞，CPU唤醒阻塞线程的开销比非公平锁大。

非公平锁

非公平锁是多个线程加锁时直接尝试获取锁，获取不到才会到等待队列的队尾等待。但如果此时锁刚好可用，那么这个线程可以无需阻塞直接获取到锁，所以非公平锁有可能出现后申请锁的线程先获取锁的场景。非公平锁的优点是可以减少唤起线程的开销，整体的吞吐效率高，因为线程有几率不阻塞直接获得锁，CPU不必唤醒所有线程。缺点是处于等待队列中的线程可能会饿死，或者等很久才会获得锁。

ReentrantLock 在构造函数中提供了 是否公平锁的初始化方式，默认为非公平锁。非公平锁实际执行的效率要远远超出公平锁，除非 程序有特殊需要，否则最常用非公平锁的分配机制

1. 非公平锁性能比公平锁高 5~10 倍，因为公平锁需要在多核的情况下维护一个队列

2. Java 中的 synchronized 是非公平锁，ReentrantLock 默认的 lock()方法采用的是非公平锁

排他锁

排他锁（Exclusive Locks，简称X锁），又称为写锁、独占锁，在数据库管理上，是锁的基本类型之一。若事务T对数据对象A加上X锁，则只允许T读取和修改A，其他任何事务都不能再对A加任何类型的锁，直到T释放A上的锁。这就保证了其他事务在T释放A上的锁之前不能再读取和修改A。

ReentrantLock 就是以独占方式实现的互斥锁

共享锁

共享锁是指该锁可被多个线程所持有。如果线程T对数据A加上共享锁后，则其他线程只能对A再加共享锁，不能加排它锁。获得共享锁的线程只能读数据，不能修改数据。

java 的并发包中提供了 ReadWriteLock，读-写锁。它允许一个资源可以被多个读操作访问， 或者被一个 写操作访问，但两者不能同时进行。

读写锁

为了提高性能，Java 提供了读写锁，在读的地方使用读锁，在写的地方使用写锁，灵活控制，如 果没有写锁的情况下，读是无阻塞的,在一定程度上提高了程序的执行效率。

读写锁分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由 jvm 自己控制的。

读锁

如果代码只读数据，可以很多人同时读，但不能同时写，那就上读锁

写锁

如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。

总之，读的时候上 读锁，写的时候上写锁！

Java 中 读 写 锁 有 个 接 口 java.util.concurrent.locks.ReadWriteLock ， 也 有 具 体 的 实 现 ReentrantReadWriteLock。

锁优化

减少锁持有时间

只用在有线程安全要求的程序上加锁

减小锁粒度

将大对象（这个对象可能会被很多线程访问），拆成小对象，大大增加并行度，降低锁竞争。 降低了锁的竞争，偏向锁，轻量级锁成功率才会提高。最典型的减小锁粒度的案例就是 ConcurrentHashMap。

锁分离

最常见的锁分离就是读写锁 ReadWriteLock，根据功能进行分离成读锁和写锁，这样读读不互 斥，读写互斥，写写互斥，即保证了线程安全，又提高了性能。读写分离思想可以延伸，只要操作互不影响，锁就可以分离。比如 LinkedBlockingQueue 从头部取出，从尾部放数据。

锁粗化

通常情况下，为了保证多线程间的有效并发，会要求每个线程持有锁的时间尽量短，即在使用完 公共资源后，应该立即释放锁。但是，凡事都有一个度，如果对同一个锁不停的进行请求、同步 和释放，其本身也会消耗系统宝贵的资源，反而不利于性能的优化 。

锁消除

锁消除是在编译器级别的事情。在即时编译器时，如果发现不可能被共享的对象，则可以消除这 些对象的锁操作，多数是因为程序员编码不规范引起。

文献

维基百科_锁

维基百科_互斥锁

维基百科_乐观锁

维基百科_悲观锁

维基百科_自旋锁

维基百科_可重入锁

不可不说的Java“锁”事

Java核心知识点整理.pdf

收录于
Java 多线程与高并发

当前文章被收录于：

Java 多线程与高并发
18 篇文章 0 人学习

个人对Java多线程的理解所写的学习笔记，只能当作参考。

订阅专栏 查看详情
标签
#线程安全 #thread #java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
《算法零基础100讲》之 第74讲：多线程编程中的锁优化 通过上述示例，展示了如何在多线程编程中进行锁优化。这些示例涵盖了使用lock关键字、Monitor类和类进行同步控制。希望这些示例能帮助你更好地理解和应用锁优化策略。 阅读详情

相关推荐

WinForm布局

登录模板页面UILoginForm

m0_71541781的博客 470

多线程中的锁

多线程锁总结

qq_36419801的博客 2001

从零搭建 AI 运维 Agent：告警自动诊断 + 修复的完整技术方案

适合读者：管理 5-50 台服务器的运维/SRE 工程师、技术负责人 技术栈：FastAPI + React + PostgreSQL + Redis + DeepSeek 关键词：AI运维、AIOps、自动化运维、智能告警、告警修复、Runbook自动化、DevOps、SRE、DeepSeek运维

weixin_38359457的博客 1640

【阿飞算法】多线程与锁

进程来对应一个程序，每个进程对应一定的内存地址空间，并且只能使用它自己的内存空间，各个进程间互不干扰 这就是并发，能够让操作系统从宏观上看起来同一个时间段有多个任务在执行。换句话说，进程让操作系统的并发成为了可能。让一个线程去执行一个子任务，这样一个进程就包括了多个线程，每个线程负责一个独立的子任务，这样在用户点击按钮的时候，就可以暂停获取图像数据的线程，让UI线程响应用户的操作，响应完之后再切换回来，让获取图像的线程得到CPU资源 线程和进程有什么区别？ 一个进程是一个独立(self contained)

wat1r的博客 824

龙迅LT9611UXC芯片简介：Dual-Port MIPI DSI/CSI to HDMI2.0 with Audio

龙迅半导体推出的LT9611UXC是一款高性能MIPI转HDMI2.0转换器，支持DSI/CSI接口转换，兼容多种视频格式（RGB/YCbCr），最高支持4K@60Hz输出。该芯片集成音频处理（I2S/SPDIF）、色彩空间转换和3D功能，适用于机顶盒、电视盒子等消费电子及车载设备。提供工业级（-40℃~+85℃）和车规级（AEC-Q100认证）版本，采用QFN64封装。

MB16698594834的博客 1334

PX4｜Gazebo模型加载失败排查指南：从环境变量到资源路径的全面解析

本文针对PX4与Gazebo联合仿真中常见的'Unable to get model name'错误，提供了从环境变量配置、资源路径排查到网络访问问题的全面解决方案。详细解析了GZ_SIM_RESOURCE_PATH等关键变量的作用与设置方法，并给出了离线模型库部署等一劳永逸的修复指南，帮助开发者彻底解决无人机模型加载失败问题。

weixin_29243063的博客 1230

03多线程常见锁

1公平锁、非公平锁 概念：所谓公平锁，就是多个线程按照申请锁的顺序来获取锁，类似排队，先到先得。而非公平锁，则是多个线程抢夺锁，会导致优先级反转或饥饿现象 区别： 公平锁在获取锁时先查看此锁维护的等待队列，为空或者当前线程是等待队列的队列，则直接占有锁，否则插⼊到等待队列，FIFO原则。 非公平锁比较粗鲁，上来直接先尝试占有锁，失败则采⽤公平锁方式。非公平锁的优点是吞吐量比公平锁更大。 synchronized 和 juc.ReentrantLock 默认都是非公平锁。ReentrantLock 在..

技术改变世界 3452

AUTOSAR汽车电子嵌入式编程精讲300篇-基于加密算法的车载CAN总线安全通信

随着科学技术的不断更新和社会文明的不断进步，汽车已经走入寻常百姓家， 成为当代社会必不可少的交通工具。伴随着互联网技术的飞速发展，汽车也不再 是一个简单的交通工具，已经逐渐发展成为一个集出行、通信、娱乐等功能于一 身的综合智能体，进而推动了车联网产业的蓬勃发展。车联网是在传统汽车的框架上安装了传感器、执行器、控制器等分布式和集 中式控制器，使汽车具备环境感知、协同控制、优化执行等功能，并通过网络技 术实现与车外环境的信息共享，给驾驶带来方便的同时也终将成为可以替代人操 作的新一代汽车[1-3]。

getusushu的博客 2591

专题2_并发：多线程、锁基础

多线程、并发、synchronized锁

2403_88625492的博客 1684

实战：RK3568 Android14 调试 ES8388 音频驱动 (MIC 篇)

这个板子的MIC设计使用了硬件自动切换方案，极大简化了软件层面的逻辑。我们不需要根据耳机插拔事件去编写复杂的路由切换代码，只需要守住 LIN1/RIN1 这一个入口，配置好增益，剩下的交给那颗 SGM3157 芯片即可。祝您的录音功能调试顺利！

qq_33427070的博客 1680

工业相机，大恒，面振相机8脚电源线和I/O触发接口线，颜色和接法说明和触发软件设定

上图： 说明一下，工业相机有TTL逻辑电平触发，也有光耦触发等。 这里一般我们用电路板驱动，就用GPIO触发模式， 这里，准备了两个GPIO触发模式，为LINE2,LINE3都可以选择，然后有一个GPIO_GND 如果，你只有一个触发接口，那么如图，选两个就好了。 实际接法如图。 ...

山云的专栏 1万+

Java 基础之多线程与锁：全面解析与深入探讨

多线程是指在一个程序中可以同时运行多个线程，每个线程都有自己独立的执行路径和程序计数器，但它们共享同一进程的资源，如内存空间、文件句柄等。与单线程程序相比，多线程程序能够在同一时间内处理多个任务，提高程序的执行效率和响应性。例如，在一个图形用户界面（GUI）应用程序中，可以使用一个线程来处理用户界面的交互事件，如按钮点击、文本输入等，另一个线程负责后台数据的加载和处理。这样，即使在数据处理过程中，用户界面也不会出现卡顿，从而提供更好的用户体验。

qq_25699299的博客 684

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0， 兼容Win7/Win10/WinXP，解压就可用。

Java多线程(一)——线程基础和锁锁锁

目录 Java多线程(一) 一、线程的定义 二、Synchronize线程同步 三、偏向锁、自旋锁、重量级锁 四、volatile关键字 4.1.普通变量运算的物理意义 4.2.有无解决的方案 4.3.volatile的几个特性（参考https://www.cnblogs.com/kubidemanong/p/9505944.html） 五、Compare And Swap无锁自旋优化技术和ABA版本号机制 5.1.CAS操作原理 5.2.atomic包

qq_42058242的博客 235

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android：LinePhone3.2.7(最新版本)，官网地址：http://www.linphone.org/

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

多线程锁基础

本文介绍了C++多线程编程中常用的锁机制

优快云_RTKLIB的博客 620

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面，电脑运行连游戏界面都一样大小，很怀旧，很真实，（英文版）强烈推荐，很小的文件，很难才找到的。

多线程 循环 锁_多线程基础

一．线程的生命周期线程的状态可以分为6个，这几个状态之间互相转换，具体如下图所示，生命周期的看似简单无用，但是实际上很多机制的设计上都是用到了生命周期，我们常见的在生命周期不同的阶段做一些事情，这只是简单的使用，对于生命周期还可以有更巧妙的使用，比如我们常用的调度线程池ScheduledThreadPool,可以执行一次性任务，也可以执行周期任务，那怎么让有的任务只执行一次，有的任务可以...

weixin_36211712的博客 586

【Java 基础】21 多线程同步与锁

多线程编程中，确保线程安全是至关重要的！通过合理使用 synchronized 关键字、volatile 关键字以及 ReentrantLock 等锁机制，可以有效地保护共享资源，避免数据不一致和竞态条件等问题。合理的同步机制不仅能够提高程序的性能，还能够确保程序的正确性。

好久不见的流星 1199

多线程与高并发（1）- 线程基础、并发特性、锁、JUC工具

文章目录第一章、线程基础知识一、基础概念1、什么是程序？2、什么是进程？3、什么是线程？4、什么是线程的切换（Context Switch）？5、单核CPU 设定多线程是否有意义？6、工作线程数是不是设置的越大越好？7、工作线程数（线程池中线程数量）设多少合适？二、创建线程的3 种方法1、继承Thread类 重写run方法2、实现Runnable接口 重写run方法3、实现Callable 重写call方法，配合FutureTask4、基于线程池构建线程三、线程状态四、线程的常用方法1、获取当前线程2、线程

qq_32091929的博客 1622

Java多线程基础干货，线程与锁！！

一、线程的基本概念 1.1 单线程 简单的说，单线程就是进程中只有一个线程。单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的必须处理好，后面的才会执行。 Java示例： public class SingleThread { public static void main(String[] args) { for (int i = 0; i &lt; 10000; i+...

qq_39662660的博客 348

JAVA多线程基础：锁的优化方式总结

1.避免死锁 场景模拟 有2个小孩，A和B，A拿着B的玩具，B拿着A的零食，A对B说，你先把零食还给我，我才把玩具还给你，B不干，于是对A说，你先把玩具给我，我才把零食还给你，于是陷入了僵持，这就是死锁，死锁的场景也有可能是多个小孩 出现的条件 互斥条件：一个资源每次只能被一个进程使用（B的玩具，被A拿来完，其他人就不能玩了） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放（A拿着B的玩具，不还零食不放手） 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺（来个大人，强行抢了

yuanyuneixin1的专栏 231

JDK系列09：Java多线程基础，创建线程、锁、volatile、synchronized底层实现

文章摘要： 本文深入解析Java多线程核心知识，涵盖线程生命周期、6种创建方式（含继承Thread、实现Runnable、Callable+FutureTask、线程池等），对比优劣及适用场景。重点剖析并发三大问题（原子性、可见性、有序性）及解决方案，详解volatile关键字的可见性与禁止指令重排特性，并强调其不保证原子性的特点。

深耕 Java 后端与企业级软件架构设计，专注微服务、分布式系统、大模型 AI 应用架构落地。 488

【面试八股文 - java基础 - 多线程 - 锁】

文章目录前言一、 悲观锁二、乐观锁三、lock1、reentrantlock2、四、死锁总结 前言 自旋锁，偏向锁，轻量级锁，重量级锁 一、 悲观锁 synchronized 二、乐观锁 CAS AQS 三、lock 1、reentrantlock segment concurrentHashMap 2、 四、死锁 总结 ...

破晓星芒的博客 484

Java多线程与锁基础

多线程 概念 **进程与线程：**进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。 线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源。因为某些资源共用，无须重新加载，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。 多线程就是多个线程同时运行或交替运行，多线程可以充

weixin_44517209的博客 273

Python-多线程基础(线程,锁,通讯,线程池)

现在的操作系统大多采用时间片轮转的方式工作，需要频繁的切换进程，由于每个进程都占有一份独立的内存空间，所以每次切换进程时都需要切换内存空间（程序上下文），这将造成很大的开销，此时操作系统的响应速度很慢，为了解决操作系统响应速度慢的问题，操作系统引入了更轻量的进程——线程，因为线程不占有内存空间，它包括在进程的内存空间中，共享进程的资源，所以切换线程的开销要小很多，又由于线程相比进程更加轻量，操作系统可以启动更多的线程来执行任务（程序段），这进一步提高了操作系统的并发能力。

weixin_45203607的博客 1829

java基础| 多线程基础四：显示锁详解

显示锁 只要实现了Lock接口的锁都叫显示锁。锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁能够防止多个线程同时访问共享资源（但是有些锁可以允许多个线程并发的访问共享资源，比如读写锁）。在Lock接口出现之前，Java程序是靠synchronized关键字实现锁功能的，而Java SE 5之后，并发包中新增了Lock接口（以及相关实现类）用来实现锁功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需要显式地获取和释放锁。虽然它缺少了（通过synchroniz...

KevinBrain的博客 330
上一篇： 多线程基础——API
下一篇： 多线程安全——synchronized锁升级
点赞 1
评论 0
书签 书签 9
城南孔乙己
城南孔乙己
博客等级 码龄14年 7粉丝 19原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值