锁的使用

最新推荐文章于 2023-06-17 16:45:00 发布

原创最新推荐文章于 2023-06-17 16:45:00 发布 · 195 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java

JAVA-多线程专栏收录该内容

22 篇文章

订阅专栏

锁用于解决多线程对共享资源的同时访问，而引起的非线程安全问题：某一时该只有一条线程可以访问共享资源，达到了线程安全的目的，但同时也限制了并发处理的速度。

锁的分类：

同步锁: synchronized 是java 内置的语法

可重入锁：ReentrantLock 是一个java类

读写锁：ReentrantReadWriteLock 是一个java类

锁定的范围：

由于锁使线程互斥访问，未获得锁的线程会阻塞，限制了并发处理的速度，因此线程应该锁定尽量小的范围及尽快的释放锁。

比如一家企业，有10个厕所，每个厕所有5个坑，每个员工都要上厕所，厕所的同一个坑不可能由多人共同使用，每个员工相当于一线线程，茅坑相当于共享资源，因此需要多个员工之间互斥使用同一个茅坑。

错误的锁定范围：

10个厕所：意味着某个员工使用某个茅坑时，所有厕所都不能使用，严重浪费资源，影响并发使用率。

每个厕所：意味着某个员工使用某个茅坑时，该厕所不能被别人使用，其他9个厕所允许9个人分别使用，浪费资源，影响并发使用率。

正确的锁定范围：

每个茅坑：意味着某个员工使用某个茅坑时，该茅坑不能被别人使用，其他49个茅坑允许49个人分别使用。

java中的锁定对象：

synchronized的锁定对象：

语法：synchronized(被锁定对象) 或在方法签名上声明

全局锁定：Class对象，static 对象及方法，singleton 实例，equals相等的String对象

部分锁定：某个多例类的实例，不同实例由不同的线程同时访问。

public class Test {
 
   public synchronized  void kk(){//做用于方法，锁定当前实例，不同实例间不影响
 
  }
  public static synchronized void ww(){//做用于静态方法锁定的是Class对象
 
  }
  public void t(Object obj){
    synchronized(obj){//锁定指定对象
     //
    }
  }
  public void f( ){
     synchronized(this){//锁定当前实例
     //
  }
 }
}

ReentrantLock 锁定对象：

同一个ReentrantLock实例，不同实例可由不同线程同时访问。

用法：

class X {
   private final ReentrantLock lock = new ReentrantLock();
   public void m() { 
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
 }

ReentrantReadWriteLock

readLock 共享锁，占用锁时，同一个ReentrantReadWriteLock实例的writeLock，被阻塞，同一个ReentrantReadWriteLock实例的readLock可以同时访问。

writeLock 独占锁，占用锁时，同一个ReentrantReadWriteLock实例的writeLock和readLock阻塞，直至锁被释放,不同实例可由不同线程同时访问

锁的释放：

1 代码执行完成，退出锁定

2.由于条件不足，而无法继续执行，主动释锁定，等待条件满足，当条件满足时，需要另一条线程唤醒等待线程，唤醒的线程争得锁之后主动释放锁的代码之后执行

A.synchronized

1.synchronized方法或代码块执行完成，而释放锁

2.synchronized：被锁定对象.wait()方法被调用时释放锁而等待, 被唤醒方式：被锁定对象.notifyAll()(这两个方法需要执行锁时才能执行)

B. ReentrantLock

1.代码执行完成后，ReentrantLock.unlock()代码被调用，而释放锁

2.由ReentrantLock.newCondition()生成Condition对象的await()方法被调用时，释放锁而等待，被唤醒方式同一个Condition对象的signalAll方法被调用。(这两个方法需要执行锁时才能执行)

C.ReentrantReadWriteLock

1.代码执行完成后，ReentrantReadWriteLock的readLock 或writeLock 对象的unlock方法被调用，而释放锁

2.readLock 不支持由条件不足释放锁定而等待条件满足。writeLock.newCondition()生成Condition对象的await()方法被调用时，释放锁而等待，被唤醒方式同一个Condition对象的signalAll方法被调用。(这两个方法需要执行锁时才能执行)

class RWDictionary {
    private final Map<String, Data> m = new TreeMap<String, Data>();
    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    private final Lock r = rwl.readLock();
    private final Lock w = rwl.writeLock();
 
    public Data get(String key) {
        r.lock();
        try { return m.get(key); }
        finally { r.unlock(); }
    }
    public String[] allKeys() {
        r.lock();
        try { return m.keySet().toArray(); }
        finally { r.unlock(); }
    }
    public Data put(String key, Data value) {
        w.lock();
        try { return m.put(key, value); }
        finally { w.unlock(); }
    }
    public void clear() {
        w.lock();
        try { m.clear(); }
        finally { w.unlock(); }
    }

信号量Semaphore ：

一般用于限制对某些资源固定数量的访问。

Semaphore维护了N个的许可，某线程通过acquire()获取一个许可或acquire(int permits) 获取多许可，如果许可数量N大于线程要求的许可数，线程得到许可并可以继续执行。

否则线程阻塞，等待某线程释放许可。

某线程释放许可，许可数量增加并唤醒被阻塞的线程，阻塞线程唤醒后再试着获取许可，获取成功则继续执行否则再次阻塞。

不使用锁解决非线程安全问题(有一定局限性)：

实现方式：一般使用CAS (compare and swap) 实现

使用场景：AtomicLongFieldUpdater 对volatile long 字段进行原子更新

AtomicReferenceFieldUpdater 对 volatile 字段进行原子更新

AtomicReference 原子方式更新的对象引用

示例：ConcurrentLinkedQueue

boolean casNext(Node<E> cmp, Node<E> val) {
            return nextUpdater.compareAndSet(this, cmp, val);
    }
    
     public boolean offer(E e) {
        if (e == null) throw new NullPointerException();
        Node<E> n = new Node<E>(e, null);
        for (;;) {
            Node<E> t = tail;
            Node<E> s = t.getNext();
            if (t == tail) {
                if (s == null) {
                    if (t.casNext(s, n)) {
                        casTail(t, n);
                        return true;
                    }
                } else {
                    casTail(t, s);
                }
            }
        }
    }
    
     private static final
            AtomicReferenceFieldUpdater<Node, Node>
            nextUpdater =
            AtomicReferenceFieldUpdater.newUpdater
            (Node.class, Node.class, "next");