传统的Synchronized锁
线程就是一个单独的资源类，它没有任何的附属操作！
先看不加Synchronized多线程并发下的买票问题：
public class SaleTicket {
public static void main(String[] args) {
Ticket ticket = new Ticket();
//并发，多个线程操作同一个资源类，将类丢入线程。
new Thread(()->{
for (int i = 1; i < 40; i++){
ticket.sale();
}
},"A").start();
new Thread(()->{
for (int i = 1; i < 40; i++){
ticket.sale();
}
},"B").start();
new Thread(()->{
for (int i = 1; i < 40; i++){
ticket.sale();
}
},"C").start();
}
}
class Ticket{
/*票数*/
private int number = 30;
/*买票的方式*/
public void sale(){
if (number > 0){
System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张，还剩"+number+"张。");
}
}
}
运行结果：
A卖出了第30张，还剩29张。
A卖出了第29张，还剩28张。
A卖出了第28张，还剩27张。
A卖出了第27张，还剩26张。
A卖出了第26张，还剩25张。
A卖出了第25张，还剩24张。
A卖出了第24张，还剩23张。
A卖出了第23张，还剩22张。
A卖出了第22张，还剩21张。
A卖出了第21张，还剩20张。
A卖出了第20张，还剩19张。
A卖出了第19张，还剩18张。
A卖出了第18张，还剩17张。
C卖出了第16张，还剩15张。
C卖出了第15张，还剩14张。
C卖出了第14张，还剩13张。
C卖出了第13张，还剩12张。
C卖出了第12张，还剩11张。
C卖出了第11张，还剩10张。
C卖出了第10张，还剩9张。
C卖出了第9张，还剩8张。
C卖出了第8张，还剩7张。
C卖出了第7张，还剩6张。
C卖出了第6张，还剩5张。
C卖出了第5张，还剩4张。
C卖出了第4张，还剩3张。
C卖出了第3张，还剩2张。
C卖出了第2张，还剩1张。
C卖出了第1张，还剩0张。
B卖出了第17张，还剩16张。
Process finished with exit code 0
很明显可以看到，多个线程操作一个资源类的时候，会出现抢占的情况，导致运行结果不是我们想要看到的那样，所以为保证线程同步安全，传统方式我们会在资源类中加入Synchronized锁以达到我们保证线程同步安全的目的。
/**
* synchronized 本质：队列、锁*/
public synchronized void sale(){
if (number > 0){
System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张，还剩"+number+"张。");
}
}
使用Synchronized锁后的运行结果：
A卖出了第30张，还剩29张。
A卖出了第29张，还剩28张。
A卖出了第28张，还剩27张。
A卖出了第27张，还剩26张。
A卖出了第26张，还剩25张。
A卖出了第25张，还剩24张。
A卖出了第24张，还剩23张。
A卖出了第23张，还剩22张。
A卖出了第22张，还剩21张。
A卖出了第21张，还剩20张。
A卖出了第20张，还剩19张。
A卖出了第19张，还剩18张。
A卖出了第18张，还剩17张。
A卖出了第17张，还剩16张。
A卖出了第16张，还剩15张。
A卖出了第15张，还剩14张。
A卖出了第14张，还剩13张。
A卖出了第13张，还剩12张。
A卖出了第12张，还剩11张。
A卖出了第11张，还剩10张。
B卖出了第10张，还剩9张。
B卖出了第9张，还剩8张。
B卖出了第8张，还剩7张。
B卖出了第7张，还剩6张。
B卖出了第6张，还剩5张。
B卖出了第5张，还剩4张。
B卖出了第4张，还剩3张。
B卖出了第3张，还剩2张。
B卖出了第2张，还剩1张。
B卖出了第1张，还剩0张。
Process finished with exit code 0
Lock锁
基本实现类，常用ReentrantLock可重入锁
ReentrantLock有两个构造方法，无参构造默认非公平锁，可以允许插队；有参构造可以传入一个Boolean值进行判断，若为true，则是公平锁，不允许插队，先来的先执行！
使用Lock锁的买票例子：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SaleTicket02 {
public static void main(String[] args) {
Ticket02 ticket = new Ticket02();
//并发，多个线程操作同一个资源类，将类丢入线程。
new Thread(()->{
for (int i = 1; i < 40; i++){
ticket.sale();
}
},"A").start();
new Thread(()->{
for (int i = 1; i < 40; i++){
ticket.sale();
}
},"B").start();
new Thread(()->{
for (int i = 1; i < 40; i++){
ticket.sale();
}
},"C").start();
}
}
/**
* Lock三部曲
* 1.new ReentrantLock()
* 2.lock.lock() 加锁;
* 3.finally ==> lock.unlock() 解锁*/
class Ticket02{
/*票数*/
private int number = 30;
//Lock锁
Lock lock = new ReentrantLock();
/*买票的方式*/
public void sale(){
//加锁
lock.lock();
try {
//业务代码
if (number > 0){
System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张，还剩"+number+"张。");
}
} catch (Exception e) {
e.printStackTrace();
}finally {
//解锁
lock.unlock();
}
}
}
Synchronized与Lock的区别
- synchronized 是内置的Java关键字，Lock 是一个Java类。
- synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁。
- synchronized 会自动释放锁，Lock 必须要手动释放锁，若不释放锁，会死锁！
- synchronized 线程A（获得锁，阻塞），线程B（等待，一直等待）；Lock 不一定会等待下去，可以用lock.tryLock()尝试获取锁。
- synchronized 默认可重入，不可以中断的，非公平；Lock 默认可重入，可以进行判断锁，非公平（可以进行设置）。
- synchronized 适合锁少量的代码同步问题；Lock 适合锁大量的同步代码！
