【并发编程】深入理解Java并发之synchronized实现原理

深入解析Java中的synchronized关键字 接下来是偏向锁,我们还是用同样的代码即可,需要注意的是偏向锁必须在jvm启动后的一段时间才会运行,所以如果我们想打印偏向锁必须让线程休眠那么几秒,这里笔者就偷懒了一下,通过设置jvm参数。打印结果如下,我们只需关注第一行的object header,可以看到第一列的00000001,我们看到后3位为001,偏向锁标记为0,锁标记为01,001这就是我们说的无锁状态。上文讲解锁升级的之后,我们一直在说对象头的概念,所以为了能够直观的看到锁对象中对象头锁标记和锁状态的变化,我们这里引入一个jol工具。 阅读详情

一、synchronized 实现同步示例

public class MyThread extends Thread{

	private int count = 0;
	@ Override
	public synchronized void run() {
		for (int i = 0; i < 5; i++) {
			try {
				System.out.println("线程名:"+Thread.currentThread().getName() + ":" + (count++));
			} catch (InterruptedException e) {
					e.printStackTrace();
          	}
		}
	}
}
public class MyTest
	public static void main(String[] args) {
		MyThread myThread = new MyThread();
        Thread thread1 = new Thread( myThread, "SyncThread1");
     	Thread thread2 = new Thread( myThread, "SyncThread2");
        thread1.start();
    	thread2.start();
    }
}

在这里插入图片描述
分析:

通过new MyThread()创建了一个对象myThread,这时候堆中就存在了共享资源myThread,然后对myThread对象创建两个线程,那么thread1线程和thread2线程就会共享myThread。thread1.start()和thead2.start()开启了两个线程,CPU会随机调度这两个线程。假如thread1先获得synchronized锁,那么thread1先把run()执行完,然后释放锁。接着thread1获得synchronized锁,thread2把run()执行完,然后释放锁。

二、synchronized 典型错误示例

public class MyThread implements Runnable{
	private int count = 0;
	@ Override
	public synchronized void run() {
		for (int i = 0; i < 5; i++) {
			try {
				System.out.println("线程名:"+Thread.currentThread().getName() + ":" + (count++));
			} catch (InterruptedException e) {
					e.printStackTrace();
          	}
		}
	}
}
public class MyTest
	public static void main(String[] args) {
        System.out.println("使用关键字synchronized每次调用进行new SyncThread()");
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        Thread thread1 = new Thread(myThread1, "SyncThread1");
        Thread thread2 = new Thread(myThread2, "SyncThread2");
        thread1.start();
        thread2.start();
    }
}

在这里插入图片描述
分析:

通过new MyThread()创建了两个对象myThread1和myThread2,这时候堆中就存在了共享资源myThread1和myThread2,然后对myThread1对象创建一个线程thread1,对myThread2对象创建一个线程thread2,那么thread1线程就会共享myThread1,thread2线程就会共享myThread2,thread1.start()和thead2.start()开启了两个线程,CPU会随机调度这两个线程。那么thread1线程在执行的时候就会获取共享资源myThread1.run()的锁,thread2线程在执行的时候就会获取共享资源myThread2.run()的锁,显然两个线程共享的都不是同一个资源。

三、Java 对象头与 Monitor

下面先来了解一个概念Java对象头,这对深入理解synchronized实现原理非常关键。

在JVM中,对象在内存中的布局分为三块区域:对象头、实例数据、填充数据
在这里插入图片描述

  • 实例变量:存放类的属性数据信息,包括父类的属性信息.
  • 填充数据:由于虚拟机要求对象起始地址必须是8字节的整数倍。

而对于顶部,则是Java头对象,它实现synchronized的锁对象的基础,这点我们重点分析它,一般而言,synchronized使用的锁对象是存储在Java对象头里的,jvm中采用2个字来存储对象头(如果对象是数组则会分配3个字,多出来的1个字记录的是数组长度),其主要结构是由Mark Word 和 Class Metadata Address 组成,其结构说明如下表:
在这里插入图片描述
其中Mark Word字段的存储结构会根据锁状态而发生变化:
在这里插入图片描述
这里我们重点分析一下重量级锁也就是通常说synchronized的对象锁,锁标识位为10,其中指针指向的是monitor对象的起始地址。

每个对象都存在着一个 monitor 与之关联,对象与其 monitor 之间的关系有存在多种实现方式,如monitor可以与对象一起创建销毁或当线程试图获取对象锁时自动生成,但当一个 monitor 被某个线程持有后,它便处于锁定状态。

在Java虚拟机(HotSpot)中,monitor是由ObjectMonitor实现的,其主要数据结构如下(位于HotSpot虚拟机源码ObjectMonitor.hpp文件,C++实现的)

ObjectMonitor() {
    _header       = NULL;
    _count        = 0; //记录个数
    _waiters      = 0,
    _recursions   = 0;
    _object       = NULL;
    _owner        = NULL;
    _WaitSet      = NULL; //处于wait状态的线程,会被加入到_WaitSet
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;
    FreeNext      = NULL ;
    _EntryList    = NULL ; //处于等待锁block状态的线程,会被加入到该列表
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
  }

ObjectMonitor中有两个队列,_WaitSet(等待状态) 和 _EntryList(阻塞状态),都是用来保存ObjectWaiter对象列表( _WaitSet和 _EntryList中的线程都会被封装成ObjectWaiter对象),_owner指向持有ObjectMonitor对象的线程,当多个线程同时访问一段同步代码时,首先会进入_EntryList集合,当线程获取到对象的monitor 后进入_Owner区域,并把monitor中的owner变量设置为当前线程,同时monitor中的计数器count加1,若线程调用 wait() 方法,将释放当前持有的monitor,owner变量恢复为null,count自减1,同时该线程进入WaitSet集合中等待被唤醒。若当前线程执行完毕也将释放monitor(锁)并复位变量的值,以便其他线程进入获取monitor(锁)。
在这里插入图片描述

四、synchronized代码块底层原理

public class SyncCodeBlock {

   public int i;

   public void syncTask(){
       //同步代码库
       synchronized (this){
           i++;
       }
   }
}

编译上述代码并使用javap反编译后得到字节码如下(这里我们省略一部分没有必要的信息):

Classfile /Users/zejian/Downloads/Java8_Action/src/main/java/com/zejian/concurrencys/SyncCodeBlock.class
  Last modified 2017-6-2; size 426 bytes
  MD5 checksum c80bc322c87b312de760942820b4fed5
  Compiled from "SyncCodeBlock.java"
public class com.zejian.concurrencys.SyncCodeBlock
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
  //........省略常量池中数据
  //构造函数
  public com.zejian.concurrencys.SyncCodeBlock();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 7: 0
  //===========主要看看syncTask方法实现================
  public void syncTask();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=3, args_size=1
         0: aload_0
         1: dup
         2: astore_1
         3: monitorenter  //注意此处,进入同步方法
         4: aload_0
         5: dup
         6: getfield      #2             // Field i:I
         9: iconst_1
        10: iadd
        11: putfield      #2            // Field i:I
        14: aload_1
        15: monitorexit   //注意此处,退出同步方法
        16: goto          24
        19: astore_2
        20: aload_1
        21: monitorexit //注意此处,退出同步方法
        22: aload_2
        23: athrow
        24: return
      Exception table:
      //省略其他字节码.......
}
SourceFile: "SyncCodeBlock.java"

我们主要关注字节码中的如下代码

3: monitorenter  //进入同步方法
//..........省略其他  
15: monitorexit   //退出同步方法
16: goto          24
//省略其他.......
21: monitorexit //退出同步方法

从字节码中可知同步语句块的实现使用的是monitorenter 和 monitorexit 指令,其中monitorenter指令指向同步代码块的开始位置,monitorexit指令则指明同步代码块的结束位置,当执行monitorenter指令时,当前线程将试图获取 objectref(即对象锁) 所对应的 monitor 的持有权,当 objectref 的 monitor 的进入计数器为 0,那线程可以成功取得 monitor,并将计数器值设置为 1,取锁成功。如果当前线程已经拥有 objectref 的 monitor 的持有权,那它可以重入这个 monitor(关于重入性稍后会分析),重入时计数器的值也会加 1。倘若其他线程已经拥有 objectref 的 monitor 的所有权,那当前线程将被阻塞,直到正在执行线程执行完毕,即monitorexit指令被执行,执行线程将释放 monitor(锁)并设置计数器值为0 ,其他线程将有机会持有 monitor 。值得注意的是编译器将会确保无论方法通过何种方式完成,方法中调用过的每条 monitorenter 指令都有执行其对应 monitorexit 指令,而无论这个方法是正常结束还是异常结束。为了保证在方法异常完成时 monitorenter 和 monitorexit 指令依然可以正确配对执行,编译器会自动产生一个异常处理器,这个异常处理器声明可处理所有的异常,它的目的就是用来执行 monitorexit 指令。从字节码中也可以看出多了一个monitorexit指令,它就是异常结束时被执行的释放monitor 的指令。

五、synchronized方法底层原理

方法级的同步是隐式,即无需通过字节码指令来控制的,它实现在方法调用和返回操作之中。JVM可以从方法常量池中的方法表结构(method_info Structure) 中的 ACC_SYNCHRONIZED 访问标志区分一个方法是否同步方法。当方法调用时,调用指令将会 检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置,如果设置了,执行线程将先持有monitor(虚拟机规范中用的是管程一词), 然后再执行方法,最后再方法完成(无论是正常完成还是非正常完成)时释放monitor。在方法执行期间,执行线程持有了monitor,其他任何线程都无法再获得同一个monitor。如果一个同步方法执行期间抛 出了异常,并且在方法内部无法处理此异常,那这个同步方法所持有的monitor将在异常抛到同步方法之外时自动释放。

补充:“获取monitor” 在第四点提到过,就是把monitor中owner变量设置为当前线程,同时monitor中的计数器count加1

六、Java虚拟机对synchronized的优化

锁的状态总共有四种:无锁状态、偏向锁、轻量级锁、重量级锁。随着锁的竞争,锁可以从偏向锁升级到轻量级锁,再升级的重量级锁(自动的),但是锁的升级是单向的,也就是说只能从低到高升级,不会出现锁的降级。、

偏向锁
锁偏向是一种针对加锁操作的优化手段。它的核心思想是:如果一个线程获得了锁,那么锁就进入偏向模式。当这个线程再次请求锁时,无须再做任何同步操作。这样就节省了大量有关锁申请的操作,从而提高了程序性能。

因此,对于几乎没有锁竞争的场合,偏向锁有比较好的优化效果,因为连续多次极有可能是同一个线程请求相同的锁。而对于锁竞争比较激烈的场合,其效果不佳。因为在竞争激烈的场合,最有可能的情况是每次都是不同的线程来请求相同的锁。这样偏向模式会失效,因此还不如不启用偏向锁。

轻量级锁
倘若偏向锁失败,虚拟机并不会立即升级为重量级锁,它还会尝试使用一种称为轻量级锁的优化手段(1.6之后加入的),此时Mark Word 的结构也变为轻量级锁的结构。

轻量级锁能够提升程序性能的依据是“对绝大部分的锁,在整个同步周期内都不存在竞争”,注意这是经验数据。需要了解的是,轻量级锁所适应的场景是不同的线程交替执行同一同步块的场合,如果存在不同线程在同一时间访问同一锁的场合,就会导致轻量级锁膨胀为重量级锁。

自旋锁
轻量级锁失败后,虚拟机为了避免线程真实地在操作系统层面挂起,还会进行一项称为自旋锁的优化手段。这是基于在大多数情况下,线程持有锁的时间都不会太长,如果直接挂起操作系统层面的线程可能会得不偿失,毕竟操作系统实现线程之间的切换时需要从用户态转换到核心态,这个状态之间的转换需要相对比较长的时间,时间成本相对较高,因此自旋锁会假设在不久将来,当前的线程可以获得锁,因此虚拟机会让当前想要获取锁的线程做几个空循环(这也是称为自旋的原因),一般不会太久,可能是50个循环或100循环,在经过若干次循环后,如果得到锁,就顺利进入临界区。如果还不能获得锁,那就会将线程在操作系统层面挂起,这就是自旋锁的优化方式,这种方式确实也是可以提升效率的。最后没办法也就只能升级为重量级锁了。

重量级锁
上述已经讲得 fi~ 常 清楚了。

锁消除
消除锁是虚拟机另外一种锁的优化,这种优化更彻底,Java虚拟机在JIT编译时(可以简单理解为当某段代码即将第一次被执行时进行编译,又称即时编译),通过对运行上下文的扫描,去除不可能存在共享资源竞争的锁,通过这种方式消除没有必要的锁,可以节省毫无意义的请求锁时间,如下StringBuffer的append是一个同步方法,但是在add方法中的StringBuffer属于一个局部变量,并且不会被其他线程所使用,因此StringBuffer不可能存在共享资源竞争的情景,JVM会自动将其锁消除。

/**
 * Created by zejian on 2017/6/4.
 * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
 * 消除StringBuffer同步锁
 */
public class StringBufferRemoveSync {

    public void add(String str1, String str2) {
        //StringBuffer是线程安全,由于sb只会在append方法中使用,不可能被其他线程引用
        //因此sb属于不可能共享的资源,JVM会自动消除内部的锁
        StringBuffer sb = new StringBuffer();
        sb.append(str1).append(str2);
    }

    public static void main(String[] args) {
        StringBufferRemoveSync rmsync = new StringBufferRemoveSync();
        for (int i = 0; i < 10000000; i++) {
            rmsync.add("abc", "123");
        }
    }
}
Java synchronized(详细) 在Java中,`synchronized`关键字用于解决多线程并发访问共享资源时可能出现的线程安全问题。 阅读详情

相关推荐

【并发编程】并发编程的三大特性

可见性问题是基于CPU位置出现的,CPU处理速度非常快,相对CPU来说,去主内存获取数据这个事情太慢了,CPU就提供了L1,L2,L3的三级缓存,每次去主内存拿完数据后,就会存储到CPU的三级缓存,每次去三级缓存拿数据,效率肯定会提升。这就带来了问题,现在CPU都是多核,每个线程的工作内存(CPU三级缓存)都是独立的,会告知每个线程中做修改时,只改自己的工作内存,没有及时的同步到主内存,导致数据不一致问题。// ....System.out.println("t1线程结束");});

lxtx 979

java sync 实现原理_Synchronized 天天用,实现原理你懂吗?

来源:小小木的博客www.cnblogs.com/wyc1994666/p/11748212.htmlSynchronized 关键字算是Java的元老级锁了,一开始它撑起了Java的同步任务,其用法简单粗暴容易上手。但是有些与它相关的知识点还是需要我们开发者去深入掌握的。比如,我们都知道通过 Synchronized 锁来实现互斥功能,可以用在方法或者代码块上,那么不同用法都是怎么实现的,以及都...

weixin_32098191的博客 1654

Java 并发编程之synchronized

在并发编程中,多个线程访问同一个共享资源时,我们必须考虑如何维护数据的原子性。在JDK1.5之前,Java是依靠Synchronized关键字实现锁功能来做到这点的。Synchronized是JVM实现的一种内置锁,锁的获取和释放是由JVM隐式实现。到了JDK1.5版本,并发包中新增了Lock接口来实现锁功能,它提供了与Synchronized关键字类似的同步功能,只是在使用时需要显式获取和释放锁。

天天新知 1519

Java-synchronized实现详解(从Java到汇编)

synchronized作为java语言中的并发关键词,其在代码中出现的频率相当高频,大多数开发者在涉及到并发场景时,一般都会下意识得选取synchronized。

小海编码日记 1021

武汉理工大学 python实验三

请编一个程序,用户在同一行内输入两个整数,代表头和脚的数量,编程计算笼中各有多少只鸡和兔(假设鸡和兔都正常,无残疾),如无解则输出`“Data Error!题目为:今有物不知其数,三三数之剩二,五五数之剩三,七七数之剩二,问物几何?年前,《孙子算经》中记载一个有趣的问题:今有雉兔同笼,上有三十五头,下有九十四足,问雉兔各几何?有一座八层宝塔,每一层都有一些琉璃灯,每一层的灯数都是上一层的二倍,已知共有。编写一个宝塔上的琉璃灯的小程序,计算并输出每层各有多少盏琉璃灯。,如果有多个解,则分行输出,每行一个解;

2401_83472225的博客 5952

Matlab机械臂建模:机器人工具箱的使用&&导入自己的机械臂模型

本文主要介绍如何在matlab中建立机械臂模型(前提要下载了Robotics Toolbox机器人工具箱~),并进行基于正逆运动学计算的轨迹运动。对于已有的Solidworks机械臂三维模型,如何导入Matlab,并对其进行运动控制。

m0_46427461的博客 5万+

//Java并发编程深入理解synchronized与Lock接口的实现原理与应用场景

synchronized和Lock都是Java中强大的同步工具。选择哪一种取决于具体的应用需求。对于大多数标准的同步需求,synchronized因其简洁性和JVM的持续优化,往往是足够的。当需要更高级的功能,如灵活的锁操作、可中断性、公平性或有复杂的等待条件时,Lock接口则提供了更强大的解决方案。开发者应深入理解两者的底层原理和特性,根据实际场景做出最合适的选择,以构建高效、可靠的并发应用程序。

u013808580的博客 651

医学图像分割实战:基于TransUNet训练自己的眼底硬渗出物数据集(附完整代码)

本文详细介绍了基于TransUNet的眼底硬渗出物分割实战指南,涵盖数据预处理、模型调优、训练策略及性能优化等关键环节。通过代码复现和实验对比,展示了TransUNet在医学图像分割中的优势,为糖尿病视网膜病变的早期诊断提供技术支持。

weixin_42524708的博客 366

[书]java并发编程的艺术笔记

第1章 并发编程的挑战 1.多线程一定比单线程快? 不一定,如同在同时阅读两本书时的来回切换切换是会影响读书效率的,同样上下文切换也会影响多线程的执行速度. 并发执行的速度会比串行慢:这是因为线程有创建和上下文切换的开销. 2.如何减少上下文切换 减少上下文切换的方法有无锁并发编程(避免使用锁)、CAS算法(Java的Atomic包使用CAS算法来更新数据,而不需要加锁)、使用最少线程...

Ryze 750

从零构建DDS信号发生器:STM32 DAC与DMA的完美交响

本文详细介绍了如何利用STM32的DAC模块和DMA控制器从零构建高性能DDS信号发生器。通过深入解析DDS技术原理、STM32 DAC特性及DMA高效数据传输,提供了完整的波形生成算法、硬件电路设计和软件实现方案,帮助开发者掌握数字信号合成的核心技术。

tree8的博客 708

CodeBuddy Code CLI 常用工作流:17个实战场景全解析

CodeBuddy Code CLI 17个实战场景解析 本文详细介绍了CodeBuddy Code CLI在17个开发场景中的高效应用,包括: 快速理解新代码库 高效修复Bug 安全重构代码 使用子代理系统处理专业任务 Plan Mode安全分析 自动化测试处理 创建合并请求 文档生成与维护 图片内容分析 文件目录快速引用 每个场景都配有具体命令示例和最佳实践,帮助开发者提升工作效率。

简简单单Onlinezuozuo 1095

搞定高并发,岂能不懂Synchronized底层原理?

Synchronized 是 Java 中解决并发问题的一种最常用的方法,也是最简单的一种方法。本文作者将全面剖析 Synchronized 的底层原理。 Synchronized 的基本使用 Synchronized 的作用主要有三个: 确保线程互斥的访问同步代码 保证共享变量的修改能够及时可见 有效解决重排序问题 从语法上讲,Synchronized ...

勇往直前的专栏 575

BoT-SORT实战:手把手教你实现BoT-SORT训练和测试

文章目录摘要1、数据准备2、配置BoT-SORT环境2.1、获取代码2.2、创建虚拟环境2.3、安装必要的包2.3.1、安装pytorch2.3.2、安装cython2.3.3、安装Cython-bbox2.3.4、安装faiss2.3.5、安装其他的包3、训练3.1、生成REID数据集3.2、预训练模型3.2.1、ByteTrack预训练模型3.2.2、REID预训练模型3.3、开始训练4、如何更改FASTREID的BackBone?5、测试5.1、测试视频5.2、测试摄像头5.3、多类别测试 摘要 Bo

m0_47867638的博客 2302

Java并发编程——synchronized详解

介绍 synchronized 用处,三种使用方式及其原理

猫头夜鹰的小屋 479

SAP 系统间信任关系配置全攻略:从 SM59 到 SMT1 的实践与风险控制

本文介绍了在SAP系统间配置信任关系的详细流程与最佳实践。文章以SAP Gateway与后端系统架构为场景,从SM59创建RFC目的地开始,到SMT1建立信任关系,再到授权对象S_RFCACL的配置,提供了完整的操作指南。重点包括:使用标准命名规范创建专用RFC连接、通过向导完成系统间信任登记、严格控制S_RFCACL授权范围等。文中还分享了真实项目案例、可复用的检查清单以及常见问题的排查思路,帮助用户实现稳定可靠的跨系统无密码调用,同时确保安全性。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 328

YOLOv10改进 | 主干篇 | 引入FasterNet:Run, Don‘t Walk,追求更快的神经网络

本文引入了 FasterNet 作为 YOLOv10 的主干网络。通过 PConv 算子,我们有效降低了模型的计算冗余。对于追求极致推理速度的场景(如树莓派、Jetson Nano),该改进方案极具价值。建议在训练时配合混合精度训练 (AMP)进一步加速。

weixin_51988935的博客 605

synchronized原理剖析与优化视频教程

在本套课程中,我们将全面的讲解synchronized相关知识,从并发编程中的三个问题,到Java内存模型和synchronize如何保证三大特性,再到深入JVM源码分析synchronized原理,再到JDK6中对synchronized的优化,包含synchronized锁升级的过程,最后总结我们平时写代码如何对synchronized优化,写出保证共享数据安全,并且执行效率高的代码。

Blue92120的博客 575

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

网友:并发编程你都不会,还想进BATJ?学好并发,告别外包

前言: 在目前,并发编程是Java程序员最重要的技能之一,却不是最难掌握的一种技能。现在几乎100%的公司不但面试都必须问到并发编程,而且在日常工作和开发当中更是需要并发编程的使用,尤其是在互联网公司,对于并发编程的要求更高,并发编程能力已经成为职场敲门砖。 那么如何才能更好的学好并发编程呢?我们先来看一张对标阿里p7的思维导图: 只有结合JDK的源码来认识Java并发框架、线程池的实现原理,才能做到知其所以然,还要对原理的剖析不仅仅局限于Java层面,而是深入到JVM,甚至CPU层面来进行讲解: 为了

爱写代码的程序员 195

深度学习工具包 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")

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

2021大厂Java春招面试经历,值得收藏!

前言 其实前几篇文章已经写了好多有关于Spring源码的文章,事实上,很多同学虽然一直在跟着阅读、学习这些Spring的源码教程,但是一直都很迷茫,这些Spring的源码学习,似乎只是为了面试吹逼用,我大概问过一些同学,很多同学看了很长时间的Spring但是依旧不知道如何将这些学到的知识运用到实际的案例上! 其实这个问题很好解决,如果你在开发中很少能够遇见需要Spring扩展时,不妨把目光放到一些依托于Spring的项目,看看它们是如何运用Spring的扩展点的。对于Spring的学习,我认为最终真正学会的

碧海朝天素 125

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

68面试常问:面试官:对并发熟悉吗?说说Synchronized及实现原理

一、Synchronized的基本使用 Synchronized是Java中解决并发问题的一种最常用的方法,也是最简单的一种方法。 Synchronized的作用主要有三个: 确保线程互斥的访问同步代码 保证共享变量的修改能够及时可见 有效解决重排序问题。 从语法上讲,Synchronized总共有三种用法: 修饰普通方法 修饰静态方法 修饰代码块 接下来我就通过几个例子程序来说明一下这三种使用方式(为了便于比较,三段代码除了Sync...

AI乔治 231

Java 锁相关详解【二、synchronized:Java 内置锁的全方位解析】

本文全面解析Java的synchronized关键字,涵盖其语义、实现机制、优化策略及实践要点。作为Java内置锁,synchronized通过对象头Mark Word和Monitor机制实现互斥访问和内存可见性,经历了从偏向锁到重量级锁的升级过程以提高性能。文章详细介绍了JVM层面的字节码指令、锁状态转换和优化技术(如锁消除、粗化等),并针对死锁、锁竞争等常见问题提供解决方案。最后强调在现代JDK中,经过优化的synchronized已成为安全高效的同步工具,能满足大多数并发场景需求。

NeoLshu的博客 758

京东顶级面试官必问:Java多线程与并发系列有何关系区别在哪里?

前言 Java多线程与并发编程现在已经属于Java面试的重灾区,这个我们都是知道的,特别是第一轮面试经常被问到。 很多同学掌握不好主要就是两个点:对并发的体系化掌握不好,还有就是其中的技术深度点掌握不好。 为了方便大家更好的掌握好并发系列,也为了让知识更系统化,这里我单独把Java多线程与并发的整个系列一并罗列于此,希望对有用的人有用,也希望能帮助到更多的人。 完整版文章尾端获取! Java线程池的使用方式,及核心运行原理 FixedThreadPool SingleThreadExe...

m0_67322837的博客 584

并发系列之synchronized解析

多线程系列之synchronized解析1、synchronized简介2、synchronized实现原理2.1、对象锁(monitor)机制2.2、synchronized的happens-before关系2.3、锁获取和锁释放的内存语义3、synchronized优化4、一个例子2、往期佳文2.1、面试系列2.2、技术系列2.3、源码系列2.4、数据结构和算法系列2.5、多线程系列 1、synchronized简介        我

Java学习之乐的博客 380

打工人,从 JMM 透析 volatile 与 synchronized 原理

在面试、并发编程、一些开源框架中总是会遇到volatile与synchronized。synchronized如何保证并发安全?volatile语义的内存可见性指的是什么?这其...

张普的专栏 238

java并发编程

一、线程基础 Thread类: start():当调用start方法后,系统才会开启一个新的线程来执行用户定义的子任务,在这个过程中,会为相应的线程分配需要的资源。 run():当通过start方法启动一个线程之后,当线程获得了CPU执行时间,便进入run方法体去执行具体的任务。 sleep(1000):sleep相当于让线程睡眠,交出CPU,让CPU去执行其他的任务。 但是有一点要...

luffy 637

synchronized底层原理_天天都在用Synchronized,他的底层原理你了解吗

作者:liuxiaopeng来源:https://www.cnblogs.com/paddix/p/5367116.htmlSynchronized 的基本使用Synchronized 的作用主要有三个:确保线程互斥的访问同步代码保证共享变量的修改能够及时可见有效解决重排序问题从语法上讲,Synchronized 总共有三种用法:修饰普通方法修饰静态方法修饰代码块接下来我就通过几个例子程序来说明一...

weixin_39518840的博客 65
上一篇: 【秒杀系统】高并发编程入门学习
下一篇: Java多线程synchronized && Lock && volatile,看完这一篇就够了
后端漫漫
博客等级 码龄7年 297粉丝 132原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址