美文网首页
聊一聊锁

聊一聊锁

作者: 二毛_220d | 来源:发表于2020-04-10 23:30 被阅读0次

    1、公平锁、非公平锁

    1. 是什么

      公平锁就是先来后到、非公平锁就是允许加塞,Lock lock = new ReentrantLock(Boolean fair); 默认非公平。

      • ==公平锁==是指多个线程按照申请锁的顺序来获取锁,类似排队打饭。

      • ==非公平锁==是指多个线程获取锁的顺序并不是按照申请锁的顺序,有可能后申请的线程优先获取锁,在高并发的情况下,有可能会造成优先级反转或者节现象。

    2. 两者区别

      • 公平锁:Threads acquire a fair lock in the order in which they requested it

        公平锁,就是很公平,在并发环境中,每个线程在获取锁时,会先查看此锁维护的等待队列,如果为空,或者当前线程就是等待队列的第一个,就占有锁,否则就会加入到等待队列中,以后会按照FIFO的规则从队列中取到自己。

      • 非公平锁:a nonfair lock permits barging: threads requesting a lock can jump ahead of the queue of waiting threads if the lock happens to be available when it is requested.

        非公平锁比较粗鲁,上来就直接尝试占有额,如果尝试失败,就再采用类似公平锁那种方式。

    2、可重入锁(递归锁)

    1. 递归锁是什么

      指的时同一线程外层函数获得锁之后,内层递归函数仍然能获取该锁的代码,在同一个线程在外层方法获取锁的时候,在进入内层方法会自动获取锁,也就是说,线程可以进入任何一个它已经拥有的锁所同步着的代码块

    2. ReentrantLock/Synchronized 就是一个典型的可重入锁

    3. 可重入锁最大的作用是避免死锁

    4. 代码示例

      package com.jian8.juc.lock;
      
      ####
          public static void main(String[] args) {
              Phone phone = new Phone();
              new Thread(() -> {
                  try {
                      phone.sendSMS();
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
              }, "Thread 1").start();
              new Thread(() -> {
                  try {
                      phone.sendSMS();
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
              }, "Thread 2").start();
          }
      }
      class Phone{
          public synchronized void sendSMS()throws Exception{
              System.out.println(Thread.currentThread().getName()+"\t -----invoked sendSMS()");
              Thread.sleep(3000);
              sendEmail();
          }
      
          public synchronized void sendEmail() throws Exception{
              System.out.println(Thread.currentThread().getName()+"\t +++++invoked sendEmail()");
          }
      }
      
      package com.jian8.juc.lock;
      
      import java.util.concurrent.locks.Lock;
      import java.util.concurrent.locks.ReentrantLock;
      
      public class ReentrantLockDemo {
          public static void main(String[] args) {
              Mobile mobile = new Mobile();
              new Thread(mobile).start();
              new Thread(mobile).start();
          }
      }
      class Mobile implements Runnable{
          Lock lock = new ReentrantLock();
          @Override
          public void run() {
              get();
          }
      
          public void get() {
              lock.lock();
              try {
                  System.out.println(Thread.currentThread().getName()+"\t invoked get()");
                  set();
              }finally {
                  lock.unlock();
              }
          }
          public void set(){
              lock.lock();
              try{
                  System.out.println(Thread.currentThread().getName()+"\t invoked set()");
              }finally {
                  lock.unlock();
              }
          }
      }
      
      

    3、独占锁(写锁)/共享锁(读锁)/互斥锁

    1. 概念

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

      • 共享锁:只该锁可被多个线程所持有

        ReentrantReadWriteLock其读锁是共享锁,写锁是独占锁

      • 互斥锁:读锁的共享锁可以保证并发读是非常高效的,读写、写读、写写的过程是互斥的

    2. 代码示例

      package com.jian8.juc.lock;
      
      import java.util.HashMap;
      import java.util.Map;
      import java.util.concurrent.TimeUnit;
      import java.util.concurrent.locks.Lock;
      import java.util.concurrent.locks.ReentrantReadWriteLock;
      
      /**
       * 多个线程同时读一个资源类没有任何问题,所以为了满足并发量,读取共享资源应该可以同时进行。
       * 但是
       * 如果有一个线程象取写共享资源来,就不应该自由其他线程可以对资源进行读或写
       * 总结
       * 读读能共存
       * 读写不能共存
       * 写写不能共存
       */
      public class ReadWriteLockDemo {
          public static void main(String[] args) {
              MyCache myCache = new MyCache();
              for (int i = 1; i <= 5; i++) {
                  final int tempInt = i;
                  new Thread(() -> {
                      myCache.put(tempInt + "", tempInt + "");
                  }, "Thread " + i).start();
              }
              for (int i = 1; i <= 5; i++) {
                  final int tempInt = i;
                  new Thread(() -> {
                      myCache.get(tempInt + "");
                  }, "Thread " + i).start();
              }
          }
      }
      
      class MyCache {
          private volatile Map<String, Object> map = new HashMap<>();
          private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
      
          /**
           * 写操作:原子+独占
           * 整个过程必须是一个完整的统一体,中间不许被分割,不许被打断
           *
           * @param key
           * @param value
           */
          public void put(String key, Object value) {
              rwLock.writeLock().lock();
              try {
                  System.out.println(Thread.currentThread().getName() + "\t正在写入:" + key);
                  TimeUnit.MILLISECONDS.sleep(300);
                  map.put(key, value);
                  System.out.println(Thread.currentThread().getName() + "\t写入完成");
              } catch (Exception e) {
                  e.printStackTrace();
              } finally {
                  rwLock.writeLock().unlock();
              }
      
          }
      
          public void get(String key) {
              rwLock.readLock().lock();
              try {
                  System.out.println(Thread.currentThread().getName() + "\t正在读取:" + key);
                  TimeUnit.MILLISECONDS.sleep(300);
                  Object result = map.get(key);
                  System.out.println(Thread.currentThread().getName() + "\t读取完成: " + result);
              } catch (Exception e) {
                  e.printStackTrace();
              } finally {
                  rwLock.readLock().unlock();
              }
      
          }
      
          public void clear() {
              map.clear();
          }
      }
      

    4、自旋锁

    1. spinlock

      是指尝试获取锁的线程不会立即阻塞,而是采用循环的方式去尝试获取锁,这样的好处是减少线程上下文切换的消耗,缺点是循环会消耗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;
          }
      

      手写自旋锁:

      package com.jian8.juc.lock;
      
      import java.util.concurrent.TimeUnit;
      import java.util.concurrent.atomic.AtomicReference;
      
      /**
       * 实现自旋锁
       * 自旋锁好处,循环比较获取知道成功位置,没有类似wait的阻塞
       *
       * 通过CAS操作完成自旋锁,A线程先进来调用mylock方法自己持有锁5秒钟,B随后进来发现当前有线程持有锁,不是null,所以只能通过自旋等待,知道A释放锁后B随后抢到
       */
      public class SpinLockDemo {
          public static void main(String[] args) {
              SpinLockDemo spinLockDemo = new SpinLockDemo();
              new Thread(() -> {
                  spinLockDemo.mylock();
                  try {
                      TimeUnit.SECONDS.sleep(3);
                  }catch (Exception e){
                      e.printStackTrace();
                  }
                  spinLockDemo.myUnlock();
              }, "Thread 1").start();
      
              try {
                  TimeUnit.SECONDS.sleep(3);
              }catch (Exception e){
                  e.printStackTrace();
              }
      
              new Thread(() -> {
                  spinLockDemo.mylock();
                  spinLockDemo.myUnlock();
              }, "Thread 2").start();
          }
      
          //原子引用线程
          AtomicReference<Thread> atomicReference = new AtomicReference<>();
      
          public void mylock() {
              Thread thread = Thread.currentThread();
              System.out.println(Thread.currentThread().getName() + "\t come in");
              while (!atomicReference.compareAndSet(null, thread)) {
      
              }
          }
      
          public void myUnlock() {
              Thread thread = Thread.currentThread();
              atomicReference.compareAndSet(thread, null);
              System.out.println(Thread.currentThread().getName()+"\t invoked myunlock()");
          }
      }
      

    锁升级

    偏向锁--》轻量级锁 (自旋锁) --》重量级锁

    锁优化

    锁粗化

    锁消除
    适应性自旋:适应性自旋,线程如果自旋成功了,则下次自旋的次数会更多,如果自旋失败了,则自旋的次数就会减少。

    相关文章

      网友评论

          本文标题:聊一聊锁

          本文链接:https://www.haomeiwen.com/subject/oyajmhtx.html