解决线程安全问题的三种方法

线程安全问题的解决方法：

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方法获取锁
                }
            }
        }
    }

}