java 读锁有什么用_Java锁的理解

目录：

1.为什么要使用锁？

2.锁的类型？

1.为什么要使用锁？

通俗的说就是多个线程，也可以说多个方法同时对一个资源进行访问时，如果不加锁会造成线程安全问题。举例：比如有两张票，但是有5个人进来买，买了一张票数就减1，在他们进门的时候会判断是否还有票，但是在他们进门的那一刻，票还一张都没有买走。但是他们都已经进门了，过了是否有票的校验了，所以最后票数为被减成负3，显然是不对的，因为票不能小于0，所以需要加一个锁，在同一时刻只能有一个人进门去买票，也就是同一个资源同一个时刻只能有一个线程进行操作，这样在第三个人进门的时候就能判断出票数已经卖完了，不会产生票数成负数的情况。

2.锁的类型

1.重入锁

重入锁也叫递归锁，外层的函数获取锁后，如果里面的函数仍然有获取锁的代码，里面的函数就不用重新获取锁了。 比如：ReentrantLock 和 synchronized

比如：

public class Test implementsRunnable {public synchronized voidget() {

System.out.println("name:" + Thread.currentThread().getName() + " get();");

set();

}public synchronized voidset() {

System.out.println("name:" + Thread.currentThread().getName() + " set();");

}

@Overridepublic voidrun() {

get();

}public static voidmain(String[] args) {

Test ss= newTest();newThread(ss).start();newThread(ss).start();newThread(ss).start();}

}

public class Test02 extendsThread {

ReentrantLock lock= newReentrantLock();public voidget() {

lock.lock();

System.out.println(Thread.currentThread().getId());

set();

lock.unlock();

}public voidset() {

lock.lock();

System.out.println(Thread.currentThread().getId());

lock.unlock();

}

@Overridepublic voidrun() {

get();

}public static voidmain(String[] args) {

Test ss= newTest();newThread(ss).start();newThread(ss).start();newThread(ss).start();

}

}

View Code

2.读写锁

读写锁：既是排他锁，又是共享锁。读锁，共享锁，写锁：排他锁

public classCache {static Map map = new HashMap();static ReentrantReadWriteLock rwl = newReentrantReadWriteLock();static Lock r =rwl.readLock();static Lock w =rwl.writeLock();//获取一个key对应的value

public static finalObject 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();returnobject;

}catch(InterruptedException e) {

}finally{

r.unlock();

}returnkey;

}//设置key对应的value，并返回旧有的value

public static finalObject 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();returnobject;

}catch(InterruptedException e) {

}finally{

w.unlock();

}returnvalue;

}//清空所有的内容

public static final voidclear() {

w.lock();try{

map.clear();

}finally{

w.unlock();

}

}public static voidmain(String[] args) {new Thread(newRunnable() {

@Overridepublic voidrun() {for (int i = 0; i < 10; i++) {

Cache.put(i+ "", i + "");

}

}

}).start();new Thread(newRunnable() {

@Overridepublic voidrun() {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无锁机制(Compare and Swap)

这种模式在多核cpu的情况下，完全没有锁竞争带来的系统开销，也没有线程间频繁调度带来的开销，因此，它要比基于锁的方式拥有更优越的性能。

什么是CAS？

CAS 操作包含三个操作数 —— 内存位置(V)、预期原值(A)和新值(B)。 当变量的内存位置的值 V 等于原值，说明在设值的时候没有其他线程去改变他的值，这时候将值设置为新值B。

存在的问题？

ABA问题：当线程A在判断内存位置的值V是否等于原值之前，线程B将值改为了B，线程C又将值改为了A。这时候A线程在比较内存位置的值V是否等于原值时，这个条件返回true，但是这个值中途已经改变过了，

解决方法，在值改变的时候加上版本号。即线程A拿到的内存位置V的值为1A，线程B修改为了2B，线程C修改为了3A，这时候内存位置值1A不等于有3A，因此就不会存在ABA问题。

循环时间长，开销大：当长时间获取不到资源的场景，自旋锁会一直循环，比较占用cpu资源。 可以根据一定的业务场景，让获取资源的操作做一些延迟。

对于多个共享变量的问题：对于多个共享变量，我可以把多个共享变量放于一个对象中，当做一个共享变量来处理。

6.AQS

7.分布式锁

在分布式的场景下，如果是单数据库的情况下，某些场景下还可以用乐观锁，大部分场景想在不用的jvm中保证数据的同步，安全问题，还是需要使用缓存，数据，zookepper等实现分布式锁。