Java锁的理解
- 2020 年 3 月 11 日
- 筆記
目录：
1.为什么要使用锁？
2.锁的类型？
1.为什么要使用锁？
通俗的说就是多个线程，也可以说多个方法同时对一个资源进行访问时，如果不加锁会造成线程安全问题。举例：比如有两张票，但是有5个人进来买，买了一张票数就减1，在他们进门的时候会判断是否还有票，但是在他们进门的那一刻，票还一张都没有买走。但是他们都已经进门了，过了是否有票的校验了，所以最后票数为被减成负3，显然是不对的，因为票不能小于0，所以需要加一个锁，在同一时刻只能有一个人进门去买票，也就是同一个资源同一个时刻只能有一个线程进行操作，这样在第三个人进门的时候就能判断出票数已经卖完了，不会产生票数成负数的情况。
2.锁的类型
1.重入锁
重入锁也叫递归锁，外层的函数获取锁后，如果里面的函数仍然有获取锁的代码，里面的函数就不用重新获取锁了。 比如：ReentrantLock 和 synchronized
比如：
public class Test implements Runnable { 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();"); } @Override public void run() { get(); } public static void main(String[] args) { Test ss = new Test(); new Thread(ss).start(); new Thread(ss).start(); new Thread(ss).start(); } }
public class Test02 extends Thread { 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(); } @Override public void run() { get(); } public static void main(String[] args) { Test ss = new Test(); new Thread(ss).start(); new Thread(ss).start(); new Thread(ss).start(); } }
View Code
2.读写锁
读写锁：既是排他锁，又是共享锁。读锁，共享锁，写锁：排他锁
public class Cache { 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("正在做读的操作,key:" + key + " 开始"); Thread.sleep(100); Object object = map.get(key); System.out.println("正在做读的操作,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("正在做写的操作,key:" + key + ",value:" + value + "开始."); Thread.sleep(100); Object object = map.put(key, value); System.out.println("正在做写的操作,key:" + key + ",value:" + value + "结束."); System.out.println(); return object; } catch (InterruptedException e) { } finally { w.unlock(); } return value; } // 清空所有的内容 public static final void clear() { w.lock(); try { map.clear(); } finally { w.unlock(); } } public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 10; i++) { Cache.put(i + "", i + ""); } } }).start(); new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 10; i++) { Cache.get(i + ""); } } }).start(); } }
View Code
3.悲观锁
总是假设最坏的情况，每次取数据时都认为其他线程会修改，所以都会加锁（读锁、写锁、行锁等），当其他线程想要访问数据时，都需要阻塞挂起。可以依靠数据库实现，如行 锁、读锁和写锁等，都是在操作之前加锁，在Java中，synchronized的思想也是悲观锁。
4.乐观锁
在更新数据的时候会判断其他线程是否修改过数据，一般通过version版本号控制。
具体实现，就是在数据表加一个version字段，每次更新的时候都会与上一次取出数据的版本号做比较。
① 线程A 和 线程B 同时取出同一条数据，这是数据的version为0.
② 线程A 取出数据的时候version = 0 ， 这时候线程A走完业务，需要更新数据，这是会 update tabel set version = version + 1 where id = {id} and version = #{取数 据时的version}
③ 这时线程B 也走完业务去更新这条数据，这时执行update tabel set version = version + 1 where id = {id} and version = #{取出数据时的version} 这时候取出数据时 的version为0但是线程这条数据的version已经为1了。所以会更新失败。在这个情况下可以写一个循环，重新去出该条数据进行更新，知道这条数据更新成功为止。
5.CAS无锁机制
这种模式在多核cpu的情况下，完全没有锁竞争带来的系统开销，也没有线程间频繁调度带来的开销，因此，它要比基于锁的方式拥有更优越的性能。
算法过程：CAS算法的过程是这样：它包含三个参数CAS(V,E,N): V表示要更新的变量，E表示预期值，N表示新值。仅当V值等于E值时，才会将V的值设为N，如果V值和E值不 同，则说明已经有其他线程做了更新，则当前线程什么都不做。最后，CAS返回当前V的真实值。
6.分布式锁
在分布式的场景下，如果是单数据库的情况下，某些场景下还可以用乐观锁，大部分场景想在不用的jvm中保证数据的同步，安全问题，还是需要使用缓存，数据，zookepper等实现分布式锁。
