Mysql独占与共亨_并发编程-锁的深入化

上一篇 <<

下一篇 >>>锁的优化

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无锁机制，采用比较法和自旋锁方式，性能上高于多线程加锁。