JUC（12）各种锁

最新推荐文章于 2024-07-26 21:46:53 发布

原创最新推荐文章于 2024-07-26 21:46:53 发布 · 206 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#公平锁与非公平锁 #重入锁 #自旋锁 #死锁

多线程与并发编程专栏收录该内容

38 篇文章

订阅专栏

本文详细介绍了Java并发编程中的四种锁机制：公平锁与非公平锁，重点讨论了ReentrantLock的公平性和非公平性；接着解释了可重入锁的概念，并通过示例展示了synchronized和ReentrantLock的可重入特性；然后阐述了自旋锁的工作原理，并提供了基于AtomicReference实现的自旋锁代码；最后，探讨了死锁的概念、产生条件及解决策略。

文章目录

一、公平锁与非公平锁

公平锁：非常公平；不能插队的，必须先来后到；
非公平锁：非常不公平，允许插队的，可以改变顺序。(ReentrantLock 与 Synchronized 默认都是非公平锁)

/**
 * 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) {
    sync = fair ? new FairSync() : new NonfairSync();
}

二、可重入锁

可重入锁(递归锁)
- 什么是 “可重入”，可重入就是说某个线程已经获得某个锁，可以再次获取相同的锁而不会出现死锁。
- synchronized和ReentrantLock都是可重入的
- 使用ReentrantLock的注意点 : synchronized是自己释放锁的，ReentrantLock 和 synchronized 不一样，需要手动释放锁，所以使用 ReentrantLock的时候一定要手动释放锁，并且加锁次数和释放次数要一样 （否则就导致死锁）
synchronized

package com.wlw.allLock;

public class Demo01 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.send();
        },"A").start();

        new Thread(()->{
            phone.send();
        },"B").start();
    }
}
class Phone{

    public synchronized void send(){
        System.out.println(Thread.currentThread().getName()+"===》 send message");
        call();
    }

    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"===》 call");
    }
}

/*
A===》 send message
A===》 call
B===》 send message
B===》 call
*/

ReentrantLock

package com.wlw.allLock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo02{
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        new Thread(()->{
            phone.send();
        },"A").start();

        new Thread(()->{
            phone.send();
        },"B").start();
    }
}
class Phone2{

    Lock lock = new ReentrantLock();

    public void send(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"===》 send message");
            call();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public void call(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"===》 call");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
}
/*
A===》 send message
A===》 call
B===》 send message
B===》 call
*/

三、自旋锁

spinlock自旋锁：不断的循环，不断的迭代，不断的尝试，知道成功为止
之前在原子类（AtomicInteger.getAndIncrement->unsafe.getAndAddInt）中见过自旋锁

 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;
}

自己利用CAS写一个自旋锁

package com.wlw.allLock;

import java.util.concurrent.atomic.AtomicReference;
//自旋锁
public class SpinLockDemo {
    AtomicReference atomicReference = new AtomicReference();

    //加锁
    public void mylock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"===> mylock");

        //自旋锁 第一个线程执行mylock方法，不会进入循环，第二线程才会进入
        while (!atomicReference.compareAndSet(null,thread)){

        }
    }

    //解锁
    public void myunlock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"===> myunlock");
        //设置为null，解锁
        atomicReference.compareAndSet(thread,null);
    }
}

package com.wlw.allLock;

import java.util.concurrent.TimeUnit;

//测试自旋锁
public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(()->{
            spinLockDemo.mylock();
            try {
                TimeUnit.SECONDS.sleep(5);
            }catch (Exception e){
                e.printStackTrace();
            }
            finally {
                spinLockDemo.myunlock();
            }
        },"T1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            spinLockDemo.mylock();
            try {
                TimeUnit.SECONDS.sleep(5);
            }catch (Exception e){
                e.printStackTrace();
            }
            finally {
                spinLockDemo.myunlock();
            }
        },"T2").start();
    }
}
/*
T1===> mylock
T2===> mylock
T1===> myunlock
T2===> myunlock
T2进程必须等待T1进程Unlock后，才能Unlock，在这之前进行自旋等待。。。。
*/

四、死锁

什么是死锁？
- 如果一组进程中的每一个进程都在等待仅有改组进程中的其他进程才能引发的事件，那么改组进程是死锁的
- 简单点来说，第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记时，产生死锁。（或者来说，两个进程都在等待对方释放持有的资源，而自己却不释放资源）
产生死锁的必要条件：
- 互斥条件：资源是互斥使用的
- 请求和保持条件：该线程保持自己持有的资源，去请求其他进程已经占有的资源
- 不可抢占条件：进程已获得的资源在未使用完之前不能被抢占
- 循环等待条件：发生死锁时，必然存在着一个进程——资源的循环链

package com.wlw.allLock;

public class DeadLockDemo {

    public static void main(String[] args) {

        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new MyThread(lockA,lockB),"t1").start();
        new Thread(new MyThread(lockB,lockA),"t2").start();
    }
}

class MyThread implements Runnable{

    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+"持有"+lockA+",想要"+lockB);

            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"持有"+lockB+",想要"+lockA);
            }
        }
    }
}
/*
t1持有lockA,想要lockB
t2持有lockB,想要lockA
程序就这样一直持续下去....................
*/