公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解?请手写一个自旋锁

公平锁和非公平锁是什么?有什么区别?

  1. 并发包中ReentrantLock的创建可以指定构造函数的布尔类型来得到公平锁和非公平锁,默认是非公平锁。
	ReentrantLock lock = new ReentrantLock(true);
  1. 两者的区别
    • 公平锁:就是很公平,在并发环境中,每个线程在获取锁时会查看此锁维护的等待队列,如果为空,并且当前线程是等待队列的第一个,就占有锁。否则就会加入到等待队列中,以后会按照FIFO规则在队列中取到自己。
    • 非公平锁:上来就直接占有锁,如果尝试失败,就再采用类似公平锁的那种方式。非公平锁的优点在于吞吐量比公平锁大。

Synchronized也是一种非公平锁。

可重入锁(也叫递归锁)

指同一线程在外层方法获取锁的时候,在内层方法会自动获取锁。
ReentrantLock和Synchronized是典型的可重入锁
可重入锁最大的作用是避免死锁。

自旋锁(spinLock)

是指尝试获取锁的线程不会阻塞,而是采用循环的方式获取锁

  • 好处:减少上下文切换的消耗
  • 坏处:循环会消耗CPU
public final int getAndSetInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var4));

        return var5;
    }
  • 手写自旋锁
public class SpinLockDemo {


    //原子引用线程
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

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

        }
    }

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

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

        new Thread(() -> {
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnLock();

        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            spinLockDemo.myLock();
            spinLockDemo.myUnLock();
        }, "t2").start();

    }
}

独占锁(写锁),共享锁(读锁),互斥锁

  1. 独占锁是指锁一次只能被一个线程所持有,对ReentrantLock和Synchronized而言,都是独占锁。
  2. 共享锁是指该锁可能被多个线程所持有。

对ReentrantWriteReadLock其读锁是共享锁,其写锁是独占锁,写写,读写,写读过程都是互斥的。也就是多线程下读的时候不写,写的时候不读,读的时候其他线程可以读。

  • 读写锁案例,手写一个缓存
class myCache {//资源类
    private volatile Map<String, Object> map = new HashMap<>();
    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void put(String key, Object value) {
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在写入:key:" + key);
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }

    public void get(String key) {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 开始读,key:" + key);
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读完成,result:" + result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
          lock.readLock().unlock();
        }
    }
}

/**
 * @author liujian
 * @descripts 读写锁
 * @create 2019-06-22 17:26
 * <p>
 * 写操作:独占+原子,中间的过程必须是完整的统一体,不允许被打断,被分割
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        myCache myCache = new myCache();
        for (int i = 0; i < 50; i++) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.put(String.valueOf(tempInt), String.valueOf(tempInt));
            }, String.valueOf(i)).start();
        }
        for (int i = 0; i < 50; i++) {
            final int tempInt = i;
            new Thread(() -> {
                myCache.get(String.valueOf(tempInt));
            }, String.valueOf(i)).start();
        }
    }
}

Synchronized和Lock有什么区别?用新的Lock有什么好处?举例说明

1. 原始构成

Synchronized是关键字,属于JVM层面。

  • monitorenter 底层通过monitor对象完成,其实wait/notify等方法也依赖monitor对象,只有在代码块和方法中才可以使用wait/notify等方法。
  • monitorexit

Lock是具体的类(java.concurrent.locks.lock),是API层面的锁。

2. 使用方法
  • Synchronized不需要用户手动去释放锁,当Synchronized代码执行完后,系统会自动让线程释放对锁的占用。
  • ReentrantLock 需要用户手动去释放锁,如果不释放,会造成死锁的现象。
3. 等待是否可中断

synchronized不可中断,只有抛出异常和运行完成两种情况。
ReentrantLock 可中断

  • 设置超时方法中断:tryLock(Long timeout ,TimeUnit unit)
  • 在代码块中声明方法:lock.lockInterruptibly(); 当线程调用Thread.interrupted()时,等待锁的过程中会立即响应中断。
4. 加锁是否公平

Synchronized 是非公平锁
ReentrantLock 默认非公平锁,构建函数传入boolean值,true为公平锁,false为非公平锁。

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
5. 锁绑定多个条件

Synchronized没有
ReentrantLock用来分组唤醒需要唤醒的线程们,可以精确唤醒,而不是像synchronized要么唤醒一个线程要么唤醒全部线程。

demo演示

题目:多线程之间按顺序调用,实现A->B->C三个线程启动,要求如下:
AA打印五次,BB打印十次,CC打印15次
紧接着 AA打印五次,BB打印十次,CC打印15次

来10轮

public class SynAndReentrantLockDemo {
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        for (int i = 0; i <10 ; i++) {
            new Thread(() -> shareResource.print(5), "AA").start();
            new Thread(() -> shareResource.print(10), "BB").start();
            new Thread(() -> shareResource.print(15), "CC").start();
        }
    }
}

class ShareResource {
    private int num = 1;
    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    public void print(int j) {
        lock.lock();
        try {
            if (j==5){
                while (num != 1) {
                    c1.await();
                }
                for (int i = 0; i < j; i++) {
                    System.out.println(Thread.currentThread().getName() + "\t ");
                }
                num = 2;
                c2.signal();
            }else if (j==10){
                while (num != 2) {
                    c2.await();
                }
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "\t ");
                }
                c3.signal();
                num = 3;
            }else if (j==15){
                while (num != 3) {
                    c3.await();
                }
                for (int i = 0; i < 15; i++) {
                    System.out.println(Thread.currentThread().getName() + "\t ");
                }
                c1.signal();
                num = 1;
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
  • 1
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值