上一篇 <<<线程安全与解决方案
下一篇 >>>锁的优化

synchronized--悲观锁、独占锁、互斥锁、排他锁
Lock分为ReentrantLock、读写锁、公平锁和非公平锁，底层用了CAS无锁机制(自旋锁)。
ReentrantLock锁底层使用AQS原理实现。

自旋锁与互斥锁的区别

互斥锁：线程会从sleep(加锁)---->running(解锁)，过程中有上下文的切换，cpu的抢占，信号的发送等开销。【互斥等待、阻塞、悲观锁】
自旋锁：线程一直是running(加锁---->解锁)，死循环检测锁的标志位，机制不复杂【属于乐观锁】

重入锁

也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。
** synchronized（重量级） 和 ReentrantLock(轻量级)，他们都属于重入锁。**

public  synchronized void get() {
    System.out.println("name:" + Thread.currentThread().getName() + " get();");
    set();
}
public synchronized  void set() {
    System.out.println("name:" + Thread.currentThread().getName() + " set();");
}

public void run() {
    get();
}

ReentrantLock lock = new ReentrantLock();
public void get() {
    lock.lock();
    System.out.println(Thread.currentThread().getId());
    set();
    lock.unlock();
}
public void set() {
    lock.lock();
    System.out.println(Thread.currentThread().getId());
    lock.unlock();
}

以上get和set方法调用的时候，都使用了同步锁，他们会自动传入，也就是类似于递归锁，不会互相排斥。

读写锁

Lock锁的子类
对一个共享资源，可以同时读，但在写的时候不可以进行其他的读写，所以读-读能共存，读-写不能共存，写-写不能共存

public class ReadWriteLockTest {
    static Map<String, Object> map = new HashMap<String, Object>();
    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock r = rwl.readLock();
    static Lock w = rwl.writeLock();

    // 获取一个key对应的value
    public static final Object get(String key) {
        r.lock();
        try {
            System.out.println(Thread.currentThread().getName()+" 正在做读的操作,key:" + key + " 开始");
            Thread.sleep(100);
            Object object = map.get(key);
            System.out.println(Thread.currentThread().getName()+" 正在做读的操作,key:" + key + " 结束");
            System.out.println();
            return object;
        } catch (InterruptedException e) {

        } finally {
            r.unlock();
        }
        return key;
    }

    // 设置key对应的value，并返回旧有的value
    public static final Object put(String key, Object value) {
        w.lock();
        try {

            System.out.println(Thread.currentThread().getName()+" 正在做写的操作,key:" + key + ",value:" + value + "开始.");
            Thread.sleep(100);
            Object object = map.put(key, value);
            System.out.println(Thread.currentThread().getName()+" 正在做写的操作,key:" + key + ",value:" + value + "结束.");
            System.out.println();
            return object;
        } catch (InterruptedException e) {

        } finally {
            w.unlock();
        }
        return value;
    }
    public static void main(String[] args) {
        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    ReadWriteLockTest.put(i + "", i + "");
                }

            }
        }).start();
        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    ReadWriteLockTest.get(i + "");
                }

            }
        }).start();
    }
}

公平锁和非公平锁

相同点：都属于Lock下面的锁，都基于锁内部维护的一个双向链表，表结点Node的值就是每一个请求当前锁的线程。
不同点：
公平锁——在做cas操作的是时候加上!hasQueuedPredecessors()必须遵循公平竞争，每次都是依次从队首取值，有新线程加入时自动加入队列的尾部【队列按顺序执行】
非公平锁——有任意新的线程妄图获取锁，都有很大的几率直接获取到锁，【每次不按顺序执行，看谁能先抢到】

New ReentramtLock()(true)---公平锁
New ReentramtLock()(false)---非公平锁

非公平锁效率比公平锁效率要高。Synchronized是非公平锁

悲观锁与乐观锁

悲观锁：每次取数据时都认为其他线程会修改，所以都会加锁（读锁、写锁、行锁等，依靠数据库实现）
在Java中的synchronized和mysql里的行锁都属于悲观锁

乐观锁：
a、取数据的时候不会上锁
b、修改数据的时候，会去判断数据是否已经有过变更【版本号机制或CAS操作实现】
场景：
版本号机制：update table set x=x+1, version=version+1 where id=#{id} and version=#{version};
CAS操作机制：【（本地内存值==主内存预期值）？新值更新：迭代循环等待】----也叫自旋

乐观锁和悲观锁的区别
乐观锁会重试，不会阻塞
悲观锁会阻塞
乐观锁效率会高很多

独占锁与共享锁

独占锁：在多线程中，只允许有一个线程获取到锁，其他线程都会等待。
共享锁：多个线程可以同时持有锁，例如ReentrantLock读写锁。读读可以共享、写写互斥、读写互斥、写读互斥。
读的时候是多线程同时执行，写的时候是单个线程执行完毕了之后才可以下一个线程执行。

行锁

在mysql中多个线程对同一行数据做写操作的时候，默认会触发行锁的机制，最终只有一个线程能对该行数据做写的操作，其他线程会被等待。
mysql中innodb引擎默认为行锁。
Begin--触发行锁机制，获取锁的权限
Commit/Rollback---提交/回滚数据，同时释放锁

查看锁的语句：
Select * from information_schema.innodb_trx;

锁的效果

tips:MySQL更多的锁情况请参考：MySQL的表锁行锁及间隙锁

原子类

原子变量类相当于一种泛化的volatile变量，能够支持原子的和有条件的读-改-写操作，处于java.util.concurrent.atomic包中，提供了compareAndSet方法，底层使用的也是CAS无锁机制
原子操作类大致可以分为4类：原子更新基本类型、原子更新数组类型、原子更新引用类型、原子更新属性类型。
常见原子类：
AtomicBoolean
AtomicInteger
AtomicLong
AtomicReference

AtomicInteger atomic = new AtomicInteger();
atomic.incrementAndGet();

多线程使用的锁和原子类的锁有什么区别

多线程锁使用Synchronized和lock的锁，多线程加锁属于悲观锁，程序可能会产生阻塞和等待。
Atomic保证线程安全采用乐观锁机制，程序不会产生阻塞和等待，底层采用了CAS无锁机制，采用比较法和自旋锁方式，性能上高于多线程加锁。

相关文章链接：
<<<多线程基础
<<<线程安全与解决方案
<<<锁的优化
<<<Java内存模型(JMM)
<<<Volatile解决JMM的可见性问题
<<<Volatile的伪共享和重排序
<<<CAS无锁模式及ABA问题
<<<Synchronized锁
<<<Lock锁
<<<AQS同步器
<<<Condition
<<<CountDownLatch同步计数器
<<<Semaphore信号量
<<<CyclicBarrier屏障
<<<线程池
<<<并发队列
<<<Callable与Future模式
<<<Fork/Join框架
<<<Threadlocal
<<<Disruptor框架
<<<如何优化多线程总结