[多线程]Synchronized与java.util.concurrent.locks.Lock

我们学习的时候常常使用Synchronized关键字来做代码块或者方法等资源的同步操作。

但是java.util.concurrent包中也提供了lock对象来手动的为自己的代码加锁。下面有相关的不同点，仅供参考：

不同点：

1. Synchronized： java内置关键字，  Lock 是一个java util包下的类

2. Synchronized： 无法判断获取锁的状态， Lock可以判断是否获取到了锁

3. Synchronized： 会自动释放锁， Lock必须要手动释放锁，如果不释放，会造成死锁

4. Synchronized： 当线程1获得锁，产生阻塞， 线程2会一直等待，Lock锁不一定会等待下去。

5. Synchronized： 可重入锁，不可以中断，非公平， Lock， 可重入锁，可以判断锁， 可自己设置公平还是非公平。

6. Synchronized： 适合锁少量的代码同步问题， Lock适合锁大量的同步代码！

7.Synchronized： 读读也互斥，Lock可用读写锁实现读读不互斥。只有读写才互斥。

8. Lock的线程间通信要比传统的wait(),notifiy()进行线程通信的效率要高很多。使得加锁，释放锁的操作更具选择性，精准性。

相关代码 ：

我们要实现生产者消费者的一段代码。A,C类生产一个产品，B，D类消费一个产品。如果B，D类消费时发现产品不够，则等待A，C类生产出来。A，C类生产出来后也会等待消费完成则继续生产。

1.  使用Synchronized实现的生产者消费者代码。

        配套等待使用的Object对象的wait()方法，而唤醒其他线程使用的Object类的notifyAll()方法。

public class A {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();

    }
}

//判断是否需要等待
//业务
//通知
class Data {
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        while (number != 0) {
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+ "=>"  + number);
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        while (number == 0) {
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+ "=>"  + number);
        this.notifyAll();
    }
}

2. 使用Lock和Condition实现精准通知

代码条件： 三个线程分别执行，但是要求A执行完毕后必须是B接着执行，B执行完毕后必须是C接着执行。

使用Lock替换了 Synchronized， Condition的await()方法替换了Object的wait()方法

                                                     Condition的signal()方法替换了Object的notify()方法

                                                     Condition的signalAll()方法替换了Object的notifyAll()方法

public class C {
    public static void main(String[] args) {
        Data3 data = new Data3();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        }, "C").start();
    }
}

class Data3 {

    private Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    private int number = 1;

    public void printA() {
        lock.lock();
        try {
            while (number != 1) {
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>AAAA");
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void printB() {
        lock.lock();
        try {
            while (number != 2) {
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>BBBBBBBB");
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void printC() {
        lock.lock();
        try {
            while (number != 3) {
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>CCCCCCCCCCCC");
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

• 注意lock的使用方法

1. 创建lock对象
2. 锁住需要锁的业务逻辑
3. 使用lock对象获取condition对象
4. 使用condition对象操作精准的等待和唤醒
5. 业务完毕，finally中第一行解锁