线程安全基本概念

---

内置锁

每个Java对象都可以用作一个同步锁，这些锁被称为内置锁 或 监视器锁。线程在进入同步代码块时会自动获得锁，并在退出同步代码块时自动释放锁（无论是正常退出还是异常退出）。

Java的内置锁是互斥锁，也就是说同时只有一个线程能拥有这个锁。

重入

当线程A请求线程B持有的锁的时候，线程A发出的请求会被阻塞。但是，当线程A请求自己持有的锁的时候，这个请求并不会被阻塞，这种形象就是锁的“重入”。内置锁是可以重入的。这也意味着获取锁的操作是 线程级别的，而不是 调用级别的。

利用重入的特性，我们可以为每个锁关联一个计数器(counter)，当锁没有被任何线程持有时counter=0。当有线程请求获取锁时，JVM记录下锁的持有者线程，并将counter=1。如果同一个线程再次来获取锁，counter再递增1。而当线程退出同步代码块时，counter相应的递减。当counter=0时，这个锁将被释放。

锁的重入避免了一部分死锁行为，并提升了加锁行为的封装性,如下所示：

public class Drawer {
    public synchronized void doanything() {
        System.out.println("Drawer do anything...");
    }
}

----

public class SmallDrawer extends Drawer {

    @Override
    public synchronized void doanything() {
        System.out.println("Samll Drawer do anything");
        super.doanything();
    }
}

这里子类的调用并不会产生死锁。（锁的重入）

可见性

当一个线程修改了对象的状态后，其他线程能够看到发生的状态变化。为了确保这一特性，我们通常需要使用同步

重排序

public class NoVisibility {
    private static boolean ready;
    private static int number;

    private static class ReaderThrad extends Thread {
        @Override
        public void run() {
            while (!ready) {
                System.out.println("yield");
                Thread.yield();
            }
            System.out.println("number = " + number);
        }
    }

    public static void main(String[] args) {
        new ReaderThrad().start();
        number = 12;
        ready = true;
    }
}

这段程序可能会持续循环下去，因为读线程可能永远看不到ready的值。也可能输出0，因为程序可能看到了写入的ready值，却没有看到之后写入number的值。

在没有同步的情况下，编译器、处理器以及运行时等都可能对操作的执行顺序进行一些意想不到的调整。

在这里，当主线程首先写入number，然后在没有同步的情况下写入ready，那么读线程看到的顺序可能与写入的顺序相反。

加锁与可见性

内置锁可以用于确保某个线程以一种可预测的方式来查看另一个线程的执行结果。例如，当A线程执行某个同步代码块时，线程B随后进入由同一个线程锁保护的的同步代码块，在这种情况下可以保证，在锁被释放之前，A看到的变量值在B获得锁后同样可以由B看到。这也就确保了某个线程写入该变量的值dui yu对于其他线程来说是可见的。

Volatile变量

Volatile变量事Java提供的一种弱的同步机制，用于确保将变量的更新操作通知到其他线程。

把变量声明成Volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作重排序。也不会被缓存在寄存器或者对其他线程不可见的地方。

访问Volatile变量时不会执行加锁操作，因此也不会执行线程阻塞，因此它是一种比sychronized关键字更轻量级的同步机制。

Volatile变量的可见性 当线程A首先写入一个volatile变量并且线程B随后读取该变量时，在写入变量之前对A可见的变量，在B读取到变量时，对B也是可见的。因此从内存的角度来看，写入volatile变量相当于退出同步代码块，而读取volatile变量相当于进入同步代码块。

发布与逸出

“发布”一个对象指的是使对象能够在当前作用域之外的代码中使用。（例如：将一个指向该对象的引用保存到其他代码可访问的地方，或者一个非私有的方法中返回该对象的引用）

“逸出”指的是对象在构造完成之前就发布了该对象，就会破坏线程安全性，发布了不该发布的对象。

线程封闭

当访问共享的可变数据时，通常需要使用同步。一种避免使用同步的方式就是不共享数据。如果仅在单线程内部访问数据，就不需要同步。

维持线程封闭的一种规范方法是使用ThreadLocal，这个类可以使线程中的某个值与保存值的对象关联起来。

public class ThreadLocalThread {
    /**
     * 该类在此代表了一些资源
     */
    static class ConnectionSource {
        

        public ConnectionSource() {

        }
        
    }

    private static ThreadLocal<ConnectionSource> connectionHolder = new ThreadLocal<ConnectionSource>(){
        @Override
        protected ConnectionSource initialValue() {
            return new ConnectionSource();
        }
    };
    
    public static ConnectionSource getConnection() {
        return connectionHolder.get();
    }
}

当某个线程初次调用ThreadLocal.get()方法时，就会调用initValue()来获取初始值，从概念上可以将ThreaLocal<T>看成是Map<Thread, T>，其中保存了该线程中特有的的值。不过，ThreadLocal并非简单的Map，保存在Thread中的特定值，在线程终止时，会被回收。