1.悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系 统不会修改数据）。

2、乐观锁（ Optimistic Locking ） 相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。 而乐观锁机制在一定程度上解决了这个问题。乐观锁，大多是基于数据版本（ Version ）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个 “version” 字段来实现。读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据.

============================

线程资源同步机制

main memory操作：read(由main memory发起，读取变量值),write(将working memory的值写入main memory中),lock(线程发起，同步操作main memory)和unlock(线程发起，同步操作main memory)
working memory操作：use(复制到线程),assign(赋值：复制到working memory中),load(main memory复制到working memory中),store(从working memory中复制到main memory中),lock和unlock

synchronized可直接写在方法或对象上

volatile 控制线程中对象的可见性，定义为volatile变量，线程不会从main memory复制到work memory中，直接在main memorry中操作
有Synchronized，lock/unlock及volatile 控制多线程程序中资源的竞争，并行-->串行

线程交互机制：基于object 的wait/notify/notifyAll


集合包：Collection和Map两个接口的实现类，Collection存放单个对象，Map存放key-value

List:      LinkedList双向链表机制，ArrayList
Vector 是基于Synchronized实现的线程安全的ArrayList
Vector: Stack(LIFO  push,pop,peek)

Set:   HashSet,TreeSet,
Map: HashMap,TreeMap,

java.util.concurrent包

ConcurrentHashMap是线程安全的HashMap的实现

CopyOnWriteArrayList线程安全，读操作时无锁的ArrayList；ReentrantLock锁

CopyOnWriteArraySet基于CopyOnWriteArrayList实现，add时还要遍历是否存在，因此性能略低于CopyOnWriteArrayList

ArrayBlockingQueue是基于数组，先进先出，线程安全的集合类，可实现指定时间的阻塞读写，固定大小数组，ReentrantLock和Condition

基于cas，拆分锁，voliate，AbstractQueuedSynchronizer类实现
减少高并发时的竞争，避免出现不一致及资源锁竞争

CAS ：compare and swap 区别于synchronouse同步锁的一种乐观锁；
CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。
CAS通过调用JNI的代码实现的。JNI:Java Native Interface为JAVA本地调用，允许java调用其他语言。
而compareAndSwapInt就是借助C来调用CPU底层指令实现的。
CAS 缺点：1.ABA问题，通过版本解决 2.循环时间开销大 3.只能保证一个共享变量的原子操作

CPU锁：1. 自动保证基本内存操作的原子性 2.总线锁 3.缓存锁


AtomicInteger是一个支持原子操作的Integer类

ThreadPoolExecutor    workQueue.poll or take  ?
高性能
SynchronousQueue.offer   poll
SynchronousQueue是BlockingQueue的一种实现

缓冲执行
ArrayBlockingQueue
LinkedBlockingQueue



newFixedThreadPool(int) 固定大小的线程池;LinkedBlockingQueue

newSingleThreadExecutor() 大小为1单位的固定线程池;LinkedBlockingQueue

newCachedThreadPool() 0-最大整型数 keepAliveTime=1分钟；队列是SynchronousQueue

newScheduledThreadPool(int)keepAliveTime=0；队列是DelayedWorkQueue；适用于异步操作超时回调
ScheduledThreadPoolExecutor可执行Callable的task


ReentrantLock

FutureTask 是Future和Callable的结合体，

Semaphore 控制创建的连接个数，信号灯，分 单值(单线程) 和 多值(多线程)，停车场的看门人，wait和Release释放 ;公平模式，先进先出；可用于死锁恢复的场合

CountDownLatch

CyclicBarrier确保所有线程开始工作，当await达到设定的数量后才往下执行，基于ReentrantLock和Condition来实现

ReentrantLock 一把锁
ReentrantReadWriteLock 读 写锁，基于AbstractQueuedSynchronizer


==========================================
信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施, 它负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。

概念
Semaphore分为单值和多值两种，前者只能被一个线程获得，后者可以被若干个线程获得。

以一个停车场运作为例。为了简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆不受阻碍的进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一辆车离开停车场，看门人得知后，打开车拦，放入一辆，如果又离开两辆，则又可以放入两辆，如此往复。

在这个停车场系统中，车位是公共资源，每辆车好比一个线程，看门人起的就是信号量的作用。

更进一步，信号量的特性如下：信号量是一个非负整数（车位数），所有通过它的线程（车辆）都会将该整数减一（通过它当然是为了使用资源），当该整数值为零时，所有试图通过它的线程都将处于等待状态。在信号量上我们定义两种操作： Wait（等待） 和 Release（释放）。 当一个线程调用Wait（等待）操作时，它要么通过然后将信号量减一，要么一直等下去，直到信号量大于一或超时。Release（释放）实际上是在信号量上执行加操作，对应于车辆离开停车场，该操作之所以叫做“释放”是因为加操作实际上是释放了由信号量守护的资源。

在java中，还可以设置该信号量是否采用公平模式，如果以公平方式执行，则线程将会按到达的顺序（FIFO）执行，如果是非公平，则可以后请求的有可能排在队列的头部。
JDK中定义如下：
Semaphore(int permits, boolean fair)
　　创建具有给定的许可数和给定的公平设置的Semaphore。

Semaphore当前在多线程环境下被扩放使用，操作系统的信号量是个很重要的概念，在进程控制方面都有应用。Java并发库Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。比如在Windows下可以设置共享文件的最大客户端访问个数。

Semaphore实现的功能就类似厕所有5个坑，假如有10个人要上厕所，那么同时只能有多少个人去上厕所呢？同时只能有5个人能够占用，当5个人中 的任何一个人让开后，其中等待的另外5个人中又有一个人可以占用了。另外等待的5个人中可以是随机获得优先机会，也可以是按照先来后到的顺序获得机会，这取决于构造Semaphore对象时传入的参数选项。单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”，这可应用于死锁恢复的一些场合。

package cn.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * 信号量
 */
public class SemaphoreTest {
    public static void main(String[] args) {
        // 线程池
        ExecutorService exec = Executors.newCachedThreadPool();
        // 只能5个线程同时访问
        final Semaphore semp = new Semaphore(5);
        // 模拟20个客户端访问
        for (int index = 0; index < 50; index ) {
            final int NO = index;
            Runnable run = new Runnable() {
                public void run() {
                    try {
                        // 获取许可
                        semp.acquire();
                        System.out.println("Accessing: " NO);
                        Thread.sleep((long) (Math.random() * 10000));
                        // 访问完后，释放
                        semp.release();
                        //availablePermits()指的是当前信号灯库中有多少个可以被使用
                        System.out.println("-----------------" semp.availablePermits());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            exec.execute(run);
        }
        // 退出线程池
        exec.shutdown();
    }
}