高效并发-线程安全与锁优化

1：线程安全

1.1：Java语言中的线程安全

1. 不可变：被final修饰。
2. 绝对线程安全
3. **相对线程安全：**Java语言中，大部分的线程安全类都属于这种类型，例如Vector、HashTable、Collections的 synchronizedCollection()方法包装的集合
4. 线程兼容：对象本身不是现场安全的，但可以通过在调用端通过正确的使用同步手段来保证在并发环境下安全的使用。
5. 线程对立：无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。

1.2：线程安全的实现方法

1. 互斥同步： 互斥是因，同步是果；互斥是方法，同步是目的。 synchronize和 ReentrantLock(可实现等待可中断，公平锁，锁绑定多个条件)。
2. 非阻塞同步： CAS同步方案：

/**
 1. Atomic变量自增运算测试
 2. 
*/
public class AtomicTest {

    public static AtomicInteger race = new AtomicInteger(0);

    public static void increase() {
        race.incrementAndGet();
    }

    private static final int THREADS_COUNT = 20;

    public static void main(String[] args) throws Exception {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }

        while (Thread.activeCount() > 1)
            Thread.yield();

        System.out.println(race);
    }
}

    /**
     * Atomically increment by one the current value.
     * @return the updated value
     */
    public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

3. 无同步方案
    可重入代码：这种代码也叫作纯代码，可以在代码执行的任意时候去中断，转而去执行另外一段代码（包括递归调用他本身），而在控制权返回后，原来的程序不会出现任何错误。
    线程本地存储：如果一段代码所需要的数据必须与其他 代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。

1.3：锁优化

1. 自旋锁与自适应自旋
2. 锁消除
3. 锁粗化
4. 轻量级锁
5. 偏向锁