线程安全问题：
线程安全出现的根本原因：
1.存在两个或者两个以上的线程对象共享同一个资源；
2.多线程操作共享资源代码有多个语句。
一、使用同步代码块
如：卖票案例 出现了线程安全 重复的票不能出现
步骤：成员位置建立锁对象；
synchronized(锁对象){
出现安全问题代码
}
注意事项：
1 锁对象可以是任意对象
2 必须保证多个线程使用的是同一个锁对象 、
3 把{} 让一个线程进
4.一个线程在同步代码块中sleep了，并不会释放锁对象；
5.如果不存在线程安全问题，千万不要使用同步代码块；
6.锁对象必须是多线程共享的一个资源，否则锁不住。
例子：
public class RunnableImpl implements Runnable{
// 定义共享资源 线程不安全
private int ticket = 100;
//在成员位置创建一个锁对象
Object obj = new Object();
// 线程任务 卖票
@Override
public void run() {
while(true){
//建立锁对象
synchronized (obj){
if(ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卖票操作
System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
ticket--;
}
}
}
}
}
二、使用同步方法（函数）解决多线程安全
同步函数就是使用synchronized修饰一个函数
步骤
1 创建一个方法 修饰符添加synchronized 2 把访问了 共享数据的代码放入到方法中 3 调用同步方法
注意事项：
同步函数注意事项：
1.如果函数是一个非静态的同步函数，那么锁对象是this对象；
2.如果函数是静态的同步函数，那么锁对象是当前函数所属的类的字节码文件（class对象）；
3.同步函数的锁对象是固定的，不能由自己指定。
例子：
public class RunnableImpl implements Runnable{
// 定义共享资源 线程不安全
private int ticket = 100;
// 线程任务 卖票
@Override
public void run() {
while(true){
payTicket();//调用下面synchronized修饰的方法
}
}
public synchronized void payTicket(){
if(ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卖票操作
System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
ticket--;
}
}
}
推荐使用：同步代码块
原因：
1.同步代码块的锁对象可以由我们自由指定，方便控制；
2.同步代码块可以方便的控制需要被同步代码的范围，同步函数必须同步函数的所有代码。
三.使用lock锁
原因：synchronized的缺陷
synchronized是java中的一个关键字，也就是说是Java语言内置的特性。那么为什么会出现Lock呢？
synchronized 的局限性 与 Lock 的优点 如果一个代码块被synchronized关键字修饰，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待直至占有锁的线程释放锁。事实上，占有锁的线程释放锁一般会是以下三种情况之一： 1：占有锁的线程执行完了该代码块，然后释放对锁的占有； 2：占有锁线程执行发生异常，此时JVM会让线程自动释放锁； 3：占有锁线程进入 WAITING 状态从而释放锁，例如在该线程中调用wait()方法等。 试考虑以下三种情况： Case 1 ： 在使用synchronized关键字的情形下，假如占有锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，那么其他线程就只能一直等待，别无他法。
这会极大影响程序执行效率。因此，就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间 (解决方案：tryLock(long time, TimeUnit unit))
或者 能够响应中断 (解决方案：lockInterruptibly())），这种情况可以通过 Lock 解决。 Case 2 ： 我们知道，当多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作也会发生冲突现象，但是读操作和读操作不会发生冲突现象。
但是如果采用synchronized关键字实现同步的话，就会导致一个问题，即当多个线程都只是进行读操作时，也只有一个线程在可以进行读操作，其他线程只能等待锁的释放而无法进行读操作。
因此，需要一种机制来使得当多个线程都只是进行读操作时，线程之间不会发生冲突。同样地，Lock也可以解决这种情况 (解决方案：ReentrantReadWriteLock) 。 Case 3 ： 我们可以通过Lock得知线程有没有成功获取到锁 (解决方案：ReentrantLock) ，但这个是synchronized无法办到的。 上面提到的三种情形，我们都可以通过Lock来解决，但 synchronized 关键字却无能为力。
事实上，Lock 是 java.util.concurrent.locks包 下的接口，Lock 实现提供了比 synchronized 关键字 更广泛的锁操作，它能以更优雅的方式处理线程同步问题。也就是说，Lock提供了比synchronized更多的功能。
总结一下，也就是说Lock提供了比synchronized更多的功能。但是要注意以下几点： 1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问； 2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；
而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。
Lock接口实现类的使用
Lock接口有6个方法：
// 获取锁 void lock() // 如果当前线程未被中断，则获取锁，可以响应中断 void lockInterruptibly() // 返回绑定到此 Lock 实例的新 Condition 实例 Condition newCondition() // 仅在调用时锁为空闲状态才获取该锁，可以响应中断 boolean tryLock() // 如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁 boolean tryLock(long time, TimeUnit unit) // 释放锁 void unlock()
注意
lock()、tryLock()、tryLock(long time, TimeUnit unit) 和 lockInterruptibly()都是用来获取锁的。
unLock()方法是用来释放锁的。newCondition() 返回 绑定到此 Lock 的新的 Condition 实例 ，用于线程间的协作，详细内容请查找关键词：线程间通信与协作。
参考： https://www.cnblogs.com/myseries/p/10784076.html
https://www.bilibili.com/video/BV1uJ411k7wy?p=323