JAVA并发编程之锁应用

Java并发包是Java中提供的一个用于支持多线程编程的工具包。Java并发包提供了多种机制来控制线程的执行，保证线程的安全性和可靠性。下面我们将介绍Java并发包的使用方法，并给出示例。

synchronized

public class SynchronizedDemo {
​
  private int v;
  private static int a;
  private final Object lock = new Object();
​
  // 修饰非静态方法 对象锁
  public synchronized void add(int value) {
    v += value; // 临界区
  }
​
  public void sub(int value) {
    // 修饰局部代码块 对象锁
    synchronized (lock) {
      v -= value; // 临界区
    }
  }
​
  // 修饰静态方法 类锁
  public static synchronized void multi(int value) {
    a *= value; // 临界区
  }
​
  public static void div(int value) {
    // 修饰局部代码块 类锁
    synchronized (SynchronizedDemo.class) {
      a /= value; // 临界区
    }
  }
} 
复制代码

java编译器会在synchronized修饰的方法或代码块前后自动Lock，unlock。

synchronized修饰代码块，锁定是个obj对象，或者是一个类，sychronized(this.class)
synchronized修饰静态方法，锁定是当前类的class对象
synchronized修饰非静态方法，锁定的是当前实例对象this。

实现原理：

synchronized关键字底层使用的锁叫做Monitor锁。但是，我们无法直接创建和使用Monitor锁。Monitor锁是寄生存在的，每个对象都会拥有一个Monitor锁。如果我们想要使用一个新的Monitor锁，我们只需要使用一个新的对象，并在synchronized关键字后，附带声明要使用哪个对象的Monitor锁即可。

当使用sychronized修饰方法的时候，编译器只不过是在函数的flags中添加了ACC_SYNCHRONIZED标记而已，其他部分跟没有添加synchronized的函数的字节码相同。

当使用synchronized修饰局部代码块的时候，字节码通过monitorenter和monitorexit来标记synchronized的作用范围。但有两点需要再解释一下

synchronized关键字底层使用的锁叫做Monitor锁。但是，我们无法直接创建和使用Monitor锁。Monitor锁是寄生存在的，每个对象都会拥有一个Monitor锁，在字节码中，通过monitorenter前面的几行字节码来指定。
以下字节码中有两个monitorexit，添加第二个monitorexit的目的是为了在代码抛出异常时仍然能解锁。
monitor锁实现原理
synchronized在底层使用不同的锁来实现，重量级锁，轻量级锁，偏向锁等。

实际上，synchronized使用的重量级锁，就是前面提到的对象上的Monitor锁。JVM有不同的实现版本，因此，Monitor锁也有不同的实现方式。在Hotspot JVM实现中，Monitor锁对应的实现类为ObjectMonitor类。因为Hotspot JVM是用C++实现的，所以，ObjectMonitor也是用C++代码定义的。

Synchronized的缺点
无法判断获取锁的状态。
虽然会自动释放锁，但如果如果锁的那个方法执行时间较长就会一直占用着不去释放，不能让使用同一把锁的方法继续执行，影响程序的运行。不能设置超时。
当多个线程尝试获取锁时，未获取到锁的线程会不断的尝试获取锁，而不会发生中断，这样会造成性能消耗。
不能够实现公平锁

Lock和Condition

Java并发包中的 Lock 和 Condition 接口提供了一种更为灵活的同步机制。与 synchronized 不同的是，它们可以支持更为细粒度的锁控制，并且可以避免死锁问题。

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

public class LockConditionExample {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    private void method1() throws InterruptedException {
        lock.lock();
        try {
            System.out.println("method1 is running");
            condition.await();
            System.out.println("method1 is finished");
        } finally {
            lock.unlock();
        }
    }

    private void method2() {
        lock.lock();
        try {
            System.out.println("method2 is running");
            condition.signal();
            System.out.println("method2 is finished");
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LockConditionExample example = new LockConditionExample();
        Thread thread1 = new Thread(() -> {
            try {
                example.method1();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread thread2 = new Thread(example::method2);
        thread1.start();
        Thread.sleep(1000);
        thread2.start();
    }
}

Lock 和 Condition 接口用于控制 method1 和 method2 方法的执行顺序。其中 method1 方法会先获取锁并进入等待状态，而 method2 方法会在一段时间后唤醒 method1 方法并释放锁。这样就可以保证 method1 方法先执行。

Semaphore

Semaphore 是一个计数信号量，用于控制同时访问某个资源的线程数。可以将 Semaphore 看作是一种计数器，每当有线程访问该资源时，计数器的值减一；当计数器的值为零时，其他线程需要等待，直到有线程释放该资源。

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

public class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

public class IncrementThread extends Thread {
    private Counter counter;

    public IncrementThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        for (int i = 0; i < 1000000; i++) {
            counter.increment();
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new IncrementThread(counter);
        Thread t2 = new IncrementThread(counter);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Count: " + counter.getCount());
    }
}

区别：

Synchronized 被称为隐式锁，也叫 JVM 锁，因为它锁的持有和释放都是隐式的，无须开发者干预。Java 1.5 引入新的锁机制，其中锁的实现基于 Lock 接口：

public interface Lock {
    // 加锁
    void lock();
    // 解锁
    void unlock();
    // 可中断获取锁，获取锁时可响应中断操作
    void lockInterruptibly() throws InterruptedException;
    // 尝试非阻塞获取锁，能够获得返回true，否则返回false
    boolean tryLock();
    // 根据时间尝试获取锁，能够获得返回true，否则返回false
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    // 获取等待通知组件，该组件与当前锁绑定
    Condition newCondition();
}
 

ReentrantLock 锁基于 AQS 队列同步器实现，全称 AbstractQueuedSynchronizer，其中它的抽象类如下：

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer {
    // 0表示锁未被占用，1表示已占用
    private volatile int state;
    // 指向同步队列队头
    private transient volatile Node head;
    // 指向同步队列队尾
    private transient volatile Node tail;
    // 其余属性省略
}

公平锁和非公平锁的差别在于：

公平锁：先请求锁的线程会优先获取到锁，原理是所有需要获得锁的线程都会进入到队列中，队列的特点是先进先出，先进入的请求线程会在头部，后进入的请求线程都会在队列的尾部。

非公平锁：则不会按照线程请求获得锁的先后顺序，会立马进行一次获取锁的请求操作。

synchronized：属于独占锁、悲观锁、可重入锁、非公平锁

ReentrantLock：继承了Lock类，可重入锁、悲观锁、独占锁、互斥锁、同步锁。

Lock：Java中的接口，可重入锁、悲观锁、独占锁、互斥锁、同步锁