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

    }
}

结果如下图:
java解决线程安全问题的三种方法_第1张图片
我们可以看到票出现了 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

    }
}

结果如下:

java解决线程安全问题的三种方法_第2张图片

二、使用同步方法

/**
 * 使用同步方法:
 *  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方法
                }
            }

        }
    }


}

你可能感兴趣的:(java解决线程安全问题的三种方法)