0%

发表于 更新于 分类于 阅读次数：
本文字数： 273 阅读时长 ≈ 1 分钟

2018年7月8日 下午3:33

理解StampedLock

  1. StampedLock是Java8引入的一种新的锁机制,简单的理解,可以认为它是读写锁的一个改进版本,::读写锁虽然分离了读和写的功能,使得读与读之间可以完全并发,但是读和写之间依然是冲突的,读锁会完全阻塞写锁,它使用的依然是悲观的锁策略::.如果有大量的读线程,他也有可能引起写线程的饥饿
  2. 而StampedLock则提供了一种乐观的读策略,这种乐观策略的锁非常类似于无锁的操作,使得乐观锁完全不会阻塞写线程
  3. Java8 读写锁的改进:StampedLock(笔记) - Darcy_wang - 博客园

发表于 更新于 分类于 阅读次数：
本文字数： 313 阅读时长 ≈ 1 分钟

2018年7月7日 上午10:32

给定某个模型，我们可以训练出来数据和对于情况之间的概率联系，概率越大越容易发生，这个概率通过sigmoid函数，将概率控制在0~1之间，

  1. 线性回归是：x—>y之间的对应关系
  2. 逻辑回归是：x—>概率值之间的对应关系(也可以说成是y,只不过这个y在0~1之间)
  3. 总结来说，逻辑回归本质和线性回归一样，都是在给定带标签的数据之后，找到x—>y之间的关系，寻找到最合适的一套参数w，
  4. 从数学的角度去看，只不过逻辑回归是一个复合函数模型，而线性回归是一个简单函数模型
  5. 对于计算机的训练过程，我们可以理解成是一样的，因为计算机是分不清复合函数和简单函数的，这个区分只不过是站在人的角度上进行的区分。

发表于 更新于 分类于 阅读次数：
本文字数： 66 阅读时长 ≈ 1 分钟

2018年7月7日 下午9:16

我理解下来就是Collection的加强版，原来的类型只能是E，现在的类型可以是E的子类。范围更加广。

发表于 更新于 分类于 阅读次数：
本文字数： 135 阅读时长 ≈ 1 分钟

2018年7月7日 下午9:10

我们的目标：就是学会怎样会不安全，如何写线程安全的代码

就是讲了几个技巧的实现原理
解释几个概念

挑理解不了的内容看视频，其他的看文字

不可变对象为啥是线程安全的？
线程不安全的表现就是类全局变量被不同的线程修改，不可变对象不可修改全局变量，自然安全

发表于 更新于 分类于 阅读次数：
本文字数： 2.6k 阅读时长 ≈ 2 分钟

2018年7月7日 下午4:23

慕课网实战·高并发探索（三）：线程安全性-原子性-CAS（CAS的ABA问题） - CSDN博客

  1. 什么是CAS？
  2. 为什么有了AtomicLong还要新增一个LongAdder呢？
    1. CAS底层实现是在一个死循环中不断地尝试修改目标值，直到修改成功。如果竞争不激烈的时候，修改成功率很高，否则失败率很高。在失败的时候，这些重复的原子性操作会耗费性能。
  3. LongAdder类的实现原理？
  4. AtomicBoolean中的compareAndSet方法作用？
    1. 这个方法可以做到的是控制一个boolean变量在一件事情执行之前为false，事情执行之后变为true。
    2. 或者也可以理解为可以控制某一件事只让一个线程执行，并仅能执行一次。 
      1
      2
      3
      if (isHappened.compareAndSet(false, true)) {//控制某有一段代码只执行一次
                 log.info("execute");
      }
  5. AtomicIntegerFieldUpdater类的用途？
    1. 这个类的核心作用是要更新一个指定的类的某一个字段的值。
    2. 并且这个字段一定要用volatile修饰同时还不能是static的。
  6. 什么是ABA问题？
    1. CAS操作的时候，其他线程将变量的值A改成了B，但是随后又改成了A，本线程在CAS方法中使用期望值A与当前变量进行比较的时候，发现变量的值未发生改变，于是CAS就将变量的值进行了交换操作。但是实际上变量的值已经被其他的变量改变过，这与设计思想是不符合的。
  7. AtomicStampReference的处理思想？
    1. 每次变量更新的时候，将变量的版本号+1，之前的ABA问题中，变量经过两次操作以后，变量的版本号就会由1变成3，也就是说只要线程对变量进行过操作，变量的版本号就会发生更改。
    2. 从而解决了ABA问题。
  8. 使用synchronized之后不同对象之间操作是互不补影响？
    1. 当synchronized修饰静态方法和类时，作用的对象是这个类的所有对象。
    2. 也就是说：这个类的所有实例是不能争抢的，必须一个个按顺序来。

慕课网实战·高并发探索（四）：线程安全性-可见性-有序性 - CSDN博客

  1. 线程可见性的定义？
    1. 一个线程对主内存的修改可以及时的被其他线程观察到
  2. 导致共享变量在线程间不可见的原因？
    1. 线程交叉执行
    2. 重排序结合线程交叉执行
    3. 共享变量更新后的值没有在工作内存与主存间及时更新
  3. JMM关于synchronized的两条规定？
    1. 线程解锁前，必须把共享变量的最新值刷新到主内存
    2. 线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值（注意：加锁与解锁是同一把锁）
  4. Volatile的作用？
    1. 对volatile变量写操作时，会在写操作后加入一条store屏障指令，将本地内存中的共享变量值刷新到主内存。
    2. 对volatile变量读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量。
    3. 方式重排序
  5. Volatitle可以解决并发问题吗？
    1. volatile不会让你的程序变得更好，仅仅是通过防止指令重排，以免让程序因为重排序变得更坏。
    2. 所以，它不可以直接解决并发问题。
  6. volatile适合做什么呢？
    1. 比较适合做状态标记量（不会涉及到多线程同时读写的操作）

慕课网实战·高并发探索（六）：不可变对象 -final -ImmutableX -unmodifiableX - CSDN博客

  1. 一个不可变对象需要满足的条件？
    1. 对象创建一个其状态不能修改
    2. 对象所有域都是final类型
    3. 对象是正确创建的(在对象创建期间，this引用没有逸出)
  2. 创建一个不可变对象的方法？
    1. 将类声明为final，这样它就不能被继承。
    2. 将所有的成员声明为私有的，这样就不允许直接访问这些成员。
    3. 对变量不提供set方法，将所有可变的成员声明为final，这样就只能赋值一次。通过构造器初始化所有成员进行深度拷贝。
    4. 在get方法中不直接返回对象的本身，而是克隆对象，返回对象的拷贝。
  3. unmodifiable相关类的实现原理是什么呢？

慕课网实战·高并发探索（七）：线程封闭 - ThreadLocal - CSDN博客

  1. 什么是线程封闭？
    1. 它其实就是把对象封装到一个线程里，只有一个线程能看到这个对象
  2. 堆栈封闭？
    1. 就是将变量尽量放在方法中，而不是全局变量
  3. ThreadLocal线程封闭？
    1. 其实ThreadLocal内部维护了一个map,map的key是每个线程的名称，而map的value就是我们要封闭的对象。
    2. ThreadLocal就像一个安全屋一样，可以保护放入的线程对象只归自己(当前线程)所有。
    3. 多个线程共有一个ThreadLocal，ThreadLocal会自动的分辨出当前线程是谁，以及对应的对象。
    4. ThreadLocal用于保存某个线程共享变量：对于同一个static ThreadLocal，不同线程只能从中get，set，remove自己的变量，而不会影响其他线程的变量。
  4. 工作内存的拷贝 与 并发问题的关系？
    1. 由于工作内存的拷贝，避免并发问题——实例：堆栈封闭
    2. 由于工作内存的拷贝，引起并发问题——实例：两个线程操作同一个全局变量

慕课网实战·高并发探索（八）：线程不安全类、同步容器 - CSDN博客

  1. Vector也不是完全的线程安全的？
    1. synchronized关键字可以保证同一时间只有一个线程执行该方法，但是多个线程同时分别执行remove、add、get操作的时候就无法控制了。
  2. 同步容器和并发容器的区别？
    1. 同步容器将所有对容器的访问都串行化—每次只能有一个线程能访问它，以实现他们的线程安全性，这种方法的代价是严重降低并发性，当多个线程竞争访问容器的锁时，吞吐量将会严重减低。
    2. 并发容器：针对多个线程设计的，用并发容器来代替同步容器，可以极大地提高伸缩性并降低风险。
    3. 并发容器使用了与同步容器完全不同的加锁策略来提供更高的并发性和伸缩性，例如在ConcurrentHashMap中采用了一种粒度更细的加锁机制，可以称为分段锁，在这种锁机制下，允许任意数量的读线程并发地访问map，并且执行读操作的线程和写操作的线程也可以并发的访问map，同时允许一定数量的写操作线程并发地修改map，所以它可以在并发环境下实现更高的吞吐量。
    4. 同步容器和并发容器的区别 - CSDN博客
      1. 这个里面有具体的代码例子，来说明同步容器的缺点，以及使用方法。
      2. 同步容器也会线程不安全
    5. Java并发——同步容器与并发容器 - LaplaceDemon - 博客园
      1. 这个里面讲的并发容器种类非常多。

发表于 更新于 分类于 阅读次数：
本文字数： 343 阅读时长 ≈ 1 分钟

2018年7月7日 下午2:53

Java内存模型，先从这几个字开始理解：

  1. Java内存模型指内存是如何在java程序运行的过程中使用的？
    1. 这类的内存，不能狭义的理解成主内存，也要包括缓存，工作内存，本地内存等这些抽象的概念内存。
  2. 围绕内存，java做了哪些特殊的功能？
    1. 这里的java功能，对于使用的人来说可以说是使用java的默认规定。

在java中我们总是讨论高并发，多线程等知识，但是产生的源头在哪里？

  1. 源头就存在于JMM中，由于JMM中就规定了
    1. 栈：用于程序运行的关键
    2. 堆：数据的存储
    3. 一个线程对应于一个栈
    4. 多个线程共享同一个堆
    5. 定义本地内存，本地内存是主内存的私有拷贝，每个线程有自己的本地内存，那么就会有同一个数据的多个私有拷贝，这就是产生多线程知识的，并发难题的本质原因——JMM中就是根本原因。

发表于 更新于 分类于 阅读次数：
本文字数： 216 阅读时长 ≈ 1 分钟

2018年7月5日 下午5:08

  1. loss function是对当前这组参数的一次评估。
  2. 我觉得增添上正则化项与解决过拟合的问题并没有直接的相关性。
  3. 正则化项添加在loss function中，我理解只是广义的修改了loss function，提供了一种新的loss function，提供了一种新的可能性而已。
  4. 这并不代表着就可以解决过拟合，说不定还会加深过拟合。
  5. 从这里我总结出：机器学习的一些东西并不是有完整的逻辑，更多的是在不断的尝试各种情况。

发表于 更新于 分类于 阅读次数：
本文字数： 919 阅读时长 ≈ 1 分钟

2018年6月23日 下午4:28
【这篇文章理解的不正确，看下面新写的文章，这篇文章就当留恋了】
参看：

首先要理解这两节的pdf：

从C编译到机器指令（八课）

  1. 这篇文章主要是为了介绍一些基础知识
    1. 点亮LED的步骤：也是操作arm的一般步骤
    2. 两种启动过程
    3. 操作GPF4的方法
    4. 几条汇编代码
    5. 机器码
    6. 快速转换2/8/16进制
    7. 字节序
    8. 位操作

      重定向
  2. 重定向是在main函数已经完成的情况下，处理如何合适的链接在内存中存储代码。

回答几个核心的问题：

  1. 这章运行时地址是最重要的，从他的名字来判断，作用是：程序的运行地址设置在哪里，那么我们的程序就应该保存在那里，然后从这里运行。
  2. 那么为啥还要出现加载地址？
    1. 现在见的最多的就是要为了更改bin文件的大小
  3. 如果一个程序运行时地址和加载地址不同怎么办？
    1. 首先要说明，我们在反汇编文件dls中，最左边的一列看到的是加载地址，但是最最重要的是：当我们将程序烧到nor/nand之后，只有第二列的机器码被烧了进去。加载地址是为了你阅读方便而存在的，不烧到内存中
    2. 而，烧到内存中的代码，其中涉及到地址的部分，是根据运行时地址来跳转或寻找的，也与加载地址无关。这个是隐形的！
    3. 总结：其实我们可以忽略加载地址的存在，认为只有运行地址
    4. 2018年11月22日 下午1:24
      1. 可以认为运行地址 比 加载地址高一个层次，是给人看的。
      2. 如果使用相对地址指令=>此时只能看到运行时地址
      3. 如果使用绝对地址指令<=>此时只能看到加载地址
        1. 一共有四个地址！！！！
  4. 我们很多时候是不可能做到代码一定就在运行地址处执行，那怎么办？
    1. 例如，刚刚烧到nor/nand的时候，是一定从0地址处开始执行的，此时，我们的运行地址一般都不从0开始
    2. 写位置无关码？
      1. rodate，date段的全局/静态变量，必须使用绝对地址来查找（没为啥，arm规定）。那么，当程序不在运行地址处执行时，我们一定不可使用全局变量
      2. 已赋值的数组中的值会保存在rodate段，即使数组本身是局部变量，应该在栈中，但是我们依然不可使用以赋值的数组。
      3. 使用相对跳转指令b/bl，不可使用ldr