多线程学习之 Lock锁

Lock类用于实现和synchronized 类似的作用，都是用于在多线程情况下的同步。

基础使用

比如我们有如下程序：

public class MyThread extends Thread {

    private ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {
        try {
            System.out.println("第一阶段完成");
            Thread.sleep(2000);
            System.out.println("第二阶段完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

public class Test {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.start();
        t2.start();
    }
}

当我们运行效果如下：

这连个线程是异步运行的，如果我们想要这两个线程同步运行，就需要加锁：
如果使用synchronized，则一种修改的方式如下：

 @Override
    public void run() {
        synchronized (MyThread.class){
            try {
                System.out.println("第一阶段完成");
                Thread.sleep(2000);
                System.out.println("第二阶段完成");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

这样就可以使两个线程同步打印了

我们也可以使用Lock类来完成相同的作用：

public class MyThread extends Thread {

    private static ReentrantLock lock=new ReentrantLock();

    @Override
    public void run() {
//        synchronized (MyThread.class){
            try {
                lock.lock();
                System.out.println("第一阶段完成");
                Thread.sleep(2000);
                System.out.println("第二阶段完成");
                lock.unlock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
//        }
    }
}

读写锁实现类

我们上面用的类是 ReentrantLock，这是可重入锁，可重入也就是说我当前的锁可以多次使用（比如连续进入两个 synchronized 代码块）
还有ReentrantReadWriteLock类，这个类提供了读写锁的功能， 读锁可以和读锁一起共存，读锁和写锁不能共存，使用实例如下：

public class MyThread extends Thread {

//    private static ReentrantLock lock=new ReentrantLock();

    private static ReentrantReadWriteLock readWriteLock=new ReentrantReadWriteLock();
    @Override
    public void run() {
//        synchronized (MyThread.class){
            try {
                readWriteLock.readLock().lock();
                System.out.println("第一阶段完成");
                readWriteLock.readLock().unlock();
                readWriteLock.writeLock().lock();
                Thread.sleep(2000);
                readWriteLock.writeLock().unlock();
                readWriteLock.readLock().lock();
                System.out.println("第二阶段完成");
                readWriteLock.readLock().unlock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
//        }
    }
}