线程安全(2)

volatile关键字

内存可见性也会引起线程不安全的问题,让我举一个例子,来进行学习.

public class Demo14 {
    private static int isQuit = 0;
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            // isQuit不为0时就跳出循环,线程thread1结束
            while (isQuit == 0) {
                ;
            }
            System.out.println("thread1执行结束了");
        });

        Thread thread2 = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入isquit的值: ");
            isQuit = scanner.nextInt();
        });

        thread1.start();
        thread2.start();

    }
}

我们预想的是当输入的isQuit不为0时,thread1就结束了.

可是thread1线程并没有结束,这显然是一个bug.
在这个地方,java编译器和jvm做出了一些优化,让我们写的代码出现了bug.
先来看这出逻辑

while (isQuit == 0) {
      ;
}

isQuit == 0 也不是只有一处逻辑,本质上是两个指令:

1. load: 读内存, 是比较慢的.
2. jcmp: 比较,并跳转,是很快的,在寄存器上操作的.
   在此时,编译器/JVM就发现,代码要反复的,快速的读取同一个内存的值,并且这个内存读出来的值还是一样的,所以,编译器就把读操作这一步给优化了,只在第一次执行load,后面都不执行了,直接拿寄存器中的数据进行比较了.
   在这里:

isQuit = scanner.nextInt();

虽然我们把isQuit的值给改了,但是thread1线程并没有反复读取isQuit的值,这就是内存可见性问题!!

用volatile关键字修饰后,编译器就会明白,此时修饰的变量是易变的,编译器就不会做出那步优化,保证了thread1线程能够随时读取内存中的数据.

public class Demo14 {
    private volatile static int isQuit = 0;
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            // isQuit不为0时就跳出循环,线程thread1结束
            while (isQuit == 0) {
                ;
            }
            System.out.println("thread1执行结束了");
        });

        Thread thread2 = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入isquit的值: ");
            isQuit = scanner.nextInt();
        });

        thread1.start();
        thread2.start();

    }
}

其实,我们也不知道编译器什么时候做出优化,比如我们在代码中加入sleep方法,它也不会进行优化,线程也正常结束了.

Thread thread1 = new Thread(() -> {
            // isQuit不为0时就跳出循环,线程thread1结束
            while (isQuit == 0) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("thread1执行结束了");
        });

wait和notify

wait()方法

wait方法的作用:

1. 使当前执行代码的线程进行等待(把线程放到等待队列中)
2. 会释放当前的锁.
3. 当满足条件被唤醒后,会尝试重新获取这个锁.

wait()要搭配synchronized()方法使用,不然wait方法会抛出异常.

wait方法结束等待的条件:

• 其它线程调用对象的notify方法.
• wait()等待时间超时.
• 其它线程调用等待线程的interrupted方法.

public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        synchronized(object) {
            System.out.println("进入等待");
            object.wait();
            System.out.println("等待结束");
        }
    }

// 1. 解锁
// 2. 阻塞等待
// 3. 当被其它线程唤醒后,就会尝试重新加锁,加锁成功后,wait执行完毕,继续执行代码逻辑.

notify方法

notify(): 唤醒等待的线程.

private static Object locker = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
           while (true) {
               synchronized (locker) {
                   System.out.println("wait开始");
                   try {
                       locker.wait();
                   } catch (InterruptedException e) {
                       throw new RuntimeException(e);
                   }
                   System.out.println("wait结束");
               }
           }
        });

        Thread thread2 = new Thread(() -> {
            while (true) {
                // 给予缓冲时间
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                synchronized (locker) {
                    System.out.println("notify开始");
                    // 唤醒wait()
                    locker.notify();
                    System.out.println("notify结束");
                }
            }
        });

        thread1.start();
        thread2.start();

注意事项:

1. 确保wait和notify都是同一个对象调用的.
2. wait和notify都需要放到synchronized中,虽然notify不涉及解锁操作,但java强制要求notify放到sybchronized中.
3. 只进行notify的时候(没有wait的线程),此时没有副作用.

wait和sleep的区别

sleep是有明确时间的,时间到了,自然就醒了.也可以被interrupt唤醒.
wait是一直等待,直到其它线程有notify来将它唤醒,也能被interrupt唤醒.

结语

本次博客总结了volatile关键字,wait和notify的定义和使用,下次我将会总结设计模式中的单例模式和工厂模式,请大家多多支持.