1.Synchronized与Lock的区别
2.Condition的根底概念
3.应用Condition循环程序打印ABC
1.Condition的根底概念
咱们可能对于Condition类都比拟生疏，所以咱们从咱们比拟相熟的Synchronized开始比照着学习。
咱们都晓得Synchronized都有下图这三个应用办法：
首先是咱们已知的最纯熟的synchronized关键字，他是保障线程同步用的，而后是Thread.notify()(唤醒所有正在期待中的线程)，Thread.wait()(将该线程退出期待队列)。
然而咱们的Lock接口也有相似的三个办法：
其中，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();
}
}再看一下执行后果：
执行胜利！
总结：
通过这篇博客，咱们总结了Synchronized与Lock的区别，得出synchronized是能够全副换成lock的，而且lock的管制比synchronized更家准确和自在一点，还是用了Lock进行线程的程序循环输入。
发表回复