生产者与消费者的 synchronized版 与 Lock版

导语：在多线程的情况下，为了保证数据安全性，就会使用到锁来保证每个线程之间互不影响，以免引起数据异常。这篇文章就来记录下所遇到的问题…

下面用一个多线程实例来了解下两者的区别，实例为：

有一个资源类Data，里有只有一个属性number=0，一个 number+1 和一个 number-1 的方法。这时有两个线程A与B，A线程调用加一方法，B线程调用减一方法。要求：必须 number 等于0时才加一，不等于0时才减一，两线程循环执行10次。

synchronized版的多线程

代码：

package morethread;

public class Synchronized {
    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();
    }
}
class Data{
    private int number = 0;

    // 三部曲：判断是否需要等待->业务->唤醒
    public synchronized void increment() throws InterruptedException {
        while(number!=0){ // 判断线程是否等待
            this.wait();
        }
        number+=1; // 业务
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll(); // 唤醒其他线程
    }

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

运行结果为：

可以发现没有问题！但如果再加两个线程C（执行加一操作）,D（执行减一操作）呢 ？

代码：

package morethread;

public class Synchronized {
    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 {
        if(number!=0){ // 判断线程是否等待
            this.wait();
        }
        number+=1; //业务
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll(); // 唤醒其他线程
    }

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

运行结果：

可以发现，这不是想要的答案，那为什么多加了两个线程会出现这个原因呢？

经过查看了jdk文档后得知：是if判断语句出现的问题，if循环会导致虚假唤醒问题。需要将if循环改为while循环就得以解决这个问题了。

Lock版的多线程

代码：

package morethread;

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

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

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

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

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.decrement();
            }},"D").start();
    }
}
class Data{
    private int number = 0;

    Lock lock = new ReentrantLock(); // 相当于 synchronized
    Condition condition = lock.newCondition(); // 可以写出Object监视器的方法，代替于synchronized版的 wait()与 notifyAll()

    public void increment(){
        lock.lock(); //上锁
        try {
            // 三部曲操作
            while(number!=0){
                condition.await();
            }
            number+=1;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition.signalAll();
        } catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock(); // 释放锁，不然会导致死锁
        }
    }

    public void decrement(){
        lock.lock();
        try {
            while(number==0){
                condition.await();
            }
            number-=1;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition.signalAll();
        } catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

图方便，这里就直接4个线程了…

运行结果：

可以发现也没有问题，但是这就是乱序的了，这相对于synchronized版没有任何区别，甚至步骤更麻烦，还要自动去释放锁等等…

Lock 精准通知唤醒

那为什么工作中用的多是Lock版的呢？因为它还可以实现精准通知唤醒。

用一个新的实例，比如我要线程A执行完，唤醒线程B，线程B执行完唤醒线程C，线程C执行完唤醒线程A，依次执行5次。

代码：

package morethread;

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

public class Lock2 {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{for (int i = 0; i < 5; i++) data.sayA();},"A").start();
        new Thread(()->{for (int i = 0; i < 5; i++) data.sayB();},"B").start();
        new Thread(()->{for (int i = 0; i < 5; i++) data.sayC();},"C").start();
    }
}
class Data{
    private int number = 1; // 1A,2B,3C

    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();

    public void sayA(){
        lock.lock();
        try {
            while(number!=1){
                condition1.await(); // A线程睡觉
            }
            System.out.println(Thread.currentThread().getName()+"线程执行完了!");
            number = 2;
            condition2.signal(); // A线程执行完了唤醒B线程
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void sayB(){
        lock.lock();
        try {
            while(number!=2){
                condition2.await(); // B线程睡觉
            }
            System.out.println(Thread.currentThread().getName()+"线程执行完了!");
            number = 3;
            condition3.signal(); // B线程执行完了唤醒C线程
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void sayC(){
        lock.lock();
        try {
            while(number!=3){
                condition3.await(); // C线程睡觉
            }
            System.out.println(Thread.currentThread().getName()+"线程执行完了!");
            number = 1;
            condition1.signal(); // C线程执行完了唤醒A线程
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

运行结果：

总结

这两个版本的区别：

1、synchronized 是java的关键字；Lock 是java的一个类（接口）。

2、synchronized 无法判断获取锁的状态； Lock 可以获取。

3、synchronized 会自动释放锁；Lock 需要手动去释放，如果不释放就会导致死锁。

4、synchronized 线程1获得锁时，线程2就会等待，如果这时候线程1阻塞了，线程2就会傻傻地等；Lock 就不一定会等下去（通过tryLock()方法判断）。

5、synchronized 可重入锁，不可以中断，非公平锁；Lock 可重入锁，可以判断锁来决定是否中断，非公平锁（可以手动调为公平锁，创建时给参数true）。

6、synchronized 适合锁少量的代码同步问题；Lock 适合锁大量的同步代码。