2.1.1）Synchronized 关键字简介
synchronized 是 Java 中的关键字，是一种同步锁，它修饰的对象有以下几种：
-
修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{} 括起来的代码，作用的对象是调用这个代码块的对象；
-
修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。
如果在父类中的某个方法使用了synchronized关键字，而在子类中复写了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上 synchronized关键字才可以。还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此， 子类的方法也就相当于同步了。
-
修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
-
修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。
2.1.2）使用Synchronized 关键字示例
使用Synchronized 关键字实现卖票的示例：
package com.study.sync;
//第一步 创建资源类，定义属性和和操作方法
class Ticket {
//票数
private int number = 30;
//操作方法：卖票
public synchronized void sale() {
//判断：是否有票
if (number > 0) {
System.out.println(Thread.currentThread().getName() + " : 卖出：" + (number--) + " 剩下：" + number);
}
}
}
public class SaleTicket {
//第二步 创建多个线程，调用资源类的操作方法
public static void main(String[] args) {
//创建Ticket对象
Ticket ticket = new Ticket();
//创建三个线程
// 创建线程 AA
new Thread(new Runnable() {
@Override
public void run() {
//调用卖票方法
for (int i = 0; i < 40; i++) {
ticket.sale();
}
}
}, "AA").start();
// 创建线程 BB
new Thread(new Runnable() {
@Override
public void run() {
//调用卖票方法
for (int i = 0; i < 40; i++) {
ticket.sale();
}
}
}, "BB").start();
// 创建线程 CC
new Thread(new Runnable() {
@Override
public void run() {
//调用卖票方法
for (int i = 0; i < 40; i++) {
ticket.sale();
}
}
}, "CC").start();
}
}
输出：
com.study.sync.SaleTicket
AA : 卖出：30 剩下：29
AA : 卖出：29 剩下：28
AA : 卖出：28 剩下：27
AA : 卖出：27 剩下：26
AA : 卖出：26 剩下：25
AA : 卖出：25 剩下：24
AA : 卖出：24 剩下：23
AA : 卖出：23 剩下：22
AA : 卖出：22 剩下：21
AA : 卖出：21 剩下：20
AA : 卖出：20 剩下：19
AA : 卖出：19 剩下：18
AA : 卖出：18 剩下：17
AA : 卖出：17 剩下：16
AA : 卖出：16 剩下：15
BB : 卖出：15 剩下：14
BB : 卖出：14 剩下：13
BB : 卖出：13 剩下：12
BB : 卖出：12 剩下：11
BB : 卖出：11 剩下：10
BB : 卖出：10 剩下：9
BB : 卖出：9 剩下：8
BB : 卖出：8 剩下：7
BB : 卖出：7 剩下：6
BB : 卖出：6 剩下：5
BB : 卖出：5 剩下：4
BB : 卖出：4 剩下：3
BB : 卖出：3 剩下：2
BB : 卖出：2 剩下：1
BB : 卖出：1 剩下：0
2.1.3）Synchronized 关键字说明
如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：
-
获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
-
线程执行发生异常，此时JVM会让线程自动释放锁。
那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep 方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一 下，这多么影响程序执行效率。
因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等 待一定的时间或者能够响应中断），通过Lock就可以办到。
2.2）LockLock锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作；Lock允许更灵活的结构，能具有非常不同的属性，并且能支持多个关联的条件对象；Lock提供了比synchronized更多的功能。
2.2.1）使用Lock 接口示例
使用Lock 接口实现卖票的示例：
package com.study.lock;
import java.util.concurrent.locks.ReentrantLock;
//第一步 创建资源类，定义属性和和操作方法
class LTicket {
//票数量
private int number = 30;
//创建可重入锁
private final ReentrantLock lock = new ReentrantLock(true);
//卖票方法
public void sale() {
//上锁
lock.lock();
try {
//判断是否有票
if (number > 0) {
System.out.println(Thread.currentThread().getName() + " ：卖出" + (number--) + " 剩余：" + number);
}
} finally {
//解锁
lock.unlock();
}
}
}
public class LSaleTicket {
//第二步 创建多个线程，调用资源类的操作方法
//创建三个线程
public static void main(String[] args) {
LTicket ticket = new LTicket();
// 创建线程 AA
new Thread(() -> {
for (int i = 0; i < 40; i++) {
ticket.sale();
}
}, "AA").start();
// 创建线程 BB
new Thread(() -> {
for (int i = 0; i < 40; i++) {
ticket.sale();
}
}, "BB").start();
// 创建线程 CC
new Thread(() -> {
for (int i = 0; i < 40; i++) {
ticket.sale();
}
}, "CC").start();
}
}
输出：
com.study.sync.SaleTicket
AA ：卖出30 剩余：29
AA ：卖出29 剩余：28
AA ：卖出28 剩余：27
AA ：卖出27 剩余：26
AA ：卖出26 剩余：25
BB ：卖出25 剩余：24
AA ：卖出24 剩余：23
CC ：卖出23 剩余：22
BB ：卖出22 剩余：21
AA ：卖出21 剩余：20
CC ：卖出20 剩余：19
BB ：卖出19 剩余：18
AA ：卖出18 剩余：17
BB ：卖出17 剩余：16
AA ：卖出16 剩余：15
BB ：卖出15 剩余：14
CC ：卖出14 剩余：13
AA ：卖出13 剩余：12
BB ：卖出12 剩余：11
CC ：卖出11 剩余：10
AA ：卖出10 剩余：9
BB ：卖出9 剩余：8
CC ：卖出8 剩余：7
AA ：卖出7 剩余：6
BB ：卖出6 剩余：5
CC ：卖出5 剩余：4
AA ：卖出4 剩余：3
BB ：卖出3 剩余：2
CC ：卖出2 剩余：1
AA ：卖出1 剩余：0
2.2.2）Lock和synchronized的不同
Lock和synchronized有以下几点不同：
-
Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
-
synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
-
Lock可以让等待锁的线程响应中断，而synchronized却不行，使用 synchronized时，等待的线程会一直等待下去，不能够响应中断；
-
通过Lock可以知道有没有成功获取锁，而synchronized却无法办到；
-
Lock可以提高多个线程进行读操作的效率，在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。
