java 多线程笔记二 线程安全问题

高并发下可能回出现的超卖问题

运行一下代码，模拟超卖问题，运行后会发现会出现重复编号的票

public class Test {
    public static void main(String[] args) {
        /**
         * 模拟出售电影票
         */
        PiaoThread piaoThread = new PiaoThread();
        new Thread(piaoThread,"1号窗口").start();
        new Thread(piaoThread,"2号窗口").start();
        new Thread(piaoThread,"3号窗口").start();
        new Thread(piaoThread,"4号窗口").start();
    }
}
 
class PiaoThread implements Runnable {
    //多个窗口使用的是同一个对象,所以成员变量是共享的
    private int piao = 100;
    @Override
    public void run() {
        while (true){
            if (piao < 1){ break;}
            System.out.println(Thread.currentThread().getName()+"卖出了第"+piao+"编号的票");
            piao--;
        }
    }
}

---

同步代码块可以解决超卖问题

public class Test {
    public static void main(String[] args) {
        /**
         * 模拟出售电影票
         */
        PiaoThread piaoThread = new PiaoThread();
        new Thread(piaoThread,"1号窗口").start();
        new Thread(piaoThread,"2号窗口").start();
        new Thread(piaoThread,"3号窗口").start();
        new Thread(piaoThread,"4号窗口").start();
    }
}
 
class PiaoThread implements Runnable {
    //多个窗口使用的是同一个对象,所以成员变量是共享的
    private int piao = 100;
    @Override
    public void run() {
        while (true){
            //悲观锁
            // synchronized (锁对象)，
            // 需要是同一个对象，这里都是使用的一个对象，所以可以使用this
           synchronized (this){
               if (piao < 1){ break;}
               System.out.println(Thread.currentThread().getName()+"卖出了第"+piao+"编号的票");
               piao--;
           }
        }
 
    }
}

---

同步方法，我们把需要同步的代码块抽取出来，idea抽取方法快捷键ctrl+alt+m

同步方法的锁对象：

如果是非静态同步方法，锁对象是this

如果是静态方法那么锁对象是该方法所在类的字节码对象（类名.class）

场景：a线程使用了同步代码块，b线程使用的同步方法，这时候ab线程需要同步那么就需要知道同步方法的锁对象是谁。

public class Test {
    public static void main(String[] args) {
        /**
         * 模拟出售电影票
         */
        PiaoThread piaoThread = new PiaoThread();
        new Thread(piaoThread,"1号窗口").start();
        new Thread(piaoThread,"2号窗口").start();
        new Thread(piaoThread,"3号窗口").start();
        new Thread(piaoThread,"4号窗口").start();
    }
}
class PiaoThread implements Runnable {
    //多个窗口使用的是同一个对象,所以成员变量是共享的
    private int piao = 100;
    @Override
    public void run() {
        while (true){
            if (extracted()) break;
        }
    }
 
    private synchronized boolean extracted() {
        if (piao < 1){
            return true;
        }
        System.out.println(Thread.currentThread().getName()+"卖出了第"+piao+"编号的票");
        piao--;
        return false;
    }
}

---

lock锁解决超卖问题

public class Test {
    public static void main(String[] args) {
        /**
         * 模拟出售电影票
         */
        PiaoThread piaoThread = new PiaoThread();
        new Thread(piaoThread,"1号窗口").start();
        new Thread(piaoThread,"2号窗口").start();
        new Thread(piaoThread,"3号窗口").start();
        new Thread(piaoThread,"4号窗口").start();
    }
}
class PiaoThread implements Runnable {
    //多个窗口使用的是同一个对象,所以成员变量是共享的
    private int piao = 100;
    //创建一个lock
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();//加锁
            if (piao < 1){
                lock.unlock();//释放锁
                break;
            }
            System.out.println(Thread.currentThread().getName()+"卖出了第"+piao+"编号的票");
            piao--;
            lock.unlock();//释放锁
        }
 
    }
}

---

多线程下的可见性问题

出现可见性问题的根本原因：java的内存模型（JMM）,java所有共享变量都是存储在主内存中的，在线程执行的时候，线程有单独的工作内存，这个时候会把主内存中的共享变量拷贝一份到工作变量，并且对所有的变量操作都是在工作变量进行的。

复习可见性问题代码：一下代码我们的理想结果是子线程3秒后修改flag的值，然后主线程结束死循环，运行程序后发现结束不了死循环。下面主线程代码过于简单，运行速度很快，来不及去读主内存中的共享变量，所以一直读的工作内存变量。

public class Test2 {
    public static void main(String[] args) {
        /**
         * 可见性问题
         */
        MyThread myThread = new MyThread();
        new Thread(myThread).start();
        //主线程
        while (true){
            if (MyThread.flag){
                System.out.println("flag为true结束主线程死循环");
                break;
            }
        }
    }
}
 
class MyThread implements Runnable{
    static boolean flag = false;
    @Override
    public void run() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = true;
 
        System.out.println("修改了flag为true");
    }
}

 解决多线程安全问题之可见性问题方法：volatile关键字

public class Test2 {
    public static void main(String[] args) {
        /**
         * 可见性问题
         */
        MyThread myThread = new MyThread();
        new Thread(myThread).start();
        //主线程
        while (true){
            if (MyThread.flag){
                System.out.println("flag为true结束主线程死循环");
                break;
            }
        }
    }
}
 
class MyThread implements Runnable{
    //这里加上volatile关键字
    static volatile boolean flag = false;
    @Override
    public void run() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = true;
 
        System.out.println("修改了flag为true");
    }
}

---

多线程安全性问题之有序性问题

多线程情况下编译器对代码重排，会产生不同的结果，引发安全性问题。

volatile关键字也可以解决有序性问题

---

多线程安全性问题之原子性问题