同步、异步、类锁、对象锁

数据库崩溃恢复机制:REDO日志与UNDO日志详解 在数据库管理系统中,事务的持久性和一致性是至关重要的。为了保证在系统崩溃或发生故障时数据不会丢失,数据库引入了恢复机制。其中,REDO日志和UNDO日志是两种关键的恢复技术。本文将详细描述这两种日志的作用、工作原理以及它们在数据库崩溃恢复中的应用。 阅读详情

同步

一个任务的执行,需要依赖另一个任务的完成。
标准的程序执行流程就是同步的,只有上一个函数执行完成,下一个函数才可以开始执行,这就是依赖关系

异步

一个任务的执行,不需要依赖另一个任务的完成。
并发的概念,只需要告诉另一个任务需要干什么,它会直接去执行

对象锁:只有竞争同一个对象的时候

  • synchronized修饰非静态方法、代码块synchronized (this)、synchronized (非this对象)线程要执行对应的同步代码,需要获取对象锁

锁住方法

先展示一个没有锁的例子,他的输出结果根据代码可以知道,因为我们实例化了一个对象,然后先开启了一个线程传了一个参数a过去,执行到System.out.println("a arrived");他就开始睡眠2s,于此同时又开启了另一个线程,同样调用的是同一对象的同一个方法,传递了b过去,所以出现下面这个结果

public class main {

    public static void main(String[] args) throws IOException {
        person p = new person();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.addstr("a");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.addstr("b");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        }
    }


class person{
    private int number = 0;
    public void addstr(String string) throws InterruptedException {
        if (string.equals("a")) {
            number = 100;
            System.out.println("a arrived");
            Thread.sleep(2000);
        }else {
            number = 200;
            System.out.println("b arrived");
            }
        System.out.println(string + " number=" + String.valueOf(number));
        }
    }

输出结果:

a arrived
b arrived
b number=200
a number=200

稍作更改给addstr方法加上锁,这时候多线程竞争同一个对象的带锁的方法时,就要按顺序来,要等上一个调用释放锁

class person{
    private int number = 0;
    synchronized public void addstr(String string) throws InterruptedException {
        if (string.equals("a")) {
            number = 100;
            System.out.println("a arrived");
            Thread.sleep(2000);
        }else {
            number = 200;
            System.out.println("b arrived");
            }
        System.out.println(string + " number=" + String.valueOf(number));
        }
    }

还有一种情况就是,锁住一个类的两个方法,两个线程同时调用锁住的不同对象,这种情况,经过测试,输出结果显示,执行第二个被锁住的方法也需要等待,也就是一个类内,使用一个锁,锁住一个或多个方法。

        person p = new person();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.printA(string);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.printB(string);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        }
    }


class person{
    private int number = 0;
    synchronized public void printA(String string) throws InterruptedException {
        System.out.println("A 进入线程!");
        Thread.sleep(2000);
        System.out.println("A 离开线程!");
        }
    
    synchronized public void printB(String string) throws InterruptedException {
        System.out.println("B 进入线程!");
        System.out.println("B 离开线程!");
        }
}

输出结果:

A 进入线程!
A 离开线程!
B 进入线程!
B 离开线程!

synchronized (this)

再次对上面的person类稍作修改,我们锁住一个代码块,同样的当多个线程竞争同一个对象的这个代码块时需要按照锁的规矩来,上一个释放,下一个才可以使用,输出结果同上

class person{
    private int number = 0;
    public void addstr(String string) throws InterruptedException {
        synchronized(this) {
        if (string.equals("a")) {
            number = 100;
            System.out.println("a arrived");
            Thread.sleep(2000);
        }else {
            number = 200;
            System.out.println("b arrived");
            }
        System.out.println(string + " number=" + String.valueOf(number));
        }
        }
    }

这里需要注意一下,因为多线程只有竞争这个代码块的内容才是使用锁的规矩,也就是这个代码块上面、下面都是不同步的,修改一下代码,这个这个同步代码块上面、下面加上两句输出System.out.println(string + "来了");、System.out.println(string + " number=" + String.valueOf(number));,这个时候输出结果有下面两种结果。首先解释一个b来了的输出,因为System.out.println(string + "来了");这一句没有锁,所以在第一个带有参数a睡眠的时候,第二个线程运行到这里输出完b来了,它就在这里等着,等第一个线程释放了锁,它才能继续执行。至于结果有两种,则是因为另外一个输出语句System.out.println(string + " number=" + String.valueOf(number));没有上锁,完全根据谁快、谁执行,或者并发执行都是可以的

class person{
    private int number = 0;
    public void addstr(String string) throws InterruptedException {
        System.out.println(string + "来了");
        synchronized(this) {
        if (string.equals("a")) {
            number = 100;
            System.out.println("a arrived");
            Thread.sleep(2000);
        }else {
            number = 200;
            System.out.println("b arrived");
            }
        }
        System.out.println(string + " number=" + String.valueOf(number));
        }
    }

输出结果:

a来了
a arrived
b来了
b arrived
a number=100
b number=200

或者

a来了
a arrived
b来了
b arrived
b number=200
a number=200

同样的,synchronized (this)也存在同一个类中,使用一个锁锁住一个或多个代码块,但是代码块上下是不同步的

class person{
    public String son;
    public person(String son) {
        this.son = son;
    }
    private int number = 0;
    synchronized public void printA(String string) throws InterruptedException {
        System.out.println("A 进入线程!");
        Thread.sleep(2000);
        System.out.println("A 离开线程!");
        }
    
    public void printB(String string) throws InterruptedException {
        System.out.println("B ready!");
        synchronized (this) {
        System.out.println("B 进入线程!");
        System.out.println("B 离开线程!");
        }
    }

输出结果:

A 进入线程!
B ready!
A 离开线程!
B 进入线程!
B 离开线程!

synchronized (非this对象)

只要多线程访问的对象带有被锁住的对象,并且是同一个,就需要按照锁的规则来,就像下面的例子,虽然实例化了两个不同的对象,但是他们访问的都是同一个String对象,就有竞争关系。其实可以被锁住的对象就像一个标记,任何线程使用了这个被锁住的对象,就相当于被标记了,被标记的线程执行到synchronized声明的地方,就要按顺序来,不存在并发进行

public static void main(String[] args) throws IOException {
        String string = "son";
        person p = new person(string);
        person p1 = new person(string);
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.addstr("a");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p1.addstr("b");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        }
    }


class person{
    public String son;
    public person(String son) {
        this.son = son;
    }
    private int number = 0;
    public void addstr(String string) throws InterruptedException {
        System.out.println(string + "来了");
        synchronized(son) {
        if (string.equals("a")) {
            number = 100;
            System.out.println("a arrived");
            Thread.sleep(2000);
        }else {
            number = 200;
            System.out.println("b arrived");
            }
        }
        System.out.println(string + " number=" + String.valueOf(number));
        }
    }

类锁

  • synchronized修饰静态方法、synchronized(类.class),锁的是对应的类,需要获取类锁
    类锁其实也是使用对象锁,当加载一个class文件时,会创建一个java.lang.Class类的实例,锁一个类的时候就是锁住java.lang.Class类的实例

下面这个例子,是对象锁,使用不同person对象,即使用了不同的锁锁住person对象

        String string = "son";
        person p = new person(string);
        person p1 = new person(string);
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.printA(string);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p1.printB(string);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        }
    }


class person{
    public String son;
    public person(String son) {
        this.son = son;
    }
    private int number = 0;
    synchronized public  void printA(String string) throws InterruptedException {
        System.out.println("A 进入线程!");
        Thread.sleep(2000);
        System.out.println("A 离开线程!");
        }
    
    synchronized public  void printB(String string) throws InterruptedException {
        System.out.println("B ready!");
        System.out.println("B 进入线程!");
        System.out.println("B 离开线程!");
    }
}

对象锁的输出结果:

A 进入线程!
B ready!
B 进入线程!
B 离开线程!
A 离开线程!

稍作修改加上static,让我们使用类锁,即使实例化了不同的对象,但是使用的同一个类,这时候的输出结果就不一样了,这里还用了同一个类,使用一个锁锁住一个或多个方法、代码块

class person{
    public String son;
    public person(String son) {
        this.son = son;
    }
    private int number = 0;
    synchronized public static void printA(String string) throws InterruptedException {
        System.out.println("A 进入线程!");
        Thread.sleep(2000);
        System.out.println("A 离开线程!");
        }
    
    synchronized public static void printB(String string) throws InterruptedException {
        System.out.println("B ready!");
        System.out.println("B 进入线程!");
        System.out.println("B 离开线程!");
    }
}

输出结果:

A 进入线程!
A 离开线程!
B ready!
B 进入线程!
B 离开线程!

再次引入一个小心得点:类锁和对象锁混用
同样使用上面的方法代码稍微修改了一下,可以从输出结果看出,使用对象锁的代码块,即使是同一个对象,也没有执行锁的机制,说明了类锁和对象锁混用的情况下,只有类锁有效,对象锁无效

this: 表示当前类实例化后的对象

        person p = new person(string);
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.printA(string);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    p.printB(string);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        }
    }

class person{
    public String son;
    public person(String son) {
        this.son = son;
    }
    private int number = 0;
    synchronized public static void printA(String string) throws InterruptedException {
        System.out.println("A 进入线程!");
        Thread.sleep(2000);
        System.out.println("A 离开线程!");
        }
    
    public void printB(String string) throws InterruptedException {
        System.out.println("B ready!");
        synchronized (this) {
        System.out.println("B 进入线程!");
        System.out.println("B 离开线程!");
        }
    }
}

为了证明和锁的顺序没关系,调换顺序来证明

class person{
    public String son;
    public person(String son) {
        this.son = son;
    }
    private int number = 0;
    
    public void printA(String string) throws InterruptedException {
        System.out.println("A ready!");
        synchronized (this) {
        System.out.println("A 进入线程!");
        Thread.sleep(2000);
        System.out.println("A 离开线程!");
        }
    }
    
    synchronized public static void printB(String string) throws InterruptedException {
        System.out.println("B 进入线程!");
        System.out.println("B 离开线程!");
        }
}

输出结果:

A ready!
A 进入线程!
B 进入线程!
B 离开线程!
A 离开线程!

Java对象锁和类锁全面解析(多线程synchronized关键字)

Statistics and Machine Learning Toolbox Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具 立即下载

相关推荐

Python连接高斯数据库踩坑实录:从SASL报错到SSL安全连接的完整指南

本文详细记录了Python连接高斯数据库时遇到的SASL authentication报错及其解决方法。通过剖析SASL认证机制,对比了修改数据库配置、使用官方驱动等方案的利弊,并重点提供了通过自动化脚本生成SSL证书,实现安全、免密连接的完整指南,帮助开发者彻底解决连接难题。

weixin_28340315的博客 442

java异步调用方法 锁_线程介绍,异步,对象锁

线程基础:当创建线程时,会为非static对象各自申请内存空间卖票程序:线程的优先级用1-10之间的整数表示,数值越大优先级越高,默认的优先级为5。pupublicclassMain{staticintticket=10;staticRunnablemRunnable=newRunnable(){@Overridepublicvoidrun(){//TODOAu...

weixin_39593427的博客 391

数据可视化—power bi 基础操作汇总

数据来源: https://pan.baidu.com/s/1U_Y7rKfhnSKbLmh4FcUD_Q 提取码: yq5v 目录 基本功能与视图 编辑与查询—修改column案例 建立关联性 新增column与DAX完成总价运算 习题练习1:建立可视化图表 产品销售统计图 column拖曳可视化 1.基本功能与视图 ①基础操作界面 ②获取数据—以打开excel为例 ③数据文件基本视图 可视化形式:柱状图、数据、关联性 2.编辑与查询—修改column ①编辑与查询—数据处理界面 .

weixin_52730784的博客 2684

java异步锁和同步锁

同步锁用synchronized修饰的代码块 ,指的是在该线程释放当前对象锁之前,其他线程不能使用该对象的同步代码块。异步锁:任何线程可以同时访问异步代码块 不需要等待其他线程释放该对象锁。如果一个数据存在读写或者写写情况,那么就对其使用同步锁。设计思路:如果一个数据只存在读,那么就对其使用异步锁。

m0_59093019的博客 1485

在Keil下完成一个汇编程序的编写

在学习STM32的路上开始是学的C语言尚未进行对汇编进行学习,因此抽出时间来学习一下在keil下的汇编语言。

Liu-FE的博客 1万+

PX4无人机-Gazebo仿真实现动态目标追踪的视觉控制方案

本文详细介绍了PX4无人机在Gazebo仿真环境中实现动态目标追踪的视觉控制方案。从PX4与Gazebo仿真环境搭建、动态目标追踪核心技术栈、仿真环境深度定制技巧到追踪算法的优化实践,提供了全面的技术指导和常见问题排查方法,帮助开发者高效实现无人机视觉追踪功能。

weixin_29196315的博客 454

java 同步锁 异步锁_十八、线程同步、线程异步和锁机制synchronized

1、线程模型1)线程异步:多个线程之间独立执行,谁也不用等谁线程同步:一个线程必需等另外一个线程执行完毕之后才能执行备注:为了数据的安全,尽管应用程序的使用率低,但是为了保证数据是安全的,必须加入线程同步机制,线程同步机制使程序变成了(等同)单线程2)什么条件下要使用线程同步?第一: 必须是多线程环境第二: 多线程环境共享同一个数据第三: 共享的数据涉及到修改操作3)同步方法和同步代码块的区别:在...

weixin_30313365的博客 3149

STM32F407与AD7766实战:如何用SPI+DMA实现高速ADC数据采集(附完整代码)

本文详细介绍了如何利用STM32F407的SPI接口与DMA控制器,高效稳定地驱动24位高精度ADC芯片AD7766,实现高速连续数据采集。通过对比传统中断方式的瓶颈,阐述了SPI+DMA方案如何大幅降低CPU负载,并提供了从硬件设计、CubeMX配置到核心驱动代码的完整实战指南,帮助工程师解决高速ADC数据采集中的性能难题。

weixin_29281941的博客 190

Java基本方法之本地锁和异步锁

在开发的时候,我们有的时候会权衡使用异步锁或者本地锁。下面的方法可以让我们更好的理解如何选择 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 案例测试 * @author 科帮网 */ public class LockDemo { priv...

wszhm123的博客 2635

FTViewSE利用VB脚本制作简易日报表

罗克韦尔SE用VB做的简单的报表

z0800656的博客 3025

Feature ‘alsa‘ was enabled, but the pre-condition ‘config.unix && !config.qnx && libs.alsa‘ failed解决

这个问题主要是Qt多媒体插件中缺少了ALSA音频库,所以我们需要自行先编译ALSA 在执行./configure的时候,配置项中ALSA为no Qt Multimedia: ALSA ................................... no GStreamer 1.0 .......................... no GStreamer 0.10 ......................... no Video for Linux .............

有问题或资源连接有缺失的可以私信公众号新潮看世界获取 2591

同步锁与异步锁的区别

异步锁:同一进程内的,多个线程间有互斥关系。只有等一个线程运行结束才能运行运行另一个进程。 同步锁:多个线程运行一个方法,因为方法上加了同了同步,一次只有一个线程运行,其他线程进入竞争进制。    同步是一种更为复杂的互斥,而互斥是一种特殊的同步。 本质:等待响应 比方说同步(读写)锁特点:1)多个读者可以同时进行读 2)写者必须互斥(只允许一个写者写,也不能读者写者同时进行) 3)写者优

nicknailo博客 3万+

YOLOv11【第二章:核心模块进阶篇·第3节】LDConv线性可变形卷积改进YOLOv11!

🏆 本文收录于专栏 《YOLOv11实战:从入门到深度优化》。本专栏围绕 YOLOv11 的改进、训练、部署与工程优化 展开,系统梳理并复现当前主流的 YOLOv11 实战案例与优化方案,内容目前已覆盖 分类、检测、分割、追踪、关键点、OBB 检测 等多个方向。

**My Coding Family** 7443

同步与异步,如何解决线程安全问题—synchronized详解,对象锁与类锁,静态与非静态同步方法详解

欢迎使用Markdown编辑器写博客 本Markdown编辑器使用StackEdit修改而来,用它写博客,将会带来全新的体验哦: Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 同步与异步 原意 同步:是所有的操作都做完,才返回给用户结果(某个人做...

方圆几里 1996

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

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

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

Java多线程并发笔记01 对象锁 & 类锁 & 对象锁的同步和异步 & 脏读

例子程序01:对象锁 /** * 多线程同时修改同一对象的成员变量,保持修改的原子性 * @author 超轶绝尘 * */ public class MyThread extends Thread { private int count = 5; //synchronized给当前对象加锁 @Override public synchronized void run(...

guchunchao的专栏 282

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

java synchronized 类锁,关于java:synchronized对象锁和类锁

对象锁概念Java的所有对象都含有1个互斥锁,这个锁由JVM主动获取和开释。线程进入synchronized办法的时候获取该对象的锁,当然如果曾经有线程获取了这个对象的锁,那么以后线程会期待,synchronized办法失常返回或者抛异样而终止,JVM会主动开释对象锁。这里也体现了用synchronized来加锁的一个益处,办法抛异样的时候,锁依然能够由JVM来主动开释。// 对象锁:模式1(办法...

weixin_39726697的博客 190

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

举例说明Java中synchronize对象锁和类锁有什么区别?

synchronize

中年人 618

【025期】谈谈 Java 中 synchronized 对象锁和类锁有什么区别?

>>号外:关注“Java精选”公众号,回复“2021面试题”,领取免费资料!“Java精选面试题”小程序,3000+ 道面试题在线刷,最新、最全 Java 面试题!synchr...

Java精选 334

Java synchronized 对象锁和类锁的区别

原文链接:https://blog.youkuaiyun.com/zhujiangtaotaise/article/details/55509939 synchronized 加到 static 方法后面是给class 加锁,即类锁; 而synchronized 加到非静态方法前面是给对象上锁。 这两者的区别我用代码来演示下: 对象锁和类锁是不同的锁,所以多个线程同时执行这2个不同锁的方法时,是异步的...

qazxsw635241的博客 150

java 类锁还能访问_面试官:你能谈谈Java中 synchronized 对象锁和类锁的区别

synchronized 加到 static 方法前面是给class 加锁,即类锁;而synchronized 加到非静态方法前面是给对象上锁。这两者的区别我用代码来演示下对象锁和类锁是不同的锁,所以多个线程同时执行这2个不同锁的方法时,是异步的。在Task2 中定义三个方法 doLongTimeTaskA和doLongTimeTaskB是类锁,而doLongTimeTaskC是对象锁。publi...

weixin_28757113的博客 169

136面试必问:你能谈谈Java中 synchronized 对象锁和类锁的区别

更多面试题:面试题内容聚合 synchronized 加到 static 方法前面是给class 加锁,即类锁;而synchronized 加到非静态方法前面是给对象上锁。 这两者的区别我用代码来演示下 对象锁和类锁是不同的锁,所以多个线程同时执行这2个不同锁的方法时,是异步的。 在Task2 中定义三个方法 doLongTimeTaskA和doLongTimeTaskB是类锁,而doLongTimeTaskC是对象锁。 publicclassTask2{ publi...

AI乔治 345

类锁和对象锁

1、对象锁(synchronized修饰方法或代码块),分两种情况,一种是synchronized method和synchronized(this)代码块,锁定的都是当前对象,两者是同一把锁,一种是synchronized(任意Object对象),代码如下:public class ObjectLock { public void method1(){ synchronized (this) ...

yx_keith的博客 481

java 同步和异步

1.举个例子:普通B/S模式(同步)AJAX技术(异步)同步:提交请求->等待服务器处理->处理完毕返回 这个期间客户端浏览器不能干任何事异步: 请求通过事件触发->服务器处理(这是浏览器仍然可以作其他事情)->处理完毕-----------------------------------------------------------------------------------同步就是你

weiliangzhichen的专栏 434

JAVA多线程之——同步与异步

线程的同步与异步 1.同步:synchronized. 同步从概念上来讲,就是一个资源的共享。因此在多线程环境中,重点就是共享,如果一个资源没有被共享,则不需要同步。 2.异步:asynchronized 异步就是在多线程环境中,多个线程可以同时访问某一个资源。而不需要竞争。相互独立。就像我们的ajax异步刷新。在刷新某个局部的时候,并不影响你进行其他操作。Synchronize

永不止步 1076

线程与锁

锁保证了多个线程访问一个类时,表现的是正确行为,即保证了线程安全。 synchronized: 可以在任意对象及方法加上锁,而加锁的这段代码称为互斥区或临界区 当多个线程访问synchronized修饰的方法锁,会以按cpu的分配先后顺序,以排队的形式进行处理。 而在这个过程中,线程都会不断地尝试去获得这个锁,如果拿到了,就进入synchronized代码体内容; 拿不到时,还会继续尝试去获取...

hlx156的博客 304

多线程学习笔记--02(对象及变量的并发访问,Object锁,Class锁,Synchronized和volatile)

1.学习目标 Synchronized对象监视器为Object时的使用 Synchronized对象监视器为Class时的使用 非线程安全是如何出现的, 关键字volatile的主要作用 关键字Synchronized和volatile的主要区别以及使用情况 先来理解理解什么是对象的发布与逸出? 发布(pub......

最后的武艺集大成者 433
上一篇: ARM汇编之指令集的切换:ARM切换到Thumb
下一篇: shellcode的NULL字符问题
Dr. 熊
博客等级 码龄10年 29粉丝 140原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值