Git配置技巧

1. Git命令自动补全

MacOS系统下，优先配置好bash_profile的系统变量加载。否则，bashrc不会生效。

1
2
3
4
5
6
7
8
9
10
#-------------------------------------------------------------
# Source global definitions (if any)
#-------------------------------------------------------------
if [ -f ~/.bashrc ]; then
      . ~/.bashrc   # --> Read ~/.bashrc, if present.
fi
source ~/.git-completion.bash

Git的源代码包里的contrib/completion目录下有个git-completion.bash，把这个文件保存到~/.git-completion.bash，
然后在.bash_profile中加入一行。

2. 别名设置

别名设置可以简化git长命令的输入，比如经常使用的git pull origin dev估计很多人都形成肌肉记忆了。
可以简化为git plode，在用户目录下创建.gitconfig文件，增加如下配置：.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[user]
        name = colorfire
        email = caihuo@gmail.com
[core]
        autocrlf = input
[alias]
    co = checkout
    ss = status
    cm = commit -m
    br = branch
    bm = branch -m
    bd = branch -D
    cb = checkout -b
    df = diff
    ls = log --stat
    lp = log -p
    plo = pull origin
    plode = pull origin dev
    pho = push origin

3. Git生僻命令

  1. #git pull —rebase origin dev // 下载新的代码并执行rebase，可以保证代码最新并且不会生成merge commit
  2. #git checkout -b dev origin/dev // 获取远端分支并在本地创建，（命令前提需要git fetch最新的代码）
  3. #git merge -s ours release // 强行以本地代码为主线merge代码，也可以将ours替换为theirs，已release版本为主（谨慎使用）
  4. #git diff -b release –name-only // 对比分支上不同的文件，只显示名称
  5. #git merge -s theirs -X ignore-all-space release // 忽略空格来合并代码
  6. #git update-index –assume-unchanged file // 忽略指定的文件，不加入git版本库（适合在gitignore漏掉时使用）

展开全文 >>

线程与锁机制

互斥同步

互斥同步(Mutual Exclusion & Synchronization)是常见的线程安全的保障手段。
同步定义：保证共享数据在同一个时刻只被一条（或多条，在使用信号量的时候）线程使用。
互斥定义：互斥是实现同步的一种手段，包括：临界区（Citical Section）、互斥量（Mutex）和信号量（Semaphore）。

Synchronized（同步关键字）

Synchronized会在同步块的前后形成MonitorEnter和MonitorExit两个字节码指令，会含有一个Reference类型参数指定一个锁定和解锁的对象，如果没有则会根据修饰的是类方法或者实例方法去取对应的实例或Class对象来作为锁对象。
执行MonitorEnter命令时，会尝试获取对象的锁，如果对象没有被锁定或者已经拥有了对象的锁，则把锁的计数器加1，在执行MonitorExit命令时会将锁的计数器减1。当锁的计数器为0时，锁就被释放了。如果获取失败，那么当前线程会阻塞等待（线程阻塞、挂起是需要调用操作系统级的指令，开销较大），直到对象的锁被其他线程释放。

ReentrantLock（可重入锁）

ReentrantLock与Synchronized都具有线程重入特性。

  • 等待可中断，正在等待的线程如果长期获取不到对象的锁，可以放弃等待改作其他事情（lock.lockInterruptibly能够响应中断）。
  • 公平锁，必须按照等待时间来一次获得锁；Synchronized是不具备该功能。
  • 绑定多条件，可以绑定多个Condition对象来支持多种条件。

ReentrantLock与Synchronized吞吐量性能，在JDK1.6之后就不是那么明显，由于Synchronized的继续优化，优先考虑使用Synchronized关键字。
笔者：总结来讲两者都具有重入性，可以满足大多数场景的使用，除非使用到了可中断等特性，否则推荐使用Sync关键字。

ReentrantLock的父类中会有一个state变量来表示同步的状态, 通过CAS操作来设置state来获取锁，如果设置成了1，则将锁的持有者给当前线程, 如果拿锁不成功，则会做一个申请, 如果还是没有申请到锁，就addWaiter，意思是把自己加到等待队列中去, 其间还会有多次尝试去申请锁，如果还是申请不到，就会被挂起。
Semaphore 对于锁来说，它是互斥的排他的。意思就是，只要我获得了锁，没人能再获得了。可以定义限额。

1
final Semaphore semaphore = new Semaphore(5);

非阻塞同步

非阻塞同步是基于冲突检测的乐观并发策略，如果产生了冲突，就采用补偿措施（最常见的就是不断重试，直到成功为止），这种并发策略不需要挂起线程。
（非阻塞同步需要硬件指令集的支持，来保证操作和冲突检测是原子性操作）

CAS（乐观锁）

比较并交换操作（Compare and Swap），是通过处理器指令（cmpxchg）来实现的。
算法的过程是这样：它包含3个参数CAS(V,E,N)。V表示要更新的变量，E表示预期值，N表示新值。仅当V值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明经有其他线程做了更新，则当前线程什么都不做。

AtomicInteger：做为线程安全的i++， increaseAndGet();

1
2
3
4
5
6
7
8
public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

无同步方案

可以将需要共享的数据可见范围限制在同一个线程之内，最常见的是消费队列（生产者-消费者）模式，将消费过程尽量在一个线程中消费完。
Web交互模型，一个请求对应一个服务器线程的处理。

ThreadLocal线程存储

每一个线程的Thread对象都有一个ThreadLocalMap对象，这个对象存储了一组以HashCode为键值的K-V值对来找到对应的本地线程变量。

锁的优化

自旋锁，不放弃处理器的执行时间，看看持有锁的线程是否很快会自己释放锁，为了让线程等一会需要让它执行一个自旋（循环）。自旋的时间由虚拟机控制，避免长时间自旋。
锁消除，虚拟机会根据数据逃逸分析来判断是否需要同步加锁，如果不需要则会自动去除掉同步块。
锁粗化，频繁的锁操作会造成过度的资源竞争，建议将多个小锁合并为一个大锁以便减少不必要的损耗。

轻量级锁

轻量级锁会在无竞争的情况下使用CAS操作去消除同步使用的互斥量。
轻量级锁就是为了在无多线程竞争的环境中使用CAS来代替mutex，一旦发生竞争，两条以上线程争用一个锁就会膨胀。设Thread1先拥有锁，Thread2是后来者，这个膨胀可能会发生在Thread1解锁的时候，也可能发生在Thread2尝试加锁的时候。可以看一下Hotspot VM的源码（vm目录下的synchronizer.cpp）。

偏向锁

偏向锁是为了消除数据在无竞争情况下的同步原语，进而提高运行性能。相比轻量级锁，在无竞争状态干脆连CAS都不做了。
该锁偏向当前获得它的线程，如果接下来没有其他线程竞争该资源，偏向锁的线程不再需要同步。

线程

协同式调度，线程的执行时间由线程本身来控制，在把自己的工作执行完了之后，主动通知系统切换到另一个线程。这种方式实现简单，但线程执行时间不可预期，如果线程存在问题会一直阻塞无法切换线程。
抢占式调度，每个线程将由系统来分配执行时间，线程的切换不由线程本身决定（Thread.yield方法可以让出执行时间，获得执行时间本身没有办法）。
线程可以指定优先级，优先级越高的越容易被系统选中执行。

线程状态间切换:
state

原子性：操作指令要么执行成功、要么执行失败，不会出现中间执行一半的状态。
可见性：当一个线程修改了共享变量的值，其他线程能够立即得知修改。
有序性：当前线程观潮所有的操作都是有序的，，但一个线程观察另一个线程所有的操作都是无序的（由于指令重排和工作内存同步延迟的问题）。

Volatile变量

关键字volatile是虚拟机提供的最轻量级的同步机制，其包含两种特性：线程可见性和禁止指令重排。
可见性：当一个线程修改了volatile变量，新值对于其他线程是立即可见的。不会出现幻读、脏读的情况。但类似i++的自增操作由于不是原子性操作，如果并发写也会导致变量的错误，所以volatile关键字标注的变量并不是线程安全的。

volatile关键字读操作，基本没有多余性能消耗；但写操作由于采用了许多内存屏障（Memory Barrier）指令来保证处理器不发生乱序执行，性能稍差。但总体比锁机制要好多。

参考：《深入理解Java虚拟机》
https://my.oschina.net/hosee/blog/614319
https://my.oschina.net/hosee/blog/599884

展开全文 >>

JVM内存模型

1. 堆与非堆内存

model

Heap 堆区 No-Heap 非堆区
Young Generation 新生代/ Old Generation 旧生代 Method Area 方法区/ Thread Area 线程区
其中新生代又分为: Eden区/Survivor区 线程区分为: VM Stack 虚拟机栈/ Runtime Constant Pool常量池/ Program Counter 计数器

Heap堆内存 (GC堆）

Java Heap 作为垃圾回收的主要对象，保存了所有Java对象和数组。当没有空间分配，会有OutOfMemoryError错误。

  • 被所有线程共享的一块内存区域
  • 所有对象实例以及数组都在堆上分配 （all class instances and arrays is allocated.)
  • 作为垃圾回收的主要区域
  • 没有空间分配，会有OutOfMemoryError错误

Method Area方法区

保存Java类、常量以及静态变量（class文件），作为永久代，也叫做非堆。

  • 存储已被虚拟机加载的类信息、常量、静态变量以及编译后的代码
  • 内存不足则会抛出OutOfMemoryError: PermGen space

常量池

  • 作为方法区的一部分，存储运行时产生的常量，最长使用的是String类的intern方法（属于native方法，作用是如果常量池中存在当前字符串, 就会直接返回当前字符串. 如果常量池中没有此字符串, 会将此字符串放入常量池中后，再返回，这里不做详细说明）

VM Stack虚拟机栈

  • 线程私有，与线程的声明周期相同
  • 存储局部变量表、操作栈、动态链接、方法出口
  • 局部变量表保存了基本数据类型（boolean、byte、char、int等），其中对象引用（reference类型）并不是对象本身而是对象的地址指针或者句柄

其中Heap区域作为垃圾回收的主要操作空间，以及解释下为什么Survivor会有两个？

大的对象直接进入旧生代，长期存活的对象进入旧生代
对于线上环境的内存泄露问题可以采用使用btrace等工具

2. 垃圾回收

Heap堆内存分为新生代、老生代，比例1：2
新生代又分为Eden区和Survivor区，比例8：1：1；Eden区放新生对象、Survivor区放回收后存活的对象。

回收步骤

标记整理清除: 先标记回收对象，然后再清除。会产生碎片。适用于存活对象多、回收对象少。
复制清除: 先复制在清除，但复制的效率较低、占用较大内存。适用于存活对象少、回收对象多。
分代回收: 新生代采用复制清除、老年代使用标记整理清除。这就是为什么分为两代区域保存，其中新生代又Eden空间和Survivor空间，并且比例是8:1:1，

所以，需要有两个Survivor区域用来复制保留的对象。

举例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 分配了一个又一个对象
放到Eden区
// 不好，Eden区满了，只能GC(新生代GC：Minor GC)了
把Eden区的存活对象copy到Survivor A区，然后清空Eden区（本来Survivor B区也需要清空的，不过本来就是空的）
// 又分配了一个又一个对象
放到Eden区
// 不好，Eden区又满了，只能GC(新生代GC：Minor GC)了
把Eden区和Survivor A区的存活对象copy到Survivor B区，然后清空Eden区和Survivor A区
// 又分配了一个又一个对象
放到Eden区
// 不好，Eden区又满了，只能GC(新生代GC：Minor GC)了
把Eden区和Survivor B区的存活对象copy到Survivor A区，然后清空Eden区和Survivor B区
// ...
// 有的对象来回在Survivor A区或者B区呆了比如15次，就被分配到老年代Old区
// 有的对象太大，超过了Eden区，直接被分配在Old区
// 有的存活对象，放不下Survivor区，也被分配到Old区
// ...
// 在某次Minor GC的过程中突然发现：
// 不好，旧生代Old区也满了，这是一次大GC(旧生代GC：Major GC)
Old区慢慢的整理一番，空间又够了
// 继续Minor GC
// ...
// ...

Survivor区域有两个是因为需要复制留存的对象，From Survivor和To Survivor也会根据情况来互换。

3.对象创建

首先是在Java方法栈中增加reference数据本地变量表，Java堆中保存实例化的对象，而相关的类型数据则保存在方法区。
object

伪代码举例：

1
2
3
4
5
6
7
8
9
10
11
public class Object {
    int id;
    String name;
    void method_name() {}
    //对象类型等数据（父类、接口、方法）会存储在方法区，Heap区只使用指针作为指向
}
Object object = new Object();
// object反映到栈的局部变量表中，作为reference类型存储
// new Object() 反映到Heap区域，保存实例数据

使用指针访问数据类型的好处是速度较快，但垃圾回收时相比句柄池，对象会被整体移动损耗时间较长

展开全文 >>

hexo+github 快速搭建手册

快速搭建

  • Node v0.12.4
  • Git 2.7.4
  • Hexo 3.1.1

配置hexo

命令列表:

1
2
3
4
5
6
7
8
9
10
11
12
// 1. 安装
sudo npm install -g hexo
// 2. 初始化
hexo init
npm install // 安装组件
// 3. 生成静态页面
hexo generate
// 4. 启动静态服务
hexo server

目录结构

1
2
3
4
5
6
7
8
9
.
├── _config.yml (配置文件，很多全局配置都在这个文件中)
├── package.json (应用数据。从它可以看出hexo版本信息，以及它所默认或者说依赖的一些组件)
├── scaffolds/ (模版文件)
├── scripts/ (放脚本的文件夹)
├── source/ (文章目录)
|   ├── _drafts
|   └── _posts
└── themes/ (主题)

配置github

建立与你用户名对应的仓库，仓库名必须为your_user_name.github.io,
修改配置文件_config.yml

1
2
3
4
5
6
# Deployment (!其他不需要修改,只需要调整该服务)
# Docs: http://hexo.io/docs/deployment.html
deploy:
  type: git
  repository: git@github.com:yourname/yourname.github.io.git
  branch: master

执行命令

1
2
3
4
// 配置生效
npm install hexo-deployer-git --save
// 站点部署
hexo deploy

常用命令

  • hexo new “postName” 新建文章
  • hexo new page “pageName” #新建页面
  • hexo generate #生成静态页面至public目录
  • hexo server #开启预览访问端口（默认端口4000，’ctrl + c’关闭server）
  • hexo deploy #将deploy目录部署到GitHub

补充：

  • hexo new draft “postName” 新建临时文稿 (不想要的文档也可以临时移动到draft目录下)
  • hexo publish [layout] 发布文稿

QA

  • 异常处理’ERROR Deployer not found: git’
    针对hexo3.0安装后部署github不成功的问题：
    修改配置
    hexo 更新到3.0之后，deploy的type中的github需要改成git。
    yaml语法要求严格，注意空格。建议把github地址那条语句重新手写一遍，冒号后面要有一个空格。

更新部署
安装针对3.0的部署器

1
npm install hexo-deployer-git --save

参考:

http://www.ituring.com.cn/article/198930

http://www.jianshu.com/p/465830080ea9

展开全文 >>

Kindle读书列表

买到kindle还是很有效果的，至少把三体看完了

三体

2015-6-28读完

从零到一，开启商业与未来的秘密

2015-7-7读完

未来简史

2017-2月 读完

把时间当做朋友

2017-3月 读完

菊与刀

2017-3月 读中

深入理解java虚拟机

2017-4月 读完

展开全文 >>

跨域请求时session的获取

服务器端访问设置

参数配置
Access-Control-Allow-Origin，设置允许访问的客户端地址。支持米字符但需要注意的是如果设置，会导致session无法获取，所以只能设置为客户端域名。
Access-Control-Allow-Credentials，同时需要打开访问认证，默认情况下是关闭的。

前端请求

模拟跨域访问，只需要不同的接口即可，所以在本地调试也是可以的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
$("#post-btn").click(function() {
  $.ajax({
    type: "POST",
    url: "http://123.57.3.86:7777",
    //url: "http://127.0.0.1:7777",
    dataType: 'application/x-www-form-urlencoded',
    xhrFields: {
      withCredentials: true
    },
    crossDomain: true,
    beforeSend: function(xhr) {
      xhr.setRequestHeader("Cookie", "pageAccess=2");
      xhr.setRequestHeader("Access-Control-Request-Headers", "Cookie");
    },
    success: function(data, status, xhr) {
      console.log(xhr.getAllResponseHeaders());
      alert('success');
    },
    error: function(xhr) {
      console.log(xhr.getResponseHeader('Cookie'));
      alert('error');
    }
  });
});

注意事项

需要注意的是webkit内核的浏览器并不支持跨域的header数据访问，例如cookie。像是chrome或者safari会禁止读取认为是非法的返回请求。

引用：https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS#Simple_requests

展开全文 >>

创建Gradle项目

创建一个gradle管理的web项目

使用普通的eclipse创建

配置第三方库

1
2
3
repositories {
    mavenCentral()
}

使用maven本地配置，也可以使用第三方库，由于速度原因，我们选择了oscchina的maven镜像

1
2
3
4
5
repositories {
    maven {
      url "http://maven.oschina.net/content/groups/public/"
    }
}

展开全文 >>

异常处理'ERROR Deployer not found:git'

针对hexo3.0安装后部署github不成功的问题：

修改配置

hexo 更新到3.0之后，deploy的type中的github需要改成git。
yaml语法要求严格，注意空格。建议把github地址那条语句重新手写一遍，冒号后面要有一个空格。

更新部署

安装针对3.0的部署器

1
npm install hexo-deployer-git --save

以上

展开全文 >>

新鲜事物爱好者<br><br>全栈工程师<br>