线程安全问题的解决方法：
1、同步代码块
2、同步方法
3、锁机制
第一种方法：同步代码块
格式：
synchronized(锁对象) {
可能会出现线程安全问题的代码（访问共享数据的代码）
}
注意：
1、通过代码块的锁对象，可以是任意的对象
2、必须保证多个线程使用的锁对象是同一个
3、锁对象的作用是把同步代码快锁住，只允许一个线程在同步代码块执行
Runable实现类
public class RunableImpl implements Runnable {
private int ticket = 100;
// 创建一个锁对象,锁对象应该创建在run方法外，因为不同的线程应该使用同一个锁对象，如果在run方法里面，就会每个线程自己创建一个锁对象，也就是不唯一了
Object object = new Object();
@Override
public void run() {
while(true) {
synchronized (object) {// 访问了共享数据的代码，也就是可能出现线程安全问题的代码，写在同步代码块里面
if(ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " is selling ticket number--> " + ticket);
ticket--;
}
}
}
}
}
再次开启多个线程，发现就没有出现线程安全问题了
package cn.zhuobo.day12.threadSafe;
public class RunableDemo {
public static void main(String[] args) {
RunableImpl run = new RunableImpl();
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
Thread t3 = new Thread(run);
t1.start();
t2.start();
t3.start();
}
}
同步代码块的原理：
使用了一个锁对象，叫同步锁，对象锁，也叫同步监视器，当开启多个线程的时候，多个线程就开始抢夺CPU的执行权，比如现在t0线程首先的到执行，就会开始执行run方法，遇到同步代码快，首先检查是否有锁对象，发现有，则获取该锁对象，执行同步代码块中的代码。之后当CUP切换线程时，比如t1得到执行，也开始执行run方法，但是遇到同步代码块检查是否有锁对象时发现没有锁对象，t1便被阻塞，等待t0执行完毕同步代码块，释放锁对象，t1才可以获取从而进入同步代码块执行。
同步中的线程，没有执行完毕是不会释放锁的，这样便实现了线程对临界区的互斥访问，保证了共享数据安全。
缺点：频繁的获取释放锁对象，降低程序效率
第二种方法：同步方法
使用步骤：
1、把访问了共享数据的代码抽取出来，放到一个方法中
2、在该方法上添加 synchronized 修饰符
格式：
修饰符 synchronized 返回值类型 方法名称（参数列表） {
method body
}
public class RunableImpl implements Runnable {
private int ticket = 100;
// 创建一个锁对象,锁对象应该创建在run方法外，因为不同的线程应该使用同一个锁对象，如果在run方法里面，就会每个线程自己创建一个锁对象，也就是不唯一了
Object object = new Object();
@Override
public void run() {
while(true) {
sellTicket();
}
}
public synchronized void sellTicket() {// 同步方法，访问了共享数据的代码，可能出现线程安全问题的代码，放到一个方法中
if(ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " is selling ticket number--> " + ticket);
ticket--;
}
}
}
同步方法的也是一样锁住同步的代码，但是锁对象的是Runable实现类对象，也就是this，谁调用方法，就是谁，在这里就是创建的run对象
静态的同步方法，添加一个静态static修饰符，此时锁对象就不是this了，静态同步方法的锁对象是本类的class属性，class文件对象（反射）
public static synchronized void sellTicket() {
if(ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " is selling ticket number--> " + ticket);
ticket--;// 访问了变量应该定义为static的，因为静态方法要访问静态变量
}
}
}
第三种方法：Lock接口
java.util.concurrent.locks.Lock
Lock接口中的方法：
void lock():获取锁
void unlock():释放锁
Lock接口的一个实现类
java.util.concurrent.locks.ReentrantLock implements Lock接口
使用方法：
1、在Runable实现类的成员变量创建一个ReentrantLock对象
2、在可能产生线程安全问题的代码前该对象调用lock方法获取锁
3、在可能产生线程安全问题的代码后该对象调用unlock方法获取锁
public class RunableImpl implements Runnable {
private static int ticket = 100;
// 创建一个锁对象,锁对象应该创建在run方法外，因为不同的线程应该使用同一个锁对象，如果在run方法里面，就会每个线程自己创建一个锁对象，也就是不唯一了
Object object = new Object();
ReentrantLock l = new ReentrantLock();// 1、在Runable实现类的成员变量创建一个ReentrantLock对象
@Override
public void run() {
while(true) {
l.lock();// 2、在可能产生线程安全问题的代码前该对象调用lock方法获取锁
if(ticket > 0) {
try {
Thread.sleep(10);
System.out.println(Thread.currentThread().getName() + " is selling ticket number--> " + ticket);
ticket--;
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// unlock方法放在finally里面，无论程序是否有出现异常，该方法都会执行，也就是都会释放锁
l.unlock();// 3、在可能产生线程安全问题的代码后该对象调用unlock方法获取锁
}
}
}
}
}