1. 线程的一些基本概念

编写线程安全的代码，其核心在于要对状态访问进行管理，特别是对共享（Shared）和可变（Mutable）状态的访问

（引自：《Java并发编程实战》）

从非正式的意义上来说，对象的状态是指存储在状态变量（例如示例或静态域）中的数据

（引自：《Java并发编程实战》）

1. 共享(Shared)与可变(Mutable)

“共享” 意味着变量可以由多个线程同时访问，二“可变”则意味着变量的值在其生命周期内可以发现变化

（引自：《Java并发编程实战》）

这些可变的变量在被多个线程访问的时候，如何防止这些改变不受控制,解决方法如下：

1、不在线程中共享该状态变量，可以将变量封装到方法中。

2、将状态变量修改为不可变的变量（final）。

3、访问状态变量时使用同步策略。

4、使用原子变量类。

2. 线程安全性

线程安全是一个比较复杂的概念。其核心概念就是正确性。所谓正确性就是某各类的行为与其规范完全一致，即其近似与“所见即所知（we know it when we see it）”。当多个线程访问某各类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

（引自：《Java并发编程实战》）

3. 原子性、可见性、有序性

原子性：一个操作如果是不可分割的，那么这个操作可以被认为是具有原子性的

可见性：
线程可见性是指线程之间的可见性，即一个变量的修改对另外一个线程是可见的，这个变量的修改结果，另外一个线程可以立马知道。

有序性：
有序性指的是数据不相关的变量在并发的情况下，实际执行的结果和单线程的执行结果是一样的，不会因为重排序的问题导致结果不可预知。volatile, final, synchronized，显式锁都可以保证有序性。

2. 关于锁

1. synchronized (内置锁)

java内置的锁机制synchronized 可以用来保证原子性

同步代码块包括两个部分：一个作为锁的对象引用，一个作为由这个锁保护的代码块。以synchronized关键字来修饰的方法就是一种横跨整个方法体的同步代码块，其中该同步代码块的锁就是方法调用所在的对象。静态的synchronized方法已Class对象作为锁

每个java对象都可以用作一个实现同步的锁，这些锁被称为 内置锁(Intrinsic Lock)或者监视器锁(Monitor Lock)。 也就是说内置锁是在java对象上面的，普通代码块还在synchronized(内置锁对象) 。同步方法就是在方法调用对象上加锁的 。

获取【内置锁】的唯一方式就是进入同步锁的代码块或者方法

java的内置锁是一种互斥锁，这就意味着最多只能有一个线程能持有这种锁。当线程A尝试说去线程B持有的锁的时候，线程A必须等待或者阻塞，直到线程B释放这个锁，否则A就一直等待下去。

例用上面的特性，可以实现一个死锁的例子：

public class DeadLockDemo {

    public static void main(String[] args) {

        DeadLockDemo d = new DeadLockDemo();

        Thread a = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread a running...");
                synchronized (d) { // 获得对象d的锁
                    System.out.println("thread a get the lock...");
                    while (true) {
                        // 只是简单的死循环，占用对象d的锁不释放
                    }
                }
            }
        });

        Thread b = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread b running...");
                synchronized (d) { // 获得对象d的锁
                    System.out.println("thread b get the lock...");
                }
            }
        });

        a.start();
        try {
            Thread.sleep(3000); // 确保a先启动，直接顺序start不能保证a比b先启动
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        b.start();
    }
}

// output
/*
thread a running...
thread a get the lock...
thread b running...
*/

上面的例子，线程b一直都没有获得锁，一直等待a释放锁，从而导致死锁

2. 内置锁的重入

内置锁是可以重入的，也就是说某个线程试图获取他自己持有的锁的时候，这个请求会成功。

“重入”意味着获取锁的操作粒度是“线程”，而不是“调用”

例如：

/**
 * 测试锁的重入
 *
 * @author fun
 * @version v0.0.1
 * @date 2017-03-22 12:02
 */
public class LockOverride {

    public static class SuperClass {
        public synchronized void doSomething() {
            System.out.println("super do something....");
        }
    }

    public static class SubClass extends SuperClass {
        @Override
        public synchronized void doSomething() {
            System.out.println("sub do something and call super.doSomething()....");
            super.doSomething();
                        //System.out.println(this.getClass());
            //System.out.println(super.getClass());
        }
    }

    public static void main(String[] args) {
        SubClass sub = new SubClass();
        sub.doSomething();
    }
}

// output
/*
sub do something and call super.doSomething()....
super do something....

*/

可以看到，正常打印了结果，分析一下这个代码，在sub.doSomething的是时候和super.doSomething 的时候都需要获得SubClass对象的锁，如果锁不能重入的话，就会一直等待，出现死锁。（可以sub.soSomething里面的两句打印注释打开，发现两个打印出来的class一样）。

这个是《java并发编程实践》中对所重入的例子，网上也很多地方都是这个例子，但是中文版的翻译中，个人觉得有点问题。实际证明是sub调用doSomething的时候，获取应该是子类实例对象的锁，当运行到super.doSomething的时候，获取的依然是子类对象的锁 。父类此时都没对象（后者说子类向上转型的对象算一个父类对象）

我都觉得上面的例子不够明显，所有我自己根据锁的理解和重入理解，写了个简单点的例子

/**
 * 测试锁的重入
 *
 * @author yehuan
 * @version v0.0.1
 * @date 2017-03-22 12:02
 */
public class LockOverride {

    public static void main(String[] args) {
        LockOverride lo = new LockOverride();

        synchronized (lo) { // 1
            System.out.println("outter get lock on lo....");
            synchronized (lo) { // 2
                System.out.println("inner get lock on lo");
            }
        }
    }
}
//output
/*
outter get lock on lo....
inner get lock on lo

*/

结果很明显，两次(注释1，2)同步块入口，获取锁成功了。但是1和2获取同一个锁，没等1释放，2就获得了。应为锁重入，2的时候已经有获得lo的内置锁了。

但是，如果上面代码变成如下方式，即2出变成一个新的线程呢：

public class LockOverride {

    public static void main(String[] args) {
        LockOverride lo = new LockOverride();

        synchronized (lo) { // 1
            System.out.println("outter get lock on lo...."+System.currentTimeMillis());

            new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (lo) { // 2
                        System.out.println("inner get lock on lo..."+System.currentTimeMillis());
                    }
                }
            }).start();

            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}
// output
outter get lock on lo....1490166261911
inner get lock on lo...1490166266912

这是时候获取锁的1,2两处实际上是两个线程，所有2等到1释放才执行了里面的代码。这也解释了上面说的锁的获取操作粒度是线程而不是调用。对比也解释了前面的例子能获得锁是因为同一个线程+锁的重入