临界资源

序列化访问共享资源，指给定时刻只允许一个任务可以访问到临界资源。

synchronized

在执行 synchronized 所保护的代码块时，它将检查锁是否可用，然后获取锁，执行代码，释放锁。
将要控制的资源包装为一个对象，并把所有访问该对象的方法标记为 synchronized。这时一个任务在调用被标记方法时，其他想要调用synchronized 方法的任务都会被阻塞。

public class Resource {

    private static int count = 0;

     synchronized static public int getCount() {
        count++;
        TimeUnit.MILLISECONDS.sleep(100);// 忽略了 try
        return count;
    }

}

所有的对象实例都自动含有单一的锁（也称为监视器）
临界资源声明为 private 才能防止直接访问数据域。
一个任务可以多次获取对象的锁(所以是递归锁).
针对每个类，也有一个锁（作为 Class 对象的一部分）,所以 synconzied static 可以同步类对象资源。

synchronized (syncObject){

}

同步块能在只获取 this 的锁之外，获取其他对象的内置锁.

Lock

public class Resource {

    private static Lock lock = new ReentrantLock();
    private static int count = 0;

    public static int getCount() {
        try {
            lock.lock();
            count++;
            TimeUnit.MILLISECONDS.sleep(100);
            return count;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return  0;
        } finally {
            lock.unlock();
        }

    }

}

Lock 接口

void lock();

无其他任务持有该锁时，获取该锁并返回，计数置 1
本任务已持有该锁，放回并将计数置 1
其他任务持有该锁，在获取锁前阻塞线程。

void lockInterruptibly() throws InterruptedException;

获得锁前阻塞线程，但接受中断信号。

boolean tryLock();

如果锁是自由的并且被当前线程获取，或者当前线程已经保持该锁，则返回 true
其他任务持有该锁，返回 false (非阻塞)

ReentrantReadWriteLock

public class Resource {

    private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private static int count = 0;

    public static void setCount() {
        lock.writeLock().lock();
        ++count;
        lock.writeLock().unlock();
    }

    public static int getCount() {
        try {
            lock.readLock().lock();
            TimeUnit.MILLISECONDS.sleep(100);
            return count;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return 0;
        } finally {
            lock.readLock().unlock();
        }

    }

}

读取没有线程正在做写操作，且没有线程在请求写操作。
写入没有线程正在做读写操作。

原子性

原子操作 指不能被线程调度机制中断的操作，一旦开始操作，那么一定会在“上下文切换”前完成。
原子性可以应用于所有非 long 和 double 的基本类型上的赋值操作和返回操作，而 long 与 double 使用 volatile 关键字修饰后，也能获取原子性。

volatile

volatile 关键词保证了一个域的可视性, 如果 volatile 域进行写操作，这个数据会立即写入主存中。

非 volatile 域的写入操作不必刷新入主存中，所有不能保证读取该域的值是最新的，所以在多个任务同时访问一个域时，这个域需要声明为 volatile，否则，需要同步来防护值。

ThreadLocal

线程本地储存可以使用相同变量在每个不同的线程都创建不同的存储。

public class ThreadLocalVariableHolder {
    private static ThreadLocal<Integer> value = new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };

    public static Integer getValue() {
        return value.get();
    }

    public static void setValue() {
        value.set(getValue() + 1);
    }
}

在 Main 中执行后能保证每个线程都得到自己的数据。

public class Main {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 3; i++) {
            executorService.execute(new Runnable() {
                private int count = 3;
                @Override
                public void run() {
                    while (count > 0){
                        count --;
                        ThreadLocalVariableHolder.setValue();
                        System.out.println(Thread.currentThread() + ": " + ThreadLocalVariableHolder.getValue());
                        Thread.yield();
                    }
                }
            });
        }
        executorService.shutdown();
    }

}

Thread[pool-1-thread-1,5,main]: 1
Thread[pool-1-thread-3,5,main]: 1
Thread[pool-1-thread-2,5,main]: 1
Thread[pool-1-thread-3,5,main]: 2
Thread[pool-1-thread-2,5,main]: 2
Thread[pool-1-thread-1,5,main]: 2
Thread[pool-1-thread-3,5,main]: 3
Thread[pool-1-thread-1,5,main]: 3
Thread[pool-1-thread-2,5,main]: 3