编程语言
首页 > 编程语言> > JUC并发编程-锁分类

JUC并发编程-锁分类

作者:互联网

锁分类

公平和非公平锁

并发包中ReentrantLock的创建可以指定构造函数的boolean类型来决定是公平锁还是非公平锁,默认是非公平锁

公平锁

公平锁,在并发环境下,每个线程在获取锁的时候会去查看此锁维护的等待队列,如果为空,或者当前线程为等待队列的第一个,就占有锁,否则加入到等待队列里,然后按照FIFO(先进先出)的规则等待

非公平锁

不公平,上来就直接尝试占有锁,就想插队,如果插不上,就再采用类似公平锁的方式,例如synchronized


可重入锁(又名递归锁)

指同一个线程在获得锁之后,遇到需要相同锁的同步代码,会自动获取锁。

线程可以进入任何一个他已经拥有的锁所同步的代码块


自旋锁

尝试获取锁的线程没拿到锁之后不会立即阻塞,而是采用循环的方式尝试获取锁,可以减少线程上下文切换,消耗cpu性能

public class SpinLockDemo {

    AtomicReference<Thread> atomicReference=new AtomicReference();

    public void myLock(){
        //获取当前线程
        Thread thread=Thread.currentThread();

        while (!atomicReference.compareAndSet(null, thread)){

        }
        System.out.println(Thread.currentThread().getName()+"获得锁");


    }

    public void unLock(){
        Thread thread=Thread.currentThread();

        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName()+"解锁");
    }

    public static void main(String[] args) throws InterruptedException {

        SpinLockDemo spinLockDemo=new SpinLockDemo();


        new Thread(()->{
            spinLockDemo.myLock();
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.unLock();

        },"t1").start();

        Thread.sleep(1000);

        new Thread(()->{
            spinLockDemo.myLock();

            spinLockDemo.unLock();

        },"t2").start();

    }

}


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


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

为了增加并发性能,读取共享资源的时候可以同时进行,但是写入共享资源的时候,不允许其他线程对资源进行读写

public class ReadWriteLockDemo {

    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        for (int i = 0; i < 5; i++) {
            //匿名内部类使用外部的局部变量必须用final修饰保证数据的一致性,局部变量和内部类生命周期不一样
            final int tem=i;
            new Thread(()->{
                try {
                    myCache.put(tem+"",tem+"");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }


        for (int i = 0; i < 5; i++) {
            //匿名内部类使用外部的局部变量必须用final修饰保证数据的一致性,局部变量和内部类生命周期不一样
            final int tem=i;
            new Thread(()->{
                try {
                    myCache.get(tem+"");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }

    }
}

class MyCache{

    private volatile Map<String,Object> map=new HashMap<>();
    //可重入读写锁
    private  ReentrantReadWriteLock rwLock=new ReentrantReadWriteLock();

    public void put(String key,Object value) throws InterruptedException {
        //写锁
        rwLock.writeLock().lock();

        System.out.println(Thread.currentThread().getName()+": 正在写入");

        Thread.sleep(1000);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+": 写入完成");

        //
        rwLock.writeLock().unlock();
    }

    public void get(String key) throws InterruptedException {
        //读锁
        rwLock.readLock().lock();

        System.out.println(Thread.currentThread().getName()+": 读取中");
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName()+": 读取完成:"+map.get(key));

        //解锁
        rwLock.readLock().unlock();

    }

标签:JUC,currentThread,Thread,void,编程,并发,线程,new,public
来源: https://blog.csdn.net/qq_50596778/article/details/122740956