乐趣区

关于java:JAVA并发编程锁专题

1. 锁之偏心锁与非偏心锁

2. 可重入锁(递归锁)

3. 自旋锁

4. 读锁写锁

1. 锁之偏心锁与非偏心锁
咱们先来理解一下,最根本的偏心锁和非偏心锁:

偏心锁:指多个线程按申请锁的程序来获取锁,相似排队打饭,先来后到。

非偏心锁:指多个线程获取锁的程序并不是依照申请的程序,有可能后申请的线程优先获取锁,在高并发的状况下,可能会造成优先级反转或者饥饿景象(饥饿景象就是线程永远获取不到锁)。

而对于 JAVA 罕用的 ReentrantLock 和 synchronize 锁而言,是偏心锁还是非偏心锁呢?

咱们先来看一下 ReentrantLock 的构造方法

Lock lock = new ReentrantLock();
/**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
    // 默认为非偏心锁
        sync = new NonfairSync();}

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
    // 如果传入为 true,则是偏心锁,正文说会应用先来后到的排序策略
        sync = fair ? new FairSync() : new NonfairSync();
    }

接下来咱们再看一下 synchronize 关键字是偏心锁还是非偏心锁:

咱们先定义一个 synchronize 办法

    public static synchronized void method01() {System.out.println(Thread.currentThread().getName() + "method01");
    }
    public static synchronized void method01() {System.out.println(Thread.currentThread().getName() + "method01");
    }

接下来咱们循环启动多个线程,如果线程的编号是依照程序执行的,则证实 synchronize 是偏心锁,如果线程的编号是乱序执行的,则证实 synchronize 是非偏心锁。

        for(int i =1;i<=10;i++){new Thread(()->{method01();},"t"+i).start();}

执行后果如下:

咱们能够得出,synchronized 也是非偏心锁。

2. 可重入锁(递归锁)
可重入锁 递归锁
可重入锁又叫递归锁,指的是同一线程在外层获取锁的时候,在进入内层办法会主动获取锁。是一种不会对其本身进行阻塞的锁,我晓得这么说比拟形象,接下来咱们间隔进行阐明。

咱们先写两个同步办法 A 和 B,其中 A 调用 B,如果锁是不可重入锁,因为线程调用办法 A 时,曾经获取锁,就没有方法获取办法 B 的锁了,然而可重入锁的话,线程调用同步办法 A,办法 A 调用同步办法 B,此时主动获取锁。


    public static synchronized void method01() {System.out.println(Thread.currentThread().getName() + "method01");
        method02();}

    public static synchronized void method02() {System.out.println(Thread.currentThread().getName() + "method02");
    }
    
new Thread(()->{method01();},"t1").start();

此时,线程不会造成死锁,而是顺利执行办法 A 和办法 B

接下来,咱们用 ReentrantLock 来示范一下可重入锁:

// 咱们应用这种模板来应用 ReentrantLock
        lock.lock();
        try {// 这里是办法体} finally {lock.unlock();
        }

咱们新建一个 phone 对象,应用 ReentrantLock,而后再用一个同步办法调用另外一个同步办法

public class Phone implements Runnable {Lock lock = new ReentrantLock();

    public void methodA() {lock.lock();
        try {System.out.println(Thread.currentThread().getName() + "method01");
            methodB();} finally {lock.unlock();
        }

    }

    public void methodB() {lock.lock();
        try {System.out.println(Thread.currentThread().getName() + "method02");
        } finally {lock.unlock();
        }
    }

    @Override
    public void run() {methodA();
    }
}
        Phone phone = new Phone();
        new Thread(phone, "t1").start();
        new Thread(phone, "t2").start();
        new Thread(phone, "t3").start();
        new Thread(phone, "t4").start();

运行后果为:

能够看出,是可重入锁,而且并没有死锁。

然而如果此时,咱们批改一下办法会怎么样?

        // 两个 lock
  public void methodA() {lock.lock();
        lock.lock();
        try {System.out.println(Thread.currentThread().getName() + "method01");
            methodB();} finally {
        // 两个 unlock
            lock.unlock();
            lock.unlock();}
    }

此时也能失常运行,然而如果加锁 lock 和解锁 unlock 的次数不一样,那就没有方法持续运行了,程序会死锁。

3. 自旋锁

自旋锁咱们在之前在介绍 CAS 的时候 JAVA 并发编程——CAS 概念以及 ABA 问题 介绍过,他指的是尝试获取锁的线程不会立刻阻塞,而是采纳循环的形式去获取锁,这样的益处是缩小上下文切换的耗费,毛病是会耗费 CPU。

   public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {var5 = this.getIntVolatile(var1, var2);
            // 在获取到正确的值之前始终循环
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;
    }

接下来咱们将用代码来自行模仿一把自旋锁:

首先,咱们须要一个原子援用类:

    AtomicReference<Thread> atomicReference = new AtomicReference<>();

因为咱们等等要用到 atomicReference 的 compareAndSet 办法,再者对锁进行加锁和解锁的主体是线程,因为是线程获取锁,所以泛型是线程。

接下来定义一个加锁和解锁办法,利用自旋的形式加锁:

     public void myLock() {Thread thread = Thread.currentThread();
        // 先获取以后线程
        //1. 如果援用类没有线程,则替换
        // 替换后返回值为 true,因为加了取反,导致为 false,跳出循环,加锁胜利
        //2. 如果原子援用类有线程,则返回 false
        // 取反后取得 true,就能够有始终循环自旋的成果
        while (!atomicReference.compareAndSet(null, thread)) { }
        System.out.println(thread.getName() + "\t get lock!");
    }

    public void unLock() {Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);
        System.out.println(thread.getName() + "\t unlock!");
    }

接下来咱们新建两个线程运行一下

  public static void main(String[] args) {SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {spinLockDemo.myLock();// 加锁
            try {
               // 五秒钟之类,第二个线程无奈进入
                Thread.sleep(5000);
            } catch (InterruptedException e) {e.printStackTrace();
            }
            spinLockDemo.unLock();// 解锁}, "t1").start();

        new Thread(() -> {spinLockDemo.myLock();// 加锁
            spinLockDemo.unLock();// 解锁}, "t2").start();}

运行后果为:

4. 读锁写锁

此时咱们引入一个新的概念:读写锁。

从后面几种锁的应用和介绍状况来看,咱们每次只容许一个线程通过,其实效率还是挺多的,从实在的开发业务场景进行剖析,其实很多时候,只有保障写操作的排他性,无需保障读操作的排他性。
接下来咱们来模仿一遍读写锁,模仿一个键值对的缓存,应用读写锁

咱们要用到一个及其重要的类:

// 它有一个 lock.writeLock().lock()和 lock.readLock().lock()
// 办法,能够保障读操作的共享性和写操作的排他性。ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

咱们来书写一个 Map,用来当缓存空间,而后读写锁对该缓存进行操作。

// 因为是多线程操作, 记得保障它的可见性,必须采纳 volatile。private volatile Map<String, Object> map = new HashMap<>();

接下来就是最重要的读和写操作:

 /**
     * 写操作  原子性 独占性
     *
     * @param key
     * @param value
     * @throws InterruptedException
     */
    public void put(String key, Object value) throws InterruptedException {
        // 应用写锁
        lock.writeLock().lock();
        try {System.out.println(Thread.currentThread().getName() + "\t 正在写入" + key);
            Thread.sleep(1000);
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t 写入实现");
        } finally {lock.writeLock().unlock();}
    }

    /**
     * 共享性,工夫不等
     *
     * @param key
     * @return
     * @throws InterruptedException
     */
    public Object get(String key) throws InterruptedException {
        // 应用读锁
        lock.readLock().lock();
        try {System.out.println(Thread.currentThread().getName() + "\t 正在读取" + key);
            Thread.sleep(1000);
            Object object = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取实现" + "对象为" + object.toString());
            return object;
        } finally {lock.readLock().unlock();}
    }

接下来咱们试着运行一下:

 public static void main(String[] args) {CacheDemo cacheDemo = new CacheDemo();
        // 五个线程写,五个线程读,保障读互斥,写共享
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(() -> {
                try {cacheDemo.put(temp + "", temp +"");
                } catch (InterruptedException e) {e.printStackTrace();
                }
            }, "t1").start();}
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(() -> {
                try {cacheDemo.get(temp + "");
                } catch (InterruptedException e) {e.printStackTrace();
                }
            }, "t2").start();}
    }

从运行后果发现,写操作时,会一个一个线程进行写入,因为应用了 sleep 办法,会有显著的距离,实现一个再运行下一个,然而读线程因为是共享锁,就会一口气全副执行,依照工夫片轮转法,获取工夫片的线程随便进行读取。

总结:
总 1. 偏心锁:指多个线程按申请锁的程序来获取锁,相似排队打饭,先来后到。
**2. 非偏心锁:指多个线程获取锁的程序并不是依照申请的程序,有可能后申请的线程优先获取锁,在高并发的状况下,可能会造成优先级反转或者饥饿景象(饥饿景象就是线程永远获取不到锁)。
3. 可重入锁:可重入锁又叫递归锁,指的是同一线程在外层获取锁的时候,在进入内层办法会主动获取锁。是一种不会对其本身进行阻塞的锁。
4. 自旋锁:他指的是尝试获取锁的线程不会立刻阻塞,而是采纳循环的形式去获取锁,这样的益处是缩小上下文切换的耗费,毛病是会耗费 CPU。
5. 读写锁:保障写操作的排他性,无需保障读操作的排他性,保证系统吞吐量。

退出移动版