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

为什么会出现线程安全问题？

先来运行一段程序(售票系统)，采用Runnable接口，代码如下：

public class MyRunnable implements Runnable {
    private int ticket = 10;

    @Override
    public void run() {
    
        while (true){
                if (ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 卖出票 : " + ticket--);
                }
        }
    }
}

public class TestThread {
    public static void main(String[] args) {
        Runnable r = new MyRunnable();
        new Thread(r).start();  //线程1
        new Thread(r).start();  //线程2
        new Thread(r).start();  //线程3

    }
}

结果如下图:

我们可以看到票出现了 0 和 -1，因为在最后票还剩余1张，因此可以通过 if (ticket > 0)语句，线程2、线程1与线程0都通过了if语句，执行到了sleep语句，进行睡眠，然后线程2首先抢到了CPU，卖出了最后一张票，此时已经没有票可以卖了，然而线程1和线程0又继续抢到了CPU，卖出了票，出现了上述问题

一、使用同步代码块synchronized

格式：
	synchronized(锁){
	可能会出现线程安全问题的代码(访问了共享数据的代码)
}
1.通过代码块中的锁对象，可以使用任意的对象
2.必须保证多个线程使用的锁对象是同一个
3.锁对象把同步代码块锁住，只让一个线程在同步代码块中执行

public class MyRunnable implements Runnable {
    private int ticket = 10;
    private Object obj = new Object(); //为保证线程用的锁对象为同一个，在方法外创建锁对象

    @Override
    public void run() {

        while (true){
            synchronized (obj){	//使用同步代码块，锁对象为obj

                if (ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 卖出票 : " + ticket--);
                }

            }
        }
    }
}

public class TestThread {
    public static void main(String[] args) {
        Runnable r = new MyRunnable();
        new Thread(r).start();  //线程1
        new Thread(r).start();  //线程2
        new Thread(r).start();  //线程3

    }
}

结果如下：

二、使用同步方法

/**
 * 使用同步方法：
 *  1.把共享数据的代码抽取出来，放到一个方法中
 *  2.在方法上添加synchronized修饰符
 */
public class MyRunnable2 implements Runnable {
    private int ticket = 10;


    @Override
    public void run() {

        while (true){
            payTicked();
        }
    }

    public synchronized void payTicked(){	//同步方法的锁对象就是this
        if (ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " 卖出票 : " + ticket--);
        }
    }
}

静态同步方法：

public class MyRunnable2 implements Runnable {
    private static int ticket = 10;


    @Override
    public void run() {

        while (true){
            payTicked();
        }
    }

    public static synchronized void payTicked(){
        if (ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " 卖出票 : " + ticket--);
        }
    }
}

静态同步方法的锁对象不是this， 其锁对象是本类的class文件对象

三、使用Lock锁

lock比sychronized可获得更加广泛的锁定操作
Lock接口中的方法：void lock() void unlock()

使用方法：
1.在成员变量中创建一个ReentrantLock()对象
2.在有可能出现安全问题的代码前使用lock()方法获取锁
3.在有可能出现安全问题的代码后使用unlock()方法释放锁

public class MyLock implements Runnable {
    private int ticket = 10;
    Lock lock = new ReentrantLock();

    @Override
    public void run() {

        while (true){
            lock.lock();    //调用lock()方法

            if (ticket > 0){
                try {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + " 卖出票 : " + ticket--);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock(); //调用unlock方法
                }
            }

        }
    }


}