java锁

java锁

1.公平与非公平锁

公平锁:是指多个线程按照申请锁的顺序来获取锁,就是排队,先来后到

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

2.可重入锁(递归锁)

ReentrantLock/Synchronized是默认非公平可重入锁

什么是可重入锁?

指的是同一线程外层函数获得锁之后,内层递归函数仍然能够获取该锁的代码,在同一线程在外层方法获取锁的时候,进入内层方会自动获取锁

public synchronized void method1(){
    method2();
}
public synchronized void method2(){
    
}
​
//在同一线程下
//可重入锁,就是method1进来了,可以直接调用method2,不管它有没有锁
//作用:防止死锁 

 

3.自旋锁

是指尝试获取锁的线程不会立即阻塞,而是采用循环的方式去尝试获取锁,这样的好处是减少线程上下文切换的消耗.缺点是循环会消耗cpu;

public class LockDemo {
    AtomicReference<Thread> atomicReference = new AtomicReference<>();
​
    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + " 进来");
        while (!atomicReference.compareAndSet(null, thread)) {
            System.out.println(Thread.currentThread().getName()+"   等待获取");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"   获取成功");
    }
    public void unLock() {
        Thread thread=Thread.currentThread();
        while (!atomicReference.compareAndSet(thread, null)) {
​
        }
        System.out.println(Thread.currentThread().getName()+" 出去");
    }
​
    public static void main(String[] args) {
        LockDemo lockDemo = new LockDemo();
        new Thread(()->{
            lockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lockDemo.unLock();
        },"a").start();
​
        new Thread(()->{
            lockDemo.myLock();
            lockDemo.unLock();
        },"b").start();
    } 
}
​

 

运行结果:

a 进来

b 进来

b 等待获取

a 获取成功

b 等待获取

b 等待获取

b 等待获取

b 等待获取

a 出去

b 获取成功

b 出去

从结果可以看出:a线程运行结束,b线程才开始执行,但是b线程并未停止运行,而是不断的尝试获取线程,知道a线程结束,这就是自旋锁;

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

实例:

class MyCache{//资源类
​
    Map<String,Object> map=new HashMap<>();
    private ReentrantReadWriteLock reLock=new ReentrantReadWriteLock();
​
​
    public void put(String key, Object value) {
​
       reLock.writeLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"  正在写入");
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+" 写入完成");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            reLock.writeLock().unlock();
        }
    }
​
    public void get() {
​
        reLock.readLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"  正在读取");
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" 读取完成");
​
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            reLock.readLock().unlock();
        }
    }
​
}
public class ReadWriteLockDemo {
​
​
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i <5 ; i++) {
            new Thread(()->{
              myCache.put(Thread.currentThread().getName(),Thread.currentThread().getName());
            },String.valueOf(i)).start();
        }
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i <5 ; i++) {
            new Thread(()->{
                myCache.get();
            },String.valueOf(i)).start();
        }
    }
}