JAVA-多线程4

1.线程安全

        synchronized 关键字，要搭配一个“锁对象”

        synchronized(锁对象){}

        针对哪个对象加锁，此处规则有且只有一条：

        当两个线程针对一个对象加锁的时候，就会出现锁竞争/锁冲突

        一个线程能拿到锁，另一个线程就会阻塞等待（BLOCKED），直到第一个线程释放了锁之后，第二个线程才可能获取到锁，才能继续往下执行。

        这个对象是谁无所谓，我们唯一关注的就是两个线程是否针对同一个对象加锁，和这个synchronized修饰不修饰方法，和synchronized里头访问哪个对象的属性啥的都没有关系。

        synchronized修饰的是静态方法

①public synchronized static void func(){}

静态方法，和具体的对象无关，是和类有关

②synchronized(Counter.class){}

• 在synchronized中，（）里写类对象还是普通对象，都没有任何区别
• synchronized不关心对象是啥，只关心两个线程是否只针对同一个对象加锁
• 类对象：类的图纸

        一个类的完整信息，最初是在.java文件中=>.class文件

        JVM加载 .class就会解析里面的内容，构造出一个内存中的对象，也就是类的类对象

        类对象(new实例基本都是基于类对象作为模板创建出来) => .class文件 => .java文件

 2.内存可见性

package thread;

import java.util.Scanner;

public class Demo13 {
    private static int isQuit =0;
    public static void main(String[] args) {
        //Thread t1=new Thread(() ->{
           while(isQuit == 0){
               ;
           }
            System.out.println("t1执行结束了");
        });//①

        //Thread t2=new Thread(() ->{
            Scanner scanner=new Scanner(System.in);
            System.out.println("输入isQuit的值：");
            ？isQuit=scanner.nextInt();？③
        });//②

        t1.start();
        t2.start();
    }
}

理想预期：

        t1始终在进行whle的循环，t2则是要用户通过控制台输入一个整数，作为isQuit的值，当用户输入的仍然是0的时候，t1线程继续执行

        如果用户的是非0，t1线程就应该循环结束 

问题出现了：

        当输入了非0值的时候，已经修改了isQuit的值了，但是t1线程仍然在继续执行，这也是不符合预期，这也是bug

2.1代码中的含义或理解

        ①中本质上是两个指令：

1. load(读内存)：读内存操作，速度非常慢
2. jcmp(比较，并跳转) 寄存器，速度极快

        此时，编译器/JVM就发现，这个逻辑中，代码要反复的，快速的读取同一个内存的值，并且这个内存的值每次读出来还是一样的

        此时，编译器就做出了一个大胆的决策，直接把load操作优化掉了，只是第一次执行load，后续都不会再执行load，直接拿寄存器中的数据进行比较

         ②在另一个线程t2中，修改了isQuit的值

        此时，编译器没法准确判定出t2线程到底会不会执行，啥时候执行，因此就不会出现误判

        ③虽然把内存中的isQuit给改了，但是另一个线程中，并没有重复读取isQuit的值，因此t1线程就无法感知t2的修改，此时就会出现上述问题 

 2.2 内存可见性问题(volatile)

        volatile(易变的，动荡不定的，反复无常的)关键字，弥补上述缺口

package thread;

import java.util.Scanner;

public class Demo13 {
    private volatile static int isQuit =0;
    public static void main(String[] args) {
        Thread t1=new Thread(() ->{
           while(isQuit == 0){
               ;
           }
            System.out.println("t1执行结束了");
        });

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

        t1.start();
        t2.start();
    }
}

         把volatile用来修饰一个变量之后，编译器就会明白，这个变量是“易变的”，就不能按照上述方法，把读操作优化到寄存器中(  编译器就会禁止上述优化)，于是就能保证t1在循环过程中，始终都能读取内存中的数据

        volatile本质上是保存变量的内存可见性(禁止变量的读操作被优化到读寄存器中)

---

不加volatile，针对①的代码进行修改：

package thread;

import java.util.Scanner;

public class Demo13 {
    private static int isQuit =0;
    public static void main(String[] args) {
        Thread t1=new Thread(() ->{
           while(isQuit == 0){
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
            System.out.println("t1执行结束了");
        });

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

        t1.start();
        t2.start();
    }
}

 

         加了sleep之后，sleep就会大幅度的影响到while循环的速度，速度慢了，编译器就不打算继续优化了，此时即使不加volatile也能及时感知到内存变化了

3.wait(等待)和notify(通知)

         用来协调线程顺序的重要工具

        wait在执行的时候，会做三样事:

1.  解锁，object.wait就会尝试针对object对象的解锁
2. 阻塞等待
3. 当被其他线程唤醒之后，就会尝试重新加锁，加锁成功，wait执行完毕，继续往下执行其他逻辑

package thread;

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

 

        运行结果为空白，是因为wait进行阻塞，一直阻塞其他进程的notify

        核心思路：先加锁，再在synchronized里面再进行wait 

---

package thread;

public class Demo15 {
    //使用这个锁对象来负责加锁wait、notify
    private static Object locker=new Thread();
    public static void main(String[] args) {
        Thread t1=new Thread(() ->{
            while(true){
                synchronized (locker){
                    System.out.println("t1 wait 开始");
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t1 wait 结束");
                }
            }
        });
    t1.start();
    Thread t2=new Thread(() ->{
       while(true){
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           synchronized (locker){
               System.out.println("t2 notify 开始");
               locker.notify();
               System.out.println("t2 notify 结束");
           }
       }
    });
    t2.start();
    }
}

运行结果：

        t1 wait 开始

        t2 notify 开始

        t2 notify 结束

        t1 wait 结束

        t1 wait 开始

        .......

        一直往复....

几个注意事项：

1. 要想让notify能够顺利唤醒wait，就需要确保notify和wait都是使用同一个对象调用的
2. wait和notify都需要放在synchronized之内的，虽然，notify不涉及"解锁操作"，但是Java也强制要求notify要放到synchronized中
3. 如果进行notify的时候，另一个线程并没有处于wait状态，此时，notify相当于"空打一炮"，不会有任何副作用

---

4.wait和sleep之间的区别

• sleep是有一个明确的时间的，到达时间，自然就会被唤醒，使用interrupt也可以打断睡眠
• wait默认是死等，一直等到有其他线程notify，wait也能够被interrupt提前唤醒

notify表示顺理成章的唤醒，唤醒之后该线程还需要继续工作，后续还会进入到wait状态

 interrupt表示告知线程就要结束了，接下来的线程要进入收尾工作了

         因此协调多个线程之间的执行顺序时，当然还是考虑使用wait和notify，而不是sleep