多线程(基础知识)_多线程 csdn-优快云博客

public class Test {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        MyThread myThread2=new MyThread();
        myThread.setName("线程1 ");
        myThread2.setName("线程2 ");
        myThread.start();
        myThread2.start();
    }
}




public class MyThread extends Thread{
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+ "hello word"+" "+i);
        }
    }
}

把上面代码复制到开发环境,会发现会交替执行输出hello word.

2.实现Runnable接口的方式实现

过程如下
1.自己创建一个类实现Runnable接口
2.重写run()方法
3.创建测试类,实例化自己实现的类
4.创建Thread对象,并将自己实例化的对象传入
5.启动线程
代码实现如下

public class Test {
    public static void main(String[] args) {
        MyRunnable myRunnable=new MyRunnable();
        Thread thread=new Thread(myRunnable);
        Thread thread2=new Thread(myRunnable);
        thread.setName("线程1");
        thread2.setName("线程2");
        thread.start();
        thread2.start();
    }
}


public class MyRunnable implements Runnable{
    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+ "hello word"+" "+i);
        }
    }
}

3.利用Callable接口和Ftuture接口实现

过程如下
1.创建一个MyCallable类,实现Callable接口
2.重写call()方法(是有返回值的,表示多线程的运行结果
3.创建MyCallable对象(表示多线程要执行的任务)
4.船舰Future对象,Future是一个接口,其实是实现FutureTask类(作用:管理多线程的运行结果)
5.创建Thread类的对象,并启动
代码如下

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable =new MyCallable();
        //这里注意如果用Future作为类型要强转,这是因为Thread类实现了Runnable接
        //Future<Integer> future=new FutureTask<>(myCallable);
        //Thread thread=new Thread((Runnable) future);
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
        Thread thread=new Thread(futureTask);
        thread.start();
        int get=futureTask.get();
        System.out.println(get);
    }
}


import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    int sum=0;
    @Override
    public Integer call() throws Exception {
        for (int i = 0; i < 100; i++) {
            sum+=i;
        }
        return sum;
    }
}

上面就是实现多线程的三种方式

多线程三种实现方式的比较

	优点	缺点
继承Thread类	代码简单,可以直接使用 Thread类中的方法	可扩展性差, 不能再继承其他的类
实现Runnable接口	扩展性强,实现接口的同时还可以继承类	代码比较复杂,不能直接使用Thread中的类
实现Callable接口	扩展性强,实现接口的同时还可以继承类	代码比较复杂,不能直接使用Thread中的类

Thread中常见的成员方法

方法名称	说明
String getName()	返回此线程的名称
void setName()	设置线程名称(构造方法也可以设置名字)
static Thread currentThread()	获取当前线程的对象
static void sleep(long time)	让线程休眠指定的时间,单位为毫秒
setPriority(int newPriority)	设置线程的优先级
final int getPriority()	获取线程的优先级
final void setDaemon(boolean on)	设置为守护线程
public static void yield	出让线程/礼让线程
public static void join	插入线程/插队线程

下面对每个方法进行介绍,第一个和第二个方法,在前面代码中已经用过了,比较简单就不介绍了,补充一下,当我们不给线程设置名字的时候,它有一个默认的名字,格式是 : Thread-x(x是序号从0开始),利用构造方法设置线程名字,要用到super关键字,因为构造方法是不能继承的,要是有父类的构造就要再写一个构造方法,并用super关键字

currentThread() 方法

该方法是获得当前线程的对象,这个方法我们上面也用到了,就是获得线程名字的时候用的,它获得了,线程的对象就可以调用该对象的方法.如果们在main方法中使用,结果就是打印main,当Java虚拟机启动之后,会自动的启动多条线程,其中一条就叫做main线程,它的作用就是调用main方法.

sleep()方法

哪条线程执行到这个方法,那么哪条线程就会在这个地方停留.停留时间自己设置,单位是毫秒,当时间到了之后,线程会自动醒来,自动执行下面的代码.

setPriority()和getPrioritry()方法

这个方法就是设置线程的优先级,在学习之前我们先学习一下线程的调度
抢占式调度(随机):就是多个线程在抢夺cup的执行权,cpu在选择执行哪条线程是不确定的,执行多长时间也是不确定的.
非抢占式调度:就是你一次我一次这样的调度
在Java中采用的式抢占式调度

我们利用setPriority()方法设置优先级,优先级越大,被执行的概率就越大,默认是5,最大是10,当我们把优先级设置为10的时候,并不意味着100%执行,只是执行的概率变大了.main方法默认也是5.
使用方式也很简单就是用创建好的线程对象去调用这个两个方法,就不演示了,非常简单.

setDaemon()方法

守护线程,表面意思就是让一个线程去守护某一个线程,当一个线程执行完之后,守护线程也会陆续执行完毕,注意这里不是立马就停止,而是陆续停止.还是创建两个线程对象,让其中一个线程调用这个方法,设置为守护线程,另一个不设置,我们可以看到当那个不是守护线程的线程执行完之后,守护线程也会陆续停止,即使守护线程的逻辑还没执行完也会陆续停止.这就是守护线程,也就是当非守护线程执行完了,守护线程也就没有存在的必要了.
守护线程的应用场景就好比我们用聊天软件聊天,你向一个人发送文件,在发送的途中你关闭了聊天,发送就会停止.

yield()方法

让出先线程,意思就是把线程让出去,如果要执行下面的代码,则需要重新抢夺cpu.

join()方法

就是强线程的执行权.

线程的生命周期

看下面这个图

线程的安全问题

一般线程安全

以买票问题为例子,有100张票,用三个窗口进行出售,我们就可以把三个窗口看成三个线程.看下面这段代码,我们以第二种方式来创建多线程.来看下面这段代码

public class Test {
    public static void main(String[] args) {
        Lottery lottery=new Lottery();
        Thread thread1=new Thread(lottery);
        Thread thread2=new Thread(lottery);
        Thread thread3=new Thread(lottery);
        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");
        thread1.start();
        thread2.start();
        thread3.start();
    }


public class Lottery implements  Runnable{
    int ticket=0;
    @Override
    public void run() {
        while(true){
            if(ticket<100){
                try {
                    Thread.sleep(100);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ticket++;
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
            }else{
                break;
            }
        }
    }
}

执行结果如下

我们就发现不对劲,三个窗口同时在卖1张票,这不是我想要的结果.怎么解决这个问题呢,下面就来介绍一下

解决线程安全问题在Java中就是用锁,在Java中,实现锁这个功能,要用到synchronized 这个关键字,上面这个例子有点麻烦,我们举一个简单的例子,创建两个线程,然后写两个循环,创建一个变量,两个变量在这两个循环中都自增加加.代码如下

 private static int count=0;
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        });
        Thread thread1=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                count++;
            }
        });
        thread1.start();
        thread.start();
        thread.join();
        thread1.join();
        System.out.println(count);
    }

我们知道,这段代码按我们没接触多线程之前,觉得count的结果为10000,但是当我们运行程序会发现并不是我们想的那样.那这事为什那么呢,我们知道当一个变量要被修改时,首先要从内存中读取到寄存器,把这个过程我简称为(load),之后进行累加(add),最后一个步骤写入到内存中(save).

那么就能意识到问题了,当一个线程刚加了一次,并且写到了内存里面,但是另一个线程是之前就拿到了,也加加了,但是这个线程没有另一个线程执行的次数多,就导致,执行快的线程,刚累加完,慢线程,把一个小的值又给覆盖了.这就导致了程序出现了bug.那么解决方案就是加锁.代码如下

 private static int count=0;
    private static Object  object=new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized(object){
                    count++;
                }

            }
        });
        Thread thread1=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized(object){
                    count++;
                }
            }
        });
        thread1.start();
        thread.start();
        thread.join();
        thread1.join();
        System.out.println(count);
    }

其实上面就改了一点点代码执行结果就正确了,由此可见,在多线程中加锁的重要性.那么,分析一下,程序为什么执行正确,看上面代码,我们给count++加了一层锁,两个线程,当有一个线程执行到count++时,另一个线程就不会执行这个操作,当这个操作执行完之后,锁打开了,那么另一个线程才会去执行,也就是当一个线程执行完一套完整的操作后,另外一个线程才会去执行一整套操作.

还有就是要注意,加的锁对象可以是任意的对象,但是必须是同一个对象,如果对象不相同,那么这个锁就相当于没加.还有就是可以是类对象,就是我们每写一个Java文件就是一个类对象,JVM,会将Java文件编译成以 .class为后缀的文件,就直接在这个Java文件加上 .class就可以,它就是一个类对象.

当一个类去点class时,这其实也是Java的一种反射操作,通过反射操作,我们可以拿到这类的所有东西,包括被private修饰的变量或者方法.

此处的synchronized是JVM提供的功能,而JVM是C++实现的.进一步也是通过操作系统api来实现的加锁功能,而系统api又是cup特殊的指令来实现的.

还有就是synchronized能是自己能加锁开锁的,像其他语言也有这种功能.

synchronized修饰方法
看下面的代码

class Func{
    public int count;
    synchronized public void add(){
        count++;
    }
}
public class demon1 {
    public static void main(String[] args) throws InterruptedException {
        Func func=new Func();
        Thread thread=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                func.add();
            }
        });
        Thread thread1=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                func.add();
            }
        });
        thread.start();
        thread1.start();
        thread1.join();
        thread.join();
        System.out.println(func.count);

    }
}

上面在方法前面加synchronized,和之前代码执行结果相同,哪个对象调用这个add方法就要将这个过程执行完,开锁后其他对象才能调用.当然还有另外一种简写的方式代码如下:



class Func1{
    public int count;
    public void add(){
        synchronized(this){
            count++;
        }
        count++;
    }
}
public class demon2 {
    public static void main(String[] args) throws InterruptedException {
        Func func=new Func();
        Thread thread=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                func.add();
            }
        });
        Thread thread1=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                func.add();
            }
        });
        thread.start();
        thread1.start();
        thread1.join();
        thread.join();
        System.out.println(func.count);

    }
}

这种方法就是在synchronized后面加this关键字,我们知道this关键字表示当前对象的引用.哪个对象调用这个方法都会对该方法上锁,其他对象调用不了.当然这种方法也有不是所有的场景都适用,看下面的代码



class Func3{
    public int count;
    public static void add(){
        synchronized(Func3.class){
        }

    }
}
public class demon3 {
    public static void main(String[] args) throws InterruptedException {
        Func func=new Func();
        Thread thread=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                func.add();
            }
        });
        Thread thread1=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                func.add();
            }
        });
        thread.start();
        thread1.start();
        thread1.join();
        thread.join();
        System.out.println(func.count);

    }
}

如果一个方法是一个静态方法,那么它没有实例,也就用不了this这个关键字.当然如果我们实在想用一个对象,那么可以直接随便new一个对象,但是要加static.

上面是面对线程安全问题的基础解决方案,但是我们在平时写代码的时候可能,会出现一种情况----------死锁.下面我们来看死锁问题.

死锁

所谓的死锁就是针对一把锁连续加锁两次.当你在外层加一层锁之后,在里面又加了一个锁,按道理来说,程序会陷入阻塞.看下面代码


class Func1{
    public int count;
    public void add(){
        synchronized(this){
            count++;
        }
        count++;
    }
}
public class demon2 {
    public static void main(String[] args) throws InterruptedException {
        Func func=new Func();
        Thread thread=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized (func){
                    func.add();
                }

            }
        });
        Thread thread1=new Thread(()->{
            for (int i = 0; i < 5000; i++) {
                synchronized (func){
                    func.add();
                }
            }
        });
        thread.start();
        thread1.start();
        thread1.join();
        thread.join();
        System.out.println(func.count);

    }
}

上面代码加了两层锁,在我们分析看来,一定会陷入阻塞,但是实际上执行结果任然是10000,程序并没有出现bug,原因就是JVM对synchronized关键字做了优化,让其不会出现死锁现象,如果是C++或者Python就会出现死锁,Java为了减少程序员写出死锁的概率,引入了特殊机制,解决上述死锁问题,这种机制又叫可重入锁.

死锁是一个大的话题设计的东西非常多下面我会一一介绍,包括怎么处理死锁现象.

那么再说一下为什么会产生线程安全问题
1.操作系统对线程的调度是随机的(抢占式执行)
2.多个线程对同时对一个变量进行修改
3.修改操作不是原子的(所谓的原子性:是指一个操作或者一组操作要么完全执行,要么不执行,不被其他线程中断(原子操作不会看到执行的中间状态).
4.内存可见性
5.指令重排序
第四点和第五点后面会说

好那么下面来说可重入锁,可重入锁会判断当前锁所加的所是不是当前线程,如果是就不会进行任何加锁,也不会有任何的阻塞,而是直接放行.
好,那么当面对锁的多重嵌套,第一层锁是加锁,那么在什么时候释放锁呢,当然是最后一层,如果中间有其他代码,那就又有线程安全问题了,那么JVM是怎么来判断在最后一个大括号呢,其实是有一个程序计数器,比方说count,初始时让count等于0,然后遇见右括号,就加 1 ,遇见左括号就减 1,当count=0时,就可以判断出这是最后一个括号了,这时候,就要释放锁了.

那么有没有synchronized无法结局的死锁呢,当然有,就比如:

线程1现针对A加锁,线程2针对B加锁,线程1在不释放锁A的情况下,再针对B加锁.线程2在不释放B的情况下,再针对A加锁.看下面代码

public class demon4 {
    private static Object locker1=new Object();
    private static Object locker2=new Object();
    public static void main(String[] args) {
        Thread thread1=new Thread(()->{
           synchronized(locker1){
               System.out.println("t1加锁,locker1完成");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               synchronized(locker2){
                   System.out.println("t1加锁 locker2完成");
               }
           }


        });
        Thread thread=new Thread(()->{
           synchronized (locker2){
               System.out.println("t2 加锁locker2完成");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               synchronized (locker1){
                   System.out.println("t1加锁 locker1完成");
               }
           }


        });
        thread.start();
        thread1.start();

    }
}

运行结果:

我们发现线程停在这里不动了,就形成死锁.

解决方案也很简单,就是在给A加锁加锁之后释放锁,然后再给B加锁.也就是下面这段代码

package thread_learn2;

public class demon5 {
    private static Object locker1=new Object();
    private static Object locker2=new Object();
    public static void main(String[] args) {
        Thread thread1=new Thread(()->{
            synchronized(locker1){
                System.out.println("t1加锁,locker1完成");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
               
            }
            synchronized(locker2){
                System.out.println("t1加锁 locker2完成");
            }


        });
        Thread thread=new Thread(()->{
            synchronized (locker2){
                System.out.println("t2 加锁locker2完成");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
               
            }
            synchronized (locker1){
                System.out.println("t1加锁 locker1完成");
            }


        });
        thread.start();
        thread1.start();

    }
}

这时一种解决死锁的一种方法.

还有一种方法,就是破除循环等待,啥意思呢,就比如一个程序员要修关于进出公司的bug,然后保安不让他进,必须要出示码,但是程序员不去修bug怎么出示码呢,把这种情况出现到代码上,也就构成了死锁.

那么解决上面问题也很简单,就是给每一个锁编号,然后约定每个线程都按一定顺序来进行加锁,看下面代码

package thread_learn2;



public class demon6 {
    private static Object locker1=new Object();
    private static Object locker2=new Object();
    public static void main(String[] args) {
        Thread thread1=new Thread(()->{
            synchronized(locker1){
                System.out.println("t1加锁,locker1完成");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized(locker2){
                    System.out.println("t1加锁 locker2完成");
                }


            }


        });
        Thread thread=new Thread(()->{
            synchronized (locker1){
                System.out.println("t2 加锁locker1完成");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker2){
                    System.out.println("t1加锁 locker2完成");
                }

            }



        });
        thread.start();
        thread1.start();

    }
}

我们会发现,除了我们不可逆转的情况出现的死锁,其他就是代码结构了,代码结构涉及的问题就是我上述说的两个问题,
1.请求和保持(这个就是线程1在不释放锁A的情况下去拿锁B,线程2不能把锁B强过来(解决方法就是等锁A释放后再拿锁B).
2.循环等待(就是那个程序员进公司的问题)解决方案就是把锁编号,约定顺序加锁.其实这个解决方案就是看哪个线程先start,先start的这个线程会优先被执行完.但是注意上述代码都是建立在sleep的基础上.如果没有sleep代码可能会死锁,也可能不死锁,因为线程是抢占式执行,谁先抢到谁先执行,结果是未知的.

还有就是死锁的两个基本特征,一个是互斥性和不可抢占.

互斥确保了同一时刻只有一个线程可以访问共享资源，从而避免数据竞争。
不可抢占确保了持有锁的线程可以安全地完成其操作，而不会被其他线程中断或抢占。

volatile 关键字

volatile关键字是用来解决内存可见性的问题,我们在多线程中除了死锁问题,还有就是内存可见性的问题,这不是程序员逻辑问题导致出错的,而是JVM的问题,所以Java提供volatile关键字来解决问题,先看有问题的代码

package thread_learn2;

import java.util.Scanner;

public class demon7 {
    private static int n=0;
    public static void main(String[] args) {

        Thread thread=new Thread(()->{
           while(n==0){

           }
        });
        Thread thread1=new Thread(()->{
            Scanner scanner=new Scanner(System.in);
            System.out.println("请输入一个整数:");
            n=scanner.nextInt();
        });
        thread.start();
        thread1.start();
    }
}

执行结果如下:

发现程序并没有终止,这就是内存可见性的问题.那么为什么会有这种问题呢.原因如下:

线程thread一直在循环并没有打印,,首先要进行条件判断,就是n是否等于0.要进行判断,就要先把数据从内存读到寄存器中,然后在寄存器中比较.然而这两个过程速度差距非常大,相差几个数量级,也就是说在线程thread1中对n的更改,要经过这两个步骤,但是在JVM看来,几万次比较后的结果都是0,并且过程一相对于过程二开销比较大,所以JVM直接将过程一直接优化掉了,也就导致,就算我们去更改n的值程序也不能停下来.
关于JVM优化这件事,其实就是提高代码的执行效率,因为每个程序员写的代码不一样,有的运行速度慢,但是当JVM优化后,运行速度就差不多了.

还有就是JVM优化在单线程中是非常准确的不会出现内存可见性问题.但是多线程会出现.

还有就是JVM这里的优化和之前C语言Debug版本的Release版本不同,Dubge版本编译的时候,将中间的符号表也编译到exe文件中了,Release版本没有.而C语言的优化是要靠指令来完成,
-O0是不优化
-O3是优化最高级.

然后就是解决上面的问题,我们可以直接sleep,让线程thread休眠一下,这时候n就能改变值,但是这个方法很不好,程序运行速率会下降很多,所以就用上面说的关键字volatile关键字,.看下面代码

package thread_learn2;

import java.util.Scanner;

public class demon7 {
    private volatile static int n=0;
    public static void main(String[] args) {

        Thread thread=new Thread(()->{
           while(n==0){

           }
        });
        Thread thread1=new Thread(()->{
            Scanner scanner=new Scanner(System.in);
            System.out.println("请输入一个整数:");
            n=scanner.nextInt();
        });
        thread.start();
        thread1.start();
    }
}

看运行结果,程序是没有错的.这也是volatile关键字的用法.

还有就是什么时候要加volatile这个关键字们就是在一个变量被一个线程读,一个线程写中情况.

下面我们还来谈内存可见性,按网上资料的说法,引入了两个概念
(1)工作内存
(2)主内存

整个Java程序都持有主内存,每个Java线程都会有一份工作内存.
就拿上面的代码来举例,变量n就在主内存中,当两个线程执行的时候,会将变量n加载到工作内存中,线程thread1修改了n,就会将n再写道主内存中.线程thread会将n从主内存读取到工作内存中,然后依照工作内存中n的值来进行判定的,而此时线程thread1修改了主内存n的值,但是,还是依据线程thread中的工作内存来进行判定的.也就出现了内存可见性问题.
我们此时类比一下,这里的主内存不就是内存吗,工作内存不就是cpu寄存器和cache吗,这其实就是换了个说法.站的角度不同.

好了关于内存可见性问题就说到这里,最后一点,volatile不能解决原子性问题,只能解决内存可见性问题.

wait和notify

上面其实已经提到了wait和notify这个方法,这里我们仔细来讨论一下.
wait是等待,notify是通知,上面我们说是唤醒,还是通知比较合适.
我们拿一个例子,来说一下这两个方法怎么用.
去ATM取钱,一群人去ATM取钱,第一个人进去之后,发现ATM没钱了,他前脚刚出去,门还没关上,要不我再去看看吧,重复这个过程.其他的人也进不去,这种现象叫做 "线程饿死".解决方案也很简单,就是让这个人去等待,等通知有钱了,再去通知他,让他去取钱,其他人也可以进ATM机,这就解决了.
所谓线程饿死这种现象,是概率问题,和调度器的策略相关.就好比上面的例子,程序不会一直重复这个过程,但是重复个几百次还是有的.
值得注意的是wait和notify是Object提供的方法,任意的object对象都可以用来wait,notify

好那么我们先简单使用一下wait这个方法看下面代码

package thread_learn2;

public class demon8 {
    public static void main(String[] args) throws InterruptedException {
        Object object=new Object();
        System.out.println("wait 之前");
        object.wait();
        System.out.println("wait 之后");
    }
}

运行结果如下

报错了,这是为什么呢
IllegalMonitorStateException Illegal是非法的意思,Monitor是监视器的意思,但是这里的意思是锁的意思,是synchronized这个锁.State是状态的意思,Exception是异常的意思.连起来就是非法的锁状态.
这里object没有进行加锁.总的来说,wait会进行一个操作,就是进行解锁.所以使用wait要放在synchronized代码块里面.所以要先加锁,才能用wait这个方法.

只要改一下代码就行了,看下面代码

package thread_learn2;

public class demon8 {
    public static void main(String[] args) throws InterruptedException {
        Object object=new Object();
        System.out.println("wait 之前");
        synchronized (object){
            object.wait();
        }
        
        System.out.println("wait 之后");
    }
}

上述代码就是正确的代码.

还有wait这个方法,就是解锁和等待是同时的(打包成原子的).为什么要是打包成原子的呢,如果不是同时的可能会发生线程切换.这就可能导致线程不能及时被唤醒.

这里总结一下wait主要做的三件事:
(1)释放锁
(2)进入阻塞状态,准备接受通知
(3)接受到通知后,唤醒,并尝试获取锁.

还有就是,必须是同一个锁对象,才能被唤醒

notify也是这样,必须是同一个锁对象才能进行通知,同时notify也要确保先加锁,才能执行.

wait默认是死等,也是有参数的,这就和sleep就很相似.当wait等待时间到了,就不再进行等待,会尝试去获取锁,获取锁之后会执行下面的代码,出了synchronized代码块之后释放锁.
我们做一个练习,利用多线程来顺序打印ABC.代码如下:

package thread_learn2;

public class demon9 {
    static Object  object1=new Object();
   static Object object2=new Object();
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            System.out.println("A");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (object1){
                object1.notify();
            }
        });
        Thread thread1=new Thread(()->{
            synchronized (object1){
                try {
                    object1.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("B");
            synchronized (object2){
                object2.notify();
            }


        });
        Thread thread2 =new Thread(()->{
            synchronized (object2){
                try {
                    object2.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("C");
        });
        thread.start();
        thread1.start();
        thread2.start();
    }
}