javaEE初阶————多线程初阶(3)

大家新年快乐呀，今天是第三期啦，大家前几期的内容掌握的怎么样啦？

1，线程死锁

1.1 构成死锁的场景

a）一个线程一把锁

这个在java中是不会发生的，因为我们之前讲的可重入机制，在其他语言中可能会发生的；

public static void main(String[] args) throws InterruptedException {

        Object locker = new Object();

        Thread t1 = new Thread(()->{
            synchronized (locker){
                synchronized (locker){
                    System.out.println(1111);
                }
            }
        });

        t1.start();
        t1.join();
        System.out.println("main");
    }

按理来说，t1线程刚进synchronized就获取到了锁对象，就要保持，进入第二个synchronized就要请求第一个锁对象，第一个要保持不给你锁对象，它让第二个先给他，第二个synchronized说你先给我我才有锁对象给你呀，它俩就这么一直僵持着，但是java有可重入机制不会发生这样的死锁的；

b）两个线程两把锁

我们来模拟一个吃饺子的过程，小明小亮吃饺子，有酱油和醋对应两把锁，他们喜欢这两个东西一起加（我不喜欢），

public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        Object locker1 = new Object();//酱油
        Object locker2 = new Object();//醋

        Thread t1 = new Thread(()->{
            synchronized (locker1){
                System.out.println("获取到了酱油");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                synchronized (locker2){
                    System.out.println("酱油和醋都是" + Thread.currentThread().getName() + "的啦");
                }
            }
        },"小明");

        Thread t2 = new Thread(()->{
            synchronized (locker2){
                System.out.println("获取到了醋");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                synchronized (locker1){
                    System.out.println("酱油和醋都是" + Thread.currentThread().getName() + "的啦");
                }
            }
        },"小亮");

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

我们来看运行结果

没有人获得酱油和醋，并且程序也没有正常停止，

这俩线程都因为锁竞争阻塞了，这就构成了死锁，我们加那个sleep是为了保证小亮拿醋，小明拿酱油之后再竞争互相的，不然可能就小明太快了直接全拿走了，或者小亮全拿走了；

c）n个线程m把锁

一个很经典的模型，哲学家就餐问题：

1，哲学家可以放下筷子思考

2，哲学家拿筷子可以吃面条（没有洁癖）两根才能吃

但是哲学家都很固执，拿到了筷子是不会放手的，那么如果在当前这个图上每个人都想吃面条，每个人都到拿到了面前的筷子，要吃面条还需要一个筷子，他们就会想要别人的筷子，然而每个人都不会放开自己的筷子，你等我，我等你，最后大家都饿死，这就构成了死锁；但是按理来说这个模型出现这样的情况非常非常低那么中国10几亿人，这个概率就会无限放大，线程安全要做到完全没有危险的概率；

1.2 死锁的四个必要条件

a）互斥（基本特性）

一个线程获取到锁，其他线程再想获得这个锁就要阻塞等待；

b）不可剥夺（基本特性）

也可以叫不可抢占，如果线程1获取到了锁，线程2再想获取锁是不可以抢夺的，必须阻塞等待；

c）请求和保持

一个线程获取了锁1之后再不放弃锁1的前提下获取锁2；

d）循环等待

a等待b，b等待c，c等待d，d等待a；构成死锁循环；

1.3 如何避免死锁

我们刚才说的构成死锁的四种情况中，互斥和不可剥夺是锁的基本特性，我们是改变不了的，我们只能去改变（请求保持和循环等待）；

a）打破请求和保持

请求和保持大概率是发生在嵌套中的，我们可以用并列来代替嵌套，但是通用性较低；

我们就拿刚才的吃饺子来举例子把；

public class Demo1 {
    public static void main(String[] args) {
        Object locker1 = new Object();//酱油
        Object locker2 = new Object();//醋
        Thread t1 = new Thread(()->{
            synchronized (locker1){
                System.out.println("小明拿到酱油");
            }

            try {
                Thread.sleep(1111);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            synchronized (locker2){
                System.out.println("小明拿到醋");
            }
        },"小明");

        Thread t2 = new Thread(()->{
            synchronized (locker1){
                System.out.println("小亮拿到酱油");
            }

            try {
                Thread.sleep(1111);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            synchronized (locker2){
                System.out.println("小亮拿到醋");
            }
        },"小亮");

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

    }
}

并列锁，虽然没有构成死锁，但是违背了我们的想法就是让小明和小亮获得两个锁，刚才说的通用性不强也是在这里；

b）打破循环等待

第二个方法，改变加锁的顺序，我们还有吃饺子的例子，但是这次要拿到两个锁：

public class Demo2 {
    public static void main(String[] args) {
        Object locker1 = new Object();//酱油
        Object locker2 = new Object();//醋
        Thread t1 = new Thread(()->{
            synchronized (locker1){
                System.out.println("小明拿到酱油啦");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (locker2){
                    System.out.println("小明拿到醋和酱油啦");
                }
            }
        },"小明");

        Thread t2 = new Thread(()->{
            synchronized (locker1){
                System.out.println("小亮拿到酱油啦");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (locker2){
                    System.out.println("小亮拿到醋和酱油啦");
                }
            }
        },"小亮");

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

我们改变了加锁的顺序，

也是能避免死锁问题的；

———————————————————————————————————————————

2，内存可见性

这也是导致线程安全的问题之一

我们来写一个例子嗷：

import java.util.Scanner;

public class Demo3 {
    static int i = 0;
    public static void main(String[] args) {
        Object obj = new Object();


        Thread t1 = new Thread(()->{
            while(i==0){

            }
            System.out.println("结束");
        });

        Thread t2 = new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            Scanner scanner = new Scanner(System.in);
            synchronized (obj){
                i = scanner.nextInt();
            }
        });
        t1.start();
        t2.start();
    }
}

我们来看这个代码，t1线程根据i的数值一直循环直到i的值被t2线程修改才停止，事实是这样的吗。我们来试试，

无法暂停，这是为啥：

这就是因为内存可见性问题，程序员的水平参差不齐，java大佬为了照顾我们这样的小卡拉米，就弄了个编译器优化，所以我们写的代码并不会直接执行，我们刚才写的while(i==0)这段代码，我们要等待t2线程来修改i，可能我们就用了几秒的时间但对于t1线程，这这边是沧海桑田，万物轮回，谁还记得什么t1呀它等于0就得了，再底层一点解释呢，就是有“工作内存” 和 “主内存”我们应该是从主内存中拿到数据，放到工作内存中，再从工作内存放回主内存，但是这么一直一直重复，去主内存的时间开销是工作内存的几千倍，编译器就不去主内存了直接去工作内存中拿数据，但是后期修改了主内存，然而此处代码已经完全忽略主内存了，就无法修改了；这就是内存可见性问题那么怎么避免呢？

———————————————————————————————————————————

3，volatile 关键字

我们可以使用volatile关键字避免内存可见性问题；

3.1 volatile 能保证内存可见性

import java.util.Scanner;

public class Demo3 {
    volatile static int i = 0;
    public static void main(String[] args) {

        Object obj = new Object();


        Thread t1 = new Thread(()->{
            while(i==0){

            }
            System.out.println("结束");
        });

        Thread t2 = new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            Scanner scanner = new Scanner(System.in);
            synchronized (obj){
                i = scanner.nextInt();
            }
        });
        t1.start();
        t2.start();
    }
}

看，解决了吧，就加了一个volatile；

3.2 volatile 不能保证原子性

还记得原子性吗，就是这个操作在底层是不是原子的，是不是分几步，再多线程中会影响到这个操作，我们拿之前那个两个线程修改一个整形：

public class Demo4 {
    volatile static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for(int i=0;i<100000;i++){
                count++;
            }
        });
        Thread t2 = new Thread(()->{
            for(int i=0;i<100000;i++){
                count++;
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Final count: " + count);
    }
}

所有我们只有使用锁才行；

———————————————————————————————————————————

4，wait 和 notify

这是个什么玩意，线程不是随机调度，抢占式执行的吗，我们可以用这个玩意稍加限制，协调线程之间的逻辑顺序；

4.1 wait() 方法

这个东西跟锁和sleep不一样，都是等待，但是是有区别的，wait(）是等的时候会释放锁，被唤醒再拿到锁而sleep这个byd它抱着锁睡，............锁的话就是阻塞等待嘛，

我们来试试wait（）方法是搭配锁来使用的，最好还要加while循环

public class Demo5 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            System.out.println("Thread 1");
            synchronized (locker){
                System.out.println(1000);
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(2000);
            }
        });

        t1.start();
    }
}

我们来看看运行结果

死等，因为没有东西能够唤醒wait（）；

我们可以设置超时时间，也可以使用notify方法；

public class Demo5 {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            System.out.println("Thread 1");
            synchronized (locker){
                System.out.println(1000);
                try {
                    locker.wait(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(3000);
            }
        });

        t1.start();
    }
}

这样代码会在2秒后打印3000；

4.2 notify() 方法

用来唤醒wait（）注意这些都是搭配锁对象来用的；

对于notify，如果存在多个使用同一个锁对象的wait，它没有规律，会随机唤醒一个wait

public class Demo6 {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();

        Thread t1 = new Thread(()->{
            System.out.println("Thread 1");
            synchronized (locker){
                System.out.println("线程1获得锁");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程1释放锁");
            }
        });
        Thread t2 = new Thread(()->{
            System.out.println("Thread 2");
            synchronized (locker){
                System.out.println("线程2获得锁");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程2释放锁");
            }
        });

        t1.start();
        t2.start();
        Thread.sleep(1000);
        synchronized (locker){
            locker.notify();
        }

    }
}

线程1成功释放了锁，说明notify唤醒了线程1的waite

我们再试试

4.3 notifyAll() 方法

这个就是全部释放

public class Demo7 {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();

        Thread t1 = new Thread(()->{
            System.out.println("Thread 1");
            synchronized (locker){
                System.out.println("线程1获得锁");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程1释放锁");
            }
        });
        Thread t2 = new Thread(()->{
            System.out.println("Thread 2");
            synchronized (locker){
                System.out.println("线程2获得锁");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程2释放锁");
            }
        });

        t1.start();
        t2.start();
        Thread.sleep(1000);
        synchronized (locker){
            locker.notifyAll();
        }

    }
}