JAVA中锁的介绍

公平锁和非公平锁

公平锁： 公平锁，就是很公平，在并发环境中每个线程在获取锁时首先会查看此锁维护的等待队列，如果是空说明自己是第一个就会获得到锁，如果不为空就会加入到队列中等待排队。

非公平锁： 非公平锁上来就尝试占有锁，如果尝试失败，才会加入到队列中。

多线程获取锁并不是按照申请锁顺序，有可能后申请锁的线程比先申请锁的线程优先获取锁，有可能会造成优先级反转或者饥饿现象（等了好久都没获得到锁非常饥饿）。

java.util.concurrent包中的ReentrantLock类，可以在这个类中的构造方法中传入一个Boolean类型值，如果是true代表公平锁，如果false是非公平锁，什么也不传默认是非公平锁。

非公平锁的优点在于比公平锁的吞吐量要大，并发效率要高。

Synchronized就是典型的非公平锁。

可重入锁（又名递归锁）

理论：是指同一线程外层函数获得到锁之后，内层函数会自动获得到锁。 其实就是同步方法中调用另一个同步方法，线程获取到外层函数锁，内层锁自动获取到。 例如：代码如下

public class Reentrant { public static synchronized void method(){ System.out.println(Thread.currentThread().getName()+"mthood.."); method01(); } public static synchronized void method01(){ System.out.println(Thread.currentThread().getName()+"method01."); } public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { Reentrant.method(); } },"t1").start(); new Thread(new Runnable() { @Override public void run() { Reentrant.method(); } },"t2").start(); } } 输出结果： t1mthood...... t1method01..... t2mthood...... t2method01.....

最典型的可重入锁除了Synchronized外还有ReentrantLock,上边代码是Synchronized重入锁的代码。

ReentrantLock代码演示。

public class Reentrant01 { static Lock lock = new ReentrantLock(); public static void set(){ lock.lock(); try { System.out.println(Thread.currentThread().getName()+"set..."); get(); } finally { lock.unlock(); } } public static void get(){ lock.lock(); try { System.out.println(Thread.currentThread().getName()+"get......"); } finally { lock.unlock(); } } public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { Reentrant01.set(); } },"t3").start(); new Thread(new Runnable() { @Override public void run() { Reentrant01.set(); } },"t4").start(); } } 结果： t3set... t3get...... t4set... t4get......

注意：lock.lock()几次就unlock()几次，只要匹配就不会出现死锁。 可重入锁避免了死锁的发生。

自旋锁（CAS思想）

尝试获取锁的线程不会阻塞，而是采用循环的方式尝试获取锁，减少了线程上下文切换所消耗的性能，但同样如果循环次数过度会占用CPU资源。

循环+CAS(比较并交换)的思想。

AtomicReference（原子引用）类 手写自旋锁代码如下：

public class zixuan { AtomicReference<Thread> atomicReference = new AtomicReference<>(); public void Mylock(){ do{ Thread thread = Thread.currentThread(); //获得当前线程 }while(!atomicReference.compareAndSet(null,thread));//比较并交换 } public void UnMylock(){ //看内存中是不是当前线程对象，如果是把它设置为null atomicReference.compareAndSet(Thread.currentThread(),null); } }

独占锁

指该锁一次只能被一个线程所持有。对ReentrantLock和Synchronized而言都是独占锁。

共享锁

指该锁可以被多个线程所持有。 对ReentrantReadWriteLock其实就是共享锁，其写锁是独占锁，该锁的共享锁保证并发读是非常高效的。 读读能共存（读的时候线程可以争抢） 读写互斥 写写互斥

代码如下：

/** * 读写锁，读写共存，读写同时进行， * 读和写共用一把锁，写可以保证写的原子性，中间没有加塞的现象，都是一个线程一个线程执行。 * 读一起读，提高并发率 */ public class ReentrantReadWLock { public volatile Map<String,Object> map = new HashMap<>(); ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock(); /** * 写方法 */ public void put(String key,Object val){ reentrantReadWriteLock.writeLock().lock(); //加入写锁 try { System.out.println(Thread.currentThread().getName()+"正在写..."); map.put(key,val); System.out.println(Thread.currentThread().getName()+"写完成..."); }finally { reentrantReadWriteLock.writeLock().unlock(); } } /** * 读方法 */ public void get(String key){ reentrantReadWriteLock.readLock().lock(); //加入读锁 try { System.out.println(Thread.currentThread().getName()+"正在读..."); map.get(key); System.out.println(Thread.currentThread().getName()+"读完成..."); }finally { reentrantReadWriteLock.readLock().unlock(); } } public static void main(String[] args) { ReentrantReadWLock reentrantReadWLock = new ReentrantReadWLock(); for (int i=1;i<=5;i++){ int temp = i; new Thread(new Runnable() { @Override public void run() { reentrantReadWLock.put(temp+"",temp+""); } },String.valueOf(i)).start(); } for (int i=1;i<=5;i++){ int temp = i; new Thread(new Runnable() { @Override public void run() { reentrantReadWLock.get(temp+""); } },String.valueOf(i)).start(); } } ｝ 结果： 1正在写... 1写完成... 2正在写... 2写完成... 3正在写... 3写完成... 4正在写... 4写完成... 5正在写... 5写完成... 1正在读... 2正在读... 3正在读... 5正在读... 4正在读... 1读完成... 2读完成... 3读完成... 5读完成... 4读完成...

总结：

ReentrantReadWriteLock是共享锁，这个类里面有ReadLock()方法获得读锁，WriteLock()方法获得写锁。写的时候只能一个线程一个线程获得锁，中间不能加塞，保证写的原子性。读的时候可以多线程一起读，提高并发率。

举个例子： 写的时候为保证数据的原子性，在写的时候上锁只能由一个线程来写，写完了再由另一个线程写。不能正在写的时候被另一个线程加塞，破坏写的数据的原子性。而读就不需要，读可以多个线程一起读，就好比飞机场的公示牌如果只允许一个人一个人读岂不是太慢了，大家一起读提高效率，一个人表示一个线程。