JAVA并发编程——Synchronized与Lock的区别以及Lock的使用

1.Synchronized与Lock的区别

2.Condition的基础概念

3.使用Condition循环顺序打印ABC

1.Synchronized与Lock的区别
我们可能对于Condition类都比较陌生,所以我们从我们比较熟悉的Synchronized开始对比着学习。
我们都知道Synchronized都有下图这三个使用方法:
JAVA并发编程——Synchronized与Lock的区别以及Lock的使用_第1张图片
首先是我们已知的最熟练的synchronized关键字,他是保证线程同步用的,然后是Thread.notify()(唤醒所有正在等待中的线程),Thread.wait()(将该线程加入等待队列)。
但是我们的Lock接口也有类似的三个方法:
JAVA并发编程——Synchronized与Lock的区别以及Lock的使用_第2张图片
其中,lock()方法对应着synchronize的sync,Lock接口下的condition(我们将在下文进行介绍)中有等同于notify()的signal(),和wait()的await()。

所以总结地说,Synchronized和Lock有以下区别。
1.原始构成:
synchronized是关键字,属于JVM层面
lock是具体类,是api层面

2.使用方法
synchronized不需要用户区手动释放锁,除非运行完毕或者抛异常
lock需要用户手动去释放锁,就有可能出现死锁现象,一般配合try finally来释放锁。

3.加锁是否公平
synchronized:非公平
lock:非公平(构造方法可选择,默认非公平)

4.等待是否可中断
synchronized不可中断,除非执行完毕或者抛出异常
reentrantlock可中断,可设置超时方法,设置interrupt方法

5,绑定condition
synchronized不能绑定
condition用来实现分组所需要的唤醒的线程们,可以精确唤醒,而不是像synchronized随机唤醒一个,或者唤醒全部的线程。

2.Condition的基础概念
从上文刚刚简单的介绍可以看出,condition是用来精确唤醒某一个线程的,接下来我们就来系统地介绍一下condition:
Cindition,它是用来代替传统的Object的wait()、notify()实现线程间的协作,相比使用Object的wait()、notify(),使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition,阻塞队列实际上是使用了Condition来模拟线程间协作。

3.使用Condition循环顺序打印ABC
既然Condition是用来精确唤醒线程的,那么我们接下来实现一个小Demo,创建三个线程,让他们按顺序循环打印ABC,A打印5次,B打印10次,C打印15次,并且使用Condition精确唤醒:

我们将要用到一下变量:

    //一个信号量 1代表打印A的线程应该被唤醒,2代表B,3代表C
    private int number = 1;
    //一把锁
    private Lock lock = new ReentrantLock();
    //c1,c2,c3用来精确唤醒的线程
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

接下来我们定义三个方法:

    public void print5() {
    }

    public void print10() {
    }

    public void print15() {
    }

我们将会启动多个线程,分别运行print5(),print10(),print15()方法,
通过condition控制,在print5()结束后,启动print10(),print10()结束后,启动print15()方法,一直循环。

接下分别来看一下三个函数的函数体:

  public void print5() {
        //加锁,每次只有一个线程能运行
        lock.lock();
        try {
            //number作为信号量,为1的时候就应该执行print5()方法
            while (number != 1) {
                //如果不是1,此线程就等待
                c1.await();
            }
            //执行打印方法
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            //接下来应该轮到print10()方法启动了
            number = 2;
            //唤醒print10()所拥有的的线程
            c2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print10() {
        //加锁,每次只有一个线程能运行
        lock.lock();
        try {
            //number作为信号量,为2的时候就应该执行print10()方法
            while (number != 2) {
                //如果不是2,此线程就等待
                c2.await();
            }
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            //接下来应该轮到print15()方法启动了
            number = 3;
            //唤醒print15()所拥有的的线程
            c3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print15() {
        //加锁,每次只有一个线程能运行
        lock.lock();
        try {
            while (number != 3) {
                //如果不是3,此线程就等待
                c3.await();
            }
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            //接下来又回到print5()方法启动了
            number = 1;
            //唤醒print5()所在线程
            c1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

从注释我们可以看出,通过Lock加锁,可以每次只让一个方法进行,通过number信号量和三个condition,可以精确地唤醒对应地线程,接下来,我们分别创建线程,来执行一下这三个方法:

   public static void main(String[] args) {
        ShareResources shareResources = new ShareResources();

        for (int i = 1; i < 5; i++) {
            new Thread(() -> {
                shareResources.print5();
            }, "A").start();
        }
        for (int i = 1; i < 5; i++) {
            new Thread(() -> {
                shareResources.print10();
            }, "B").start();
        }
        for (int i = 1; i < 5; i++) {
            new Thread(() -> {
                shareResources.print15();
            }, "C").start();
        }

    }

再看一下执行结果:
JAVA并发编程——Synchronized与Lock的区别以及Lock的使用_第3张图片
执行成功!

总结:
通过这篇博客,我们总结了Synchronized与Lock的区别,得出synchronized是可以全部换成lock的,而且lock的控制比synchronized更家精确和自由一点,还是用了Lock进行线程的顺序循环输出。

你可能感兴趣的