上一篇 <<<线程安全与解决方案
下一篇 >>>锁的优化
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 map = new HashMap();
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;
如果begin了之后，没有commit或rollback，则开启新的时候会出现LOCK_WAIT的情况，手动删除命令：kill 11892.
首次执行生成的事务ID 是11892，二次来的时候是11895，在126的时候会提示无法获取到锁超时。
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无锁机制，采用比较法和自旋锁方式，性能上高于多线程加锁。
相关文章链接：
<<<多线程基础
<<<线程安全与解决方案
<<<锁的优化
<<
<<<并发队列
<<