一、Synchronized 关键字
synchronized 是 Java 中的关键字，是一种同步锁。它修饰的对象有以下几种：
1、修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{} 括起来的代码，作用的对象是调用这个代码块的对象；
2、修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
虽然可以使用 synchronized 来定义方法，但 synchronized 并不属于方法定义的一部分，因此， synchronized 关键字不能被继承。如果在父类中的某个方法使用了 synchronized 关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized 关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。
3、修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4、修改一个类，其作用的范围是 synchronized 后面括号括起来的部分，作用主的对象是这个类的所有对象。
https://www.cnblogs.com/lukelook/p/9946065.html
https://blog.csdn.net/import_sadaharu/article/details/78846675
二、售票案例
1、不加 synchronized 同步锁
示例：
//第一步 创建资源类，定义属性和和操作方法
class Ticket {
//票数
private int number = 30;
//操作方法，买票
public void sale() {
//判断：是否有票
if (number > 0) {
System.out.println(Thread.currentThread().getName() + "：卖出" + (number--) + " 剩下：" + number);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class SaleTicket {
//第二步 创建多个线程，调用资源类的操作方法
public static void main(String[] args) {
//创建Ticket对象
Ticket ticket = new Ticket();
//创建三个线程
new Thread(new Runnable(){
@Override
public void run() {
//调用卖票方法
for (int i = 0; i < 40; i++) {
ticket.sale();
}
}
}, "AA").start();
new Thread(new Runnable(){
@Override
public void run() {
//调用卖票方法
for (int i = 0; i < 40; i++) {
ticket.sale();
}
}
}, "BB").start();
new Thread(new Runnable(){
@Override
public void run() {
//调用卖票方法
for (int i = 0; i < 40; i++) {
ticket.sale();
}
}
}, "CC").start();
}
}
运行结果：
（1）卖出重票
（2）超卖
2、使用 synchronized 同步锁
示例：
class Ticket {
//票数
private int number = 30;
//操作方法，买票
public synchronized void sale() {
//判断：是否有票
if (number > 0) {
System.out.println(Thread.currentThread().getName() + "：卖出" + (number--) + " 剩下：" + number);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
加上同步锁后，不会有多个线程同时操作同一资源，也不会发生上面的两种情况。
3、分析
如果一个代码块被 synchronized 修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：
1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
2）线程执行发生异常，此时 JVM 会让线程自动释放锁。
那么如果这个获取锁的线程由于要等待 IO 或者其他原因（比如调用 sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。
因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过 Lock 就可以办到。
三、多线程编程步骤（上）
第一步：创建资源类，在资源类创建数据和操作方法；
第二步：创建多个线程，调用资源类的操作方法；
口诀一：在高内聚低耦合的前提下，线程操作（对外暴露的调用方法） 资源类
四、补充
创建线程的四种方式：
1、继承 Thread 类
public class SaleTicket extends Thread{}
不推荐使用，java是单继承，继承宝贵，要用接口方式
2、实现 Runnable 接口
① 新增类实现 Runnable 接口
class MyThread implements Runnable//新建类实现runnable接口
new Thread(new MyThread,...)
这种方法会新增类，有更新更好的方法。
② 匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
}
}, "your thread name").start();
这种方法不需要创建新的类，可以new接口
③ Lambda 表达式
new Thread(() -> {
}, "your thread name").start();
这种方法代码更简洁精炼
3、实现 Callable 接口
4、使用线程池
第三种和第四种后面学习。
