Java 锁

Java 锁

---

---

前言

关键词: 公平锁/非公平锁 可重入锁 独占锁/共享锁 自旋锁 读写锁

---

一、synchronized ？

1. 为什么要使用synchronized

多线程操作共享数据,存在线程安全的问题 如下演示

public class Test08 {
    private static Integer count = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    count++;
                }
            }
        }, "t1");


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    count--;
                }
            }
        }, "t2");
        
        t1.start();
        t2.start();
        //等待执行完
        t1.join();
        t2.join();

        System.out.println(count);
    }
}

结果运行第一次

运行第二次

两次运行结果不同,且不是0,存在多线程操作共享数据安全问题

2. synchronized如何解决线程安全

演示

public class Test08 {
    private static Integer count = 0;
    private static final Object obj=new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public  void run() {
                for (int i = 0; i < 1000; i++) {
                     // 加锁
                    synchronized (obj){
                        count++;
                    }
                }
            }
        }, "t1");


        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
               		 // 加锁
                    synchronized (obj){
                        count--;
                    }
                }
            }
        }, "t2");

        t1.start();
        t2.start();
        //等待执行完
        t1.join();
        t2.join();

        System.out.println(count);
    }
}

synchronized可以保证方法或者代码块在运行时，同一时刻只有一个线程可以操作临界区，同时它还可以保证共享变量的内存可见性

3. synchronized优化

• 原理: synchronized加锁,会给锁对象指向一个monitor对象(锁不同,monitor不同)
  

• 轻量级锁
  当虽然有多线程访问共享资源,但他们访问时间是错开的,synchronized自动升级为轻量级锁
  参考: mark word 结构
  
  1> 线程的栈帧有锁记录对象(jvm层面的), 轻量级锁会把锁记录地址和锁对象的mark work 地址互换 (cas互换) 01表示没有锁 00表示轻量级锁互换
  

• 偏向锁
  2 > 当同一个线程再次获取锁时(锁重入),轻量级锁会新建一个锁记录对象,记录锁重入次数
  
  3> 锁重入的时候,每次都会进行cas操作,耗费性能.所以就有了偏向锁,偏向锁认为这个锁对象就偏向自己,会把锁对象的mark work 修改成自己的线程id,下次自己重入时,就不用cas比较,直接获取锁.
  

4> 锁膨胀,当另外一个线程也来竞争修改锁对象的mark word,就会锁膨胀(因为轻量级锁默认认为没有竞争),就是升级为重量锁(monitor对象)

• 自旋锁
  升级成重量锁,会采用自旋优化,就是不会立马进入EntryList阻塞,会多次尝试获取锁对象,如果尝试过程中获取到对象了,就可以避免上下文切换带来的性能损耗,如果没有再阻塞.

场景1： 程序不会有锁的竞争。
那么这种情况我们不需要加锁，所以这种情况下对象锁状态为无锁。

场景2： 经常只有某一个线程来加锁。
加锁过程：也许获取锁的经常为同一个线程，这种情况下为了避免加锁造成的性能开销，所以并不会加实际意义上的锁，偏向锁的执行流程如下：
1、线程首先检查该对象头的线程ID是否为当前线程；
2、A：如果对象头的线程ID和当前线程ID一直，则直接执行代码；B：如果不是当前线程ID则使用CAS方式替换对象头中的线程ID，如果使用CAS替换不成功则说明有线程正在执行，存在锁的竞争，这时需要撤销偏向锁，升级为轻量级锁。
3、如果CAS替换成功，则把对象头的线程ID改为自己的线程ID，然后执行代码。
4、执行代码完成之后释放锁，把对象头的线程ID修改为空。

场景3： 有线程来参与锁的竞争，但是获取锁的冲突时间很短。
当开始有锁的冲突了，那么偏向锁就会升级到轻量级锁；线程获取锁出现冲突时，线程必须做出决定是继续在这里等，还是回家等别人打电话通知，而轻量级锁的路基就是采用继续在这里等的方式，当发现有锁冲突，线程首先会使用自旋的方式循环在这里获取锁，因为使用自旋的方式非常消耗CPU，当一定时间内通过自旋的方式无法获取到锁的话，那么锁就开始升级为重量级锁了。

场景4： 有大量的线程参与锁的竞争，冲突性很高。
我们知道当获取锁冲突多，时间越长的时候，我们的线程肯定无法继续在这里死等了，所以只好先休息，然后等前面获取锁的线程释放了锁之后再开启下一轮的锁竞争，而这种形式就是我们的重量级锁。

二、公平锁/非公平锁？

公平锁: 按申请锁的顺序获取锁
非公平锁: 不按照申请锁的顺序获取锁,上来就尝试获取锁,获取不到就去公平
synchronized 和 ReentrantLock 都是非公平锁(通过true修改)

// 默认非公平锁
ReentrantLock lock= new ReentrantLock();
// 公平锁
ReentrantLock lock= new ReentrantLock(true);

非公平锁可以减少cpu上下文切换,效率高(因为公平锁要按照顺序,不是顺序的要切换到顺序)

三、可重入锁？

可重入锁: 线程获取了锁,它就可以进入任何一个锁本身所同步的代码块,防止死锁
Synchronized/ReentrantLock都是可重入锁

public class Test07 {


    public static void main(String[] args) {
        Thread thread = new Thread(new MyTask01());
        thread.start();
    }

}
class MyTask01 implements Runnable{

    @Override
    public void run() {
        set();
    }
    //this锁
    public synchronized void set(){
        System.out.println(Thread.currentThread().getName()+",方法set");
        get();
    }
   //this锁
    private synchronized void get() {
        System.out.println(Thread.currentThread().getName()+",方法get");
    }
}

四、Synchronized/ReentrantLock区别？

synchronized优化后,两者性能差不多,reentrantLock有一些高级api,当需要应用api时就用lock,其他推荐synchronized
lock情况如下:
1> 公平锁 (构造传入true)
2> 取消等待
3> 锁绑定多个条件 +Condition实现可以分组唤醒