Java锁

墨蓝 2022-11-04 01:49 111阅读 0赞

### 文章目录 ###

*  一、公平锁和非公平锁
 *  二、可重入锁（独占锁）
 *  三、自旋锁
 *  四、独占锁、共享锁

# 一、公平锁和非公平锁 #

*  公平锁：是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到；
 *  非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。在高并发的情况下，有可能会造成优先级反转或者饥饿现象

> Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。  
> 对于Synchronized而言，也是一种非公平锁。

# 二、可重入锁（独占锁） #

**可重入锁（也就是递归锁）：指的是同一个线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。**

**也就是说，线程可以进入任何一个它已经拥有的锁所有同步着的代码块。**

public class RenentryLockDemo { 
        public static void main(String[] args) { 
            Phone phone = new Phone();
            for (int i = 0; i < 10; i++) { 
                new Thread(() -> { 
                    phone.sendSMS();
                }).start();
            }
        }
    }
    class Phone { 
        public synchronized void sendSMS() { 
            System.out.println(Thread.currentThread().getName() + "\t has sendSMS");
            sendEmail();
        }
    
        public synchronized void sendEmail() { 
            System.out.println(Thread.currentThread().getName() + "\t has sendEmail");
        }
    }

打印结果如下图，验证可重入锁的特性。  
![在这里插入图片描述][20210301152913148.png]  
`ReentrantLock`/`Synchronized`就是一个典型的可重入锁，可重入锁最大的作用是避免死锁 。

> 所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。  
> 如下图所示，如果此时有一个线程`A`已经获取了锁`A`等待获取锁`B`，而在此同时又有另外一个线程已经获取了锁`B`等待获取锁`A`，这种情况会造成线程的死锁。  
> ![在这里插入图片描述][20210301154754615.png]

# 三、自旋锁 #

**自旋锁：是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁  
，这样的好处是减少线程上下切换的消耗，缺点是循环会消耗`CPU`。**

public class SpinLockDemo { 
    
        AtomicReference<Thread> reference = new AtomicReference<>();
    
        public void enLock() { 
            Thread thread = Thread.currentThread();
            while (!reference.compareAndSet(null, thread)) { 
    
            }
            System.out.println(thread.getName() + "->加锁");
        }
    
        public void unLock() { 
            Thread thread = Thread.currentThread();
            while (!reference.compareAndSet(thread, null)) { 
    
            }
            System.out.println(thread.getName() + "->解锁");
        }
    
        public static void main(String[] args) { 
            SpinLockDemo spinLock = new SpinLockDemo();
            for (int i = 0; i < 5; i++) { 
                new Thread(() -> { 
                    spinLock.enLock();
                    try { 
                        TimeUnit.SECONDS.sleep((long) 0.5);
                    } catch (InterruptedException e) { 
                    }
                    spinLock.unLock();
                }).start();
            }
        }
    }

打印结果如下图，验证自旋锁的特性。  
![在这里插入图片描述][20210301172107359.png]

# 四、独占锁、共享锁 #

*  独占锁：指该锁一次只能被一个线程所持有。对`ReentrantLock`和`Synchronized`而言都是独占锁。
 *  共享锁：指该锁可被多个线程所持有。对`ReentrantReadWriteLock`，其读锁是共享锁，其写锁是独占锁。读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。

class MyCache<T> { 
        private Map<String, T> map = new HashMap<>();
        private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    
        public void get(String key) { 
            readWriteLock.readLock().lock();
            T t = null;
            try { 
                System.out.println(Thread.currentThread().getName() +
                        "\t 正在读取：" + key+"\t-----------------------");
                TimeUnit.MILLISECONDS.sleep(300);
                System.out.println(Thread.currentThread().getName() + 
                        "\t 读取完成：" + map.get(key) + "\t当前时间：" + System.currentTimeMillis());
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                readWriteLock.readLock().unlock();
            }
        }
    
        public void set(String key, T value) { 
            readWriteLock.writeLock().lock();
            try { 
                System.out.println(Thread.currentThread().getName() + 
                        "\t 正在写入：" + key + "\t当前值：" + map.get("w"));
                TimeUnit.MILLISECONDS.sleep(300);
                map.put(key, value);
                System.out.println(Thread.currentThread().getName() + 
                        "\t 写入完成：" + map.get(key) + "\t当前时间：" + System.currentTimeMillis());
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                readWriteLock.writeLock().unlock();
            }
        }
    }
    
    
    public class ReadWriteLockTest { 
    
        public static void main(String[] args) { 
            MyCache<String> myCache = new MyCache<>();
            for (int i = 0; i < 5; i++) { 
                new Thread(() -> { 
                    myCache.set("w", UUID.randomUUID().toString());
                }, "w" + i).start();
            }
            try { 
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (Exception e) { 
                e.printStackTrace();
            }
            for (int i = 0; i < 5; i++) { 
                new Thread(() -> { 
                    myCache.get("w");
                }, "r" + i).start();
            }
        }
    }

打印结果如下图，验证读写锁的特性，可以看出读读之间是没有互斥的。  
![在这里插入图片描述][20210302143002313.png]

[20210301152913148.png]: /images/20221023/66b097362fe84818ac086e264f49c2af.png
[20210301154754615.png]: /images/20221023/c9cace784abd414a96d41efe455a80e1.png
[20210301172107359.png]: /images/20221023/760284fc1b3040cb9fca494ab4a3e8c7.png
[20210302143002313.png]: /images/20221023/1085a009a0c548c68c4e268a3a9dbf05.png