Java SE :”深挖 “多线程

编译软件:IntelliJ IDEA 2019.2.4 x64
运行环境:win10 家庭中文版
jdk版本:1.8.0_361



提示:以下是本篇文章正文内容,下面案例可供参考

一、进程与线程的相关概念

1.1 程序

它是选择一种编程语言,完成一个功能/任务,而编写的一段代码,这段代码最后被编译/解释为指令程序是一组指令的集合

程序是静态的。当我们电脑、手机安装了一个程序之后,只是占用硬盘/存储卡的空间。

1.2 进程

①一个程序的一次运行

按快捷键 CTRL+SHIFT+ESC ,调出任务管理器,如下所示:

在这里插入图片描述

当程序启动后,操作系统部会给这个程序分配一个进程的ID, 并且会给他分配一块独立的内存空间。

②如果一个程序被启动了多次,那么会有多个进程。

如下所示:

在这里插入图片描述

多个进程之问是无法共享数据。

如果两段代码需要进行数据的交互,成本比较高,要么遇过一个硬盘的文件,要么通过网络。

进程之间的切换成术也比较高。现在的操作系统都支持多任务,嫌作系统在每一个任务之同进行切换,要给整个进程做镜像,要记录当前进程的状态,执行到哪个指令的.

1.3 线程

进程中的其中一条执行路径。

多个线程会同属于一个进程。
这多个线程会共享同一个进程中的一些资源。

比如Java中堆内存的数据,方法区的数据。

如下所示:

在这里插入图片描述

如果同一个进程的两段代码需要进行数据的交互,非常方便,可以直接在内存中共享。当然,同时要考虑安全问题。进程之间的切换,需要记录的信息要少很多,因为很多线程之间的数据是共享的,这些数据就不用单独在做镜像了,只需要记录每一个线程要执行的下一条指令。


二、并发与并行

  • 并行(parallel):指两个或多个事件在同一时刻发生(同时发生)。指在同一时刻,有多条指令在多个处理器上同时执行。
  • 并发(concurrency):指两个或多个事件在同一个时间段内发生。指在同一个时刻只能有一条指令执行,但多个进程的指令被快速轮换执行,使得在宏观上具有多个进程同时执行的效果。

如下图所示:
在这里插入图片描述
在操作系统中,启动了多个程序,并发指的是在一段时间内宏观上有多个程序同时运行,这在单 CPU 系统中,每一时刻只能有一个程序执行,即微观上这些程序是分时的交替运行,只不过是给人的感觉是同时运行,那是因为分时交替运行的时间是非常短的。

而在多个 CPU 系统中,则这些可以并发执行的程序便可以分配到多个处理器上(CPU),实现多任务并行执行,即利用每个处理器来处理一个可以并发执行的程序,这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU,便是多核处理器,核越多,并行处理的程序越多,能大大的提高电脑运行的效率。

例子:

  • 并行:多项工作一起执行,之后再汇总,例如:泡方便面,电水壶烧水,一边撕调料倒入桶中
  • 并发:同一时刻多个线程在访问同一个资源,多个线程对一个点,例如:春运抢票、电商秒杀…

三、线程调度

有两种调度模型:分时调度模型和抢占式调度模型。

  • 分时调度模型

    所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间。

  • 抢占式调度模型

    优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性),Java使用的为抢占式调度。

    • 抢占式调度详解

      大部分操作系统都支持多进程并发运行,现在的操作系统几乎都支持同时运行多个程序。比如:现在我们上课一边使用编辑器,一边使用录屏软件,同时还开着画图板,dos窗口等软件。此时,这些程序是在同时运行,”感觉这些软件好像在同一时刻运行着“。

      实际上,CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言,某个时刻,只能执行一个线程,而 CPU的在多个线程间切换速度相对我们的感觉要快,看上去就是在同一时刻运行。
      其实,多线程程序并不能提高程序的运行速度,但能够提高程序运行效率,让CPU的使用率更高

java虚拟机采用抢占式调度模型,是指优先让可运行池中优先级高的线程占用CPU,如果可运行池中的线程优先级相同,那么就随机选择一个线程,斜体样式使其占用CPU。处于运行状态的线程会一直运行,直至它不得不放弃CPU。


四 、线程的创建与使用

4.1 线程的创建

java中开启一个线程的方共有四种:
1.继承Thread类
2.实现Runnable接口
3.实现Callable接口
4. 线程池

ps:本文今天暂且只介绍前两种,后两种在后期再行探讨。

4.1.1 继承Thread类

Java使用java.lang.Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务,实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建启动多线程的步骤如下:

(1) 编与一个类,让它继承Thread类

(2)重写父类的public void run()}这个run()方法不是由程序员调用的,而且线程调度时,自动调用。要让一个线程做什么事,必须把这个代码写到run 中把run()方法的方法体,称为线程体。

(3) 创建自定义线程类的对象

(4)启动线程,调用自定义线程类的对象的start()

代码演示如下:

public class TestMyThread {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();//启动线程

        for (int i = 1; i <=10 ; i+=2) {
            System.out.println("main线程打印【1-10】之间的奇数:"+i);
        }
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 1; i <=10 ; i++) {
            if (i%2==0){
                System.out.println("自定义线程打印【1-10】之间的偶数:"+i);
            }
        }
    }
}

在这里插入图片描述

4.1.2 实现Runnable接口

Java有单继承的限制,当我们无法继承Thread类时,那么该如何做呢?在核心类库中提供了Runnable接口,我们可以实现Runnable接口,重写run()方法,然后再通过Thread类的对象代理启动和执行我们的线程体run()方法

步骤如下:

(1)编写线程类,实现Runnable接口

(2)重写接口的抽象方法public void run()

(3) 创建自定义线程类的对象

(4)创建一个Thread类的对象,同时让Thread对象代理我们的自定义线程对象创建它的目的是为了调用start方法

(5)启动线程

线程调度器会调用t对象的run方法,因为这里启动的是t线程 ,(t.start())

	Thread类的run()
	@Override
	public void run() {
	 	if(target != null) 
	 	{
	 		(target.run();
	 	}
	 }

这里的target对象就是创建Thread类对象时传入的Runnable接口的实现类对象,即被代理对象。

代码演示如下:

public class test {
    public static void main(String[] args) {
        TestRunnable tr=new TestRunnable();
        Thread thread=new Thread(tr);
        thread.start();  //启动线程

    }
}

class TestRunnable implements Runnable{
    @Override
    //线程体
    public void run() {
        for (int i = 1; i <=10 ; i++) {
            if (i%2==0){
                System.out.println("自定义线程打印【1-10】之间的偶数:"+i);
            }
        }
    }
}

在这里插入图片描述

通过实现Runnable接口,使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候,需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象,然后调用Thread对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此,不管是继承Thread类还是实现,Runnable接口来实现多线程,最终还是通过Thread的对象的API来控制线程的,熟悉Thread类的API是进行多线程编程的基础。

💡tips:

Runnable对象仅仅作为Thread对象的target,Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例,只是该Thread线程负责执行其target的run()方法。

4.3 使用匿名内部类对象来实现线程的创建和启动

①使用匿名内部类对象继承Thread类

代码演示如下:

		new Thread(){
            @Override
            public void run() {
                //依次打印1-10
                System.out.println("使用匿名内部类创建Thread对象打印1-10:");
                for (int i = 1; i <=10 ; i++) {
                    System.out.print(i+"\t");
                }
            }
        }.start();

在这里插入图片描述

②使用匿名内部类对象实现Runnable接口

代码演示如下:

		new Thread(new Runnable(){
            @Override
            public void run() {
                //依次打印1-10
                System.out.println("使用匿名内部类实现Runnable接口创建的线程打印1-10:");
                for (int i = 1; i <=10 ; i++) {
                    System.out.print(i+"\t");
                }
            }
        }).start();

在这里插入图片描述

4.2 线程的使用

4.2.1 Thread类

4.2.1.1 构造方法
  • public Thread() :分配一个新的线程对象。
  • public Thread(string name) :分配一个指定名字的新的线程对象。
  • public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
  • public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字
4.2.1.2 常用方法①
  • public void run() :此线程要执行的任务在此处定义代码。
  • public String getName() :获取当前线程名称。

如果没有手动指定线程名称,默认是Thread-编号,从0开始。 如果需要手动指定线程名称,可以通过构造器,或者setName(String name)方法设置线程名称。

  • public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
  • public final boolean isAlive()测试线程是否处于活动状态。如果线程已经启动且尚未终止,则为活动状态。
  • public final int getPriority()返回线程优先级
  • public final void setPriority(int newPriority)改变线程的优先级
    • 每个线程都有一定的优先级,优先级高的线程将获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。Thread类提供了setPriority(int newPriority)和getPriority()方法类设置和获取线程的优先级,其中setPriority方法需要一个整数,并且范围在[1,10]之间,通常推荐设置Thread类的三个优先级常量:
    • MAX_PRIORITY(10):最高优先级
    • MIN _PRIORITY (1):最低优先级
    • NORM_PRIORITY (5):普通优先级,默认情况下main线程具有普通优先级。

案例:声明一个匿名内部类继承Thread类,重写run方法,在run方法中获取线程名称和优先级。设置该线程优先级为最高优先级并启动该线程。

代码演示如下:

 		Thread  t=  new Thread(){
            @Override
            public void run() {
                System.out.println(getName()+"的优先级:"+getPriority());
            }
        };
        t.setPriority(10);
        t.start();

在这里插入图片描述

4.2.1.3 常用方法②
  • public static void sleep(long millis) throws InterruptedException: 线程休眠,单位毫秒
  • public static void yield(): 让当前线程暂停一下当前线程暂停下,让出CPU,但是下一次CPU有可能还是调用它。
  • void join() throws InterruptedException : 等待该线程终止。该线程是调用ioin 方法的线程。

阻塞当前线程的执行,等到被调用join的线程对象执行完毕才执行继续执行当前线程

  • void join(long millis) : 等待该线程终止的时间最长为 millis 毫秒。如果millis时间到,将不再等待。
  • void join(long millis,int nanos) : 等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。

案例:
声明一个PrintEvenThread线程类,继承Thread类,重写run方法,实现打印[1,100]之间的偶数,要求每隔1毫秒打印1个偶数。

声明一个PrintOddThread线程类,继承Thread类,重写run方法,实现打打印[1,100]之间的奇数在main线程中:

(1) 创建两个线程对象,并启动两个线程
(2)当打印奇数的线程结束了,让偶数的线程也停下来,就算偶数线程没有全部打印完[1,100]之间的偶数.

案例演示代码如下:

package test;

//打印1-100之间的偶数
public class PrintEvenThread extends Thread {
    private boolean flag=true;

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        for (int i = 2; i <=100 & flag; i+=2) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("自定义异常打印【1-100】之间的偶数:"+i);
        }
    }
}

//打印1-100之间的奇数
public class PrintOddThread extends Thread {

    @Override
    public void run() {
        for (int i = 1; i <= 100 ; i+=2) {
            System.out.println("自定义异常打印【1-100】之间的奇数:"+i);
        }
    }
}

public class TestPrint {
    public static void main(String[] args) {
        PrintEvenThread p1=new PrintEvenThread();//偶数进程
        PrintOddThread p2=new PrintOddThread();//奇数进程
        p1.start();
        p2.start();

        try {
            p2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        p1.setFlag(false);
    }
}

在这里插入图片描述

4.3 线程的停止

主方法也是一个线程,对于部署在主方法内其他的线程而言,如何让主方法这个线程让其他的线程提前结束呢?

线程的死亡有两种:

自然死亡:当一个线程的run方法执行完,线程自然会停止。
意外死亡:当一个线程遇到未捕获处理的异常,也会挂掉。

我们肯定希望是让线程自然死亡更好。

  • public final void stop():**强迫线程停止执行。 该方法具有固有的不安全性,已经标记为@Deprecated==(已过时、已废弃)==不建议再使用,**那么我们就需要通过其他方式来停止线程了,其中一种方式是使用变量的值的变化来控制线程是否结束。
  • 标记法

案例:
声明一个PrintEvenThread线程类,继承Thread类,重写run方法,实现打印[1,100]之间的偶数,要求每隔1毫秒打印1个偶数。

声明一个PrintOddThread线程类,继承Thread类,重写run方法,实现打打印[1,100]之间的奇数在main线程中:

(1) 创建两个线程对象,并启动两个线程
(2)当打印奇数的线程结束了,让偶数的线程也停下来,就算偶数线程没有全部打印完[1,100]之间的偶数.

代码演示如下:

package test;

//打印1-100之间的偶数
public class PrintEvenThread extends Thread {
    private boolean flag=true;

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        for (int i = 2; i <=100 & flag; i+=2) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("自定义异常打印【1-100】之间的偶数:"+i);
        }
    }
}

//打印1-100之间的奇数
public class PrintOddThread extends Thread {

    @Override
    public void run() {
        for (int i = 1; i <= 100 ; i+=2) {
            System.out.println("自定义异常打印【1-100】之间的奇数:"+i);
        }
    }
}

public class TestPrint {
    public static void main(String[] args) {
        PrintEvenThread p1=new PrintEvenThread();//偶数进程
        PrintOddThread p2=new PrintOddThread();//奇数进程
        p1.start();
        p2.start();

        try {
            p2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        p1.setFlag(false);//此时打印奇数的线程执行完了,就把打印偶数的进程停掉,即便之前它没有执行完
    }
}

在这里插入图片描述


五、线程安全问题

5.2 什么是线程安全问题?

当我们使用多个线程访问同一资源(可以是同一个变量、同一个文件、同一条记录等)的时候,若多个线程只有读操作,那么不会发生线程安全问题,但是如果多个线程中对资源有读和写的操作,就容易出现线程安全问题。

我们通过一个案例,演示线程的安全问题:

电影院要卖票,我们模拟电影院的卖票过程。假设要播放的电影是“葫芦娃大战奥特曼”,本次电影的座位共100个(本场电影只能卖100张票)。
我们来模拟电影院的售票窗口,实现多个窗口同时卖“葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票

代码如下(示例):

public class TestTicket {

    public static void main(String[] args) {
        //创建3个窗口一起卖票
        Ticket t1=new Ticket("窗口一");
        Ticket t2=new Ticket("窗口二");
        Ticket t3=new Ticket("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}


class Ticket extends Thread{
    //先假设需要卖10张票
    private static int tickets=10;

    public Ticket(String name) {
        super(name);
    }

    @Override
    public void run() {
        while (tickets>=1){
            try {
                Thread.sleep(2000);//线程休眠2000ms,即2s
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            tickets--;
            System.out.println(Thread.currentThread().getName()+"卖了1张票,"+"还剩"+tickets+"票");//打印卖票信息以及余票情况
        }
    }
}


在这里插入图片描述

问题分析如下:

在这里插入图片描述

5.2 如何解决线程安全问题?

1、使用同步机制

同步就是给某段代码加“锁”
锁是一个对象,又被称为监视器对象·就是监视使用共享数据的这几个线程的调度执行情况

Java对象分为3个部分:
(1) 对象头 :
A:包含当前对象所属类的指针
B : Mark word : 记录了和当前对象有关的GC、锁标记等信息
c: 数组的长度,数组对象特有的
(2) 对象的实例变量
( 3) 对齐空白

即每一个对象都有一个标记位,标记现在哪个线程“占有”这个锁对象。这个标记为会记录这个线程的ID。只有“占有”锁对象的线程才有机会执行被锁的代码,称为同步代码

2、如何给代码加锁 ? synchronized

(1) 同步方法: 锁整个方法

[修饰符] synchronized 返回值类型 方法名( [形参列表] ) [throws 异常列表]
{
方法体
}

演示代码如下:

①情形:继承Thread类

public class TestTicket {

    public static void main(String[] args) {
        Ticket t1=new Ticket("窗口一");
        Ticket t2=new Ticket("窗口二");
        Ticket t3=new Ticket("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}


class Ticket extends Thread{
    private static int tickets =3;

    public Ticket(String name) {
        super(name);
    };

    @Override
    public void run() {
        while (tickets >= 1){
            sellOneTicket();
        } 
    }

    public static synchronized void sellOneTicket(){
        if (tickets>=1) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            tickets--;
            System.out.println(Thread.currentThread().getName() + "卖了1张票," + "还剩" + tickets + "票");
        }
    }
}*斜体样式*

在这里插入图片描述

②情形:实现Rannable接口

public class RunnableTickets implements Runnable{
    private int tickets=10;

    @Override
    public  void run() {
        while (tickets >= 1){
            sellOneTicket();
        }
    }
    //非静态方法的锁对象是this
    public synchronized void sellOneTicket(){
        if (tickets >= 1) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            tickets--;
            System.out.println(Thread.currentThread().getName() + "卖了1张票," + "还剩" + tickets + "票");
        }
    }
}

public class TestRunnableTickets {
    public static void main(String[] args) {
        RunnableTickets rt=new RunnableTickets();
        Thread t1=new Thread(rt,"窗口一");
        Thread t2=new Thread(rt,"窗口二");
        Thread t3=new Thread(rt,"窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

在这里插入图片描述
注意:

若以上代码中同步方法未加 if 条件判断,则还会出现-1的情况。

不信?请看如下代码:

在这里插入图片描述
在这里插入图片描述
原因分析如下:

在这里插入图片描述

(2) 同步代码块 : 锁方法体里面的一小部分代码

synchronized() {
需要被锁起来的代码
}

代码演示如下:

public class SafeMethod {
    public static void main(String[] args) {
        Tick t1=new Tick("窗口一");
        Tick t2=new Tick("窗口二");
        Tick t3=new Tick("窗口三");
        t1.start();
        t2.start();
        t3.start();
    }

}


class Tick extends Thread{
    private static int tickets =100;
    private static Object lock=new Object();

    public Tick(String name) {
        super(name);
    };

    @Override
    public void run() {
        while (tickets >= 1) {
            synchronized (lock) { //不能使用this。因为在测试类中的t1,t2,t3所引用的类类型是同一个,若用this,达不到效果,锁对象不一致
                if (tickets >= 1) {
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    tickets--;
                    System.out.println(Thread.currentThread().getName() + "卖了1张票," + "还剩" + tickets + "票");
                }
            }

        }

    }
}

在这里插入图片描述

(3) 什么时候释放锁 ?

当synchronized锁的代码全部执行完,才会释放锁

(4) 锁对象的选择问题 ?

①任意类型的对象都可以当做监视线程的锁对象。即类型不限制。
②必须保证使用共享数据的多个线程( 具有竞争关系的多个线程 )使用同一个锁对象·
③同步方法的锁对象是不能自由选择的,是默认的。
非静态方法的锁对象是this对象

备注:非静态方法的锁对象是实例对象本身(this)

静态方法的锁对象是当前类的class对象。
只要是同一个类,那么class就一定是同一个


六、守护线程

6.1 守护线程是什么?

有一种线程,它是在后台运行的,它的任务是为其他线程提供服务的,这种线程被称为“守护线程”。JVM的垃圾回收线程就是典型的守护线程。

当系统中所有的被守护线程都结束之后,守护线程就算自己的事情没有做完,也会自动结束即系统中不会只有守护线程在单独运行。

6.2 如何设置守护线程?

public final setDaemon(boolean on)on为true,便可设置指定线程为守护线程

必须在线程启动之前设置,否则会报IllegalThreadStateException异常。

代码演示如下:

public class DemonThread {
    public static void main(String[] args) {
        MyDemon md=new MyDemon();
        /*
这两句代码不能反着放,会触发线程非法状态异常:线程被启动了两次
md.setDaemon(true);
md.start();
*/
        md.setDaemon(true);
        md.start();

        for (int i = 1; i <201 ; i++) {
            System.out.println(i);
        }
    }
}


class MyDemon extends Thread{

    @Override
    public void run() {
        while (true){
            System.out.println("我一直在守护你..........");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这里插入图片描述


七、等待唤醒机制

7.1 线程间通信

为什么要处理线程间通信:

多个线程在处理同一个资源,但是处理的动作(线程的任务)却不相同。而多个线程并发执行时, 在默认情况下CPU是随机切换线程的,当我们需要多个线程来共同完成一件任务,并且我们希望他们有规律的执行, 那么多线程之间需要一些通信机制,可以协调它们的工作,以此来帮我们达到多线程共同操作一份数据。

比如:线程A用来生成包子的,线程B用来吃包子的,包子可以理解为同一资源,线程A与线程B处理的动作,一个是生产,一个是消费,此时B线程必须等到A线程完成后才能执行,那么线程A与线程B之间就需要线程通信,即—— 等待唤醒机制。

7.2 等待唤醒机制

什么是等待唤醒机制

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争(race),比如去争夺锁,但这并不是故事的全部,线程间也会有协作机制。

就是在一个线程满足某个条件时,就进入等待状态(wait()/wait(time)), 等待其他线程执行完他们的指定代码过后再将其唤醒(notify());或可以指定wait的时间,等时间到了自动唤醒;在有多个线程进行等待时,如果需要,可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。

1.wait:线程不再活动,不再参与调度,进入 wait set 中,因此不会浪费 CPU 资源,也不会去竞争锁了,这时的线程状态即是 WAITING或TIMED_WAITING。它还要等着别的线程执行一个特别的动作,也即是“通知(notify)”或者等待时间到,在这个对象上等待的线程从wait set 中释放出来,重新进入到调度队列(ready queue)中
2. notify:则选取所通知对象的 wait set 中的一个线程释放;
3. notifyAll:则释放所通知对象的 wait set 上的全部线程。

注意:

被通知线程被唤醒后也不一定能立即恢复执行,因为它当初中断的地方是在同步块内,而此刻它已经不持有锁,所以她需要再次尝试去获取锁(很可能面临其它线程的竞争),成功后才能在当初调用wait 方法之后的地方恢复执行。

总结如下:

  • 如果能获取锁,线程就从 WAITING 状态变成 RUNNABLE(可运行) 状态;
  • 否则,线程就从 WAITING 状态又变成 BLOCKED(等待锁) 状态

调用wait和notify方法需要注意的细节

  1. wait方法与notify方法必须要由同一个锁对象调用。因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
  2. wait方法与notify方法是属于Object类的方法的。因为:锁对象可以是任意对象,而任意对象的所属类都是继承了Object类的。
  3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为:必须要通过锁对象调用这2个方法。

如何判断有没有线程安全问题?

(1) 是否存在多个线程 (2个或2个以上的线程)

(2)这多个线程是否有共享数据,

如第五节线程安全问题中5.2中的不同代码块案例的tickets=100

(3) 多个线程是否既有读又有与操作(修改)
都包含的话,那么一定有线程安全。
有线程安全问题,就一定要加同步锁。
同步锁有两种加法,同步方法,同步代码块。

tips:

在java.Lang.Object类中: wait();notify();
当这两个方法不是线程的监视器对象调用时,会报ILLealMonitorStateException (非法监视器异常)

7.3 生产者与消费者问题

生产者消费者问题(英语:Producer-consumer problem),也称有限缓冲问题(英语:Bounded-buffer problem),是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程。与此同时,消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区已经装满时加入数据,消费者也不会在缓冲区为空时消耗数据。

生产者与消费者问题中其实隐含了两个问题:

  • 线程安全问题:因为生产者与消费者共享数据缓冲区,不过这个问题可以使用同步解决。
  • 线程的协调工作问题:
    • 要解决该问题,就必须让生产者线程在缓冲区满时等待(wait),暂停进入阻塞状态,等到下次消费者消耗了缓冲区中的数据的时候,通知(notify)正在等待的线程恢复到就绪状态,重新开始往缓冲区添加数据。同样,也可以让消费者线程在缓冲区空时进入等待(wait),暂停进入阻塞状态,等到生产者往缓冲区添加数据之后,再通知(notify)正在等待的线程恢复到就绪状态。通过这样的通信机制来解决此类问题。

7.3.1 一个生产者与一个消费者的协作问题

模拟案例:一家两个人共同经营的小饭馆,一个人作为厨师负责做菜,另一个作为服务员负责取菜,做好的菜都会放到工作台上,这个工作台最多能放5盘菜,这时候厨师就休息了,因为放不下,只能休息,他通过“摇铃”通知服务员去取菜,服务员取完五盘菜后就会休息,因为要等厨师去做菜。

代码演示如下:

//模拟小饭馆【2人】的做菜与取菜流程
public class TestTearoom {
    public static void main(String[] args) {
        Tearoom t=new Tearoom();
        new Thread("厨师"){
            @Override
            public void run() {
                while (true){
                    t.put();
                }

            }
        }.start();

        new Thread("服务员"){
            @Override
            public void run() {
                while (true) {
                    t.take();
                }
            }
        }.start();


    }
}


class Tearoom{
    private final int MAX_TOTAL=5;
    private int total;

    public synchronized void put(){
        if (total>=MAX_TOTAL){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        total++;
        System.out.println(Thread.currentThread().getName()+"做了一盘菜,数量是:"+total);
        this.notify();
    }

    public synchronized void take(){
        if (total<=0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        total--;
        System.out.println(Thread.currentThread().getName()+"拿了一盘菜,数量是:"+total);
        this.notify();
    }

}

在这里插入图片描述

7.3.2 多个生产者与多个消费者的协作问题

模拟案例:一家两个人共同经营的小饭馆,一个人作为厨师负责做菜,另一个作为服务员负责取菜,做好的菜都会放到工作台上,这个工作台最多能放5盘菜,这时候厨师就休息了,因为放不下,只能休息,他通过“摇铃”通知服务员去取菜,服务员取完五盘菜后就会休息,因为要等厨师去做菜。现在,又招募了两个人,一个厨师,一个服务员。重复实现之前的上菜取菜流程

之前的单个生产者与消费者模拟案例代码不变,仅仅增加了两个线程来实现厨师2和服务员2的工作,但出现了问题,如下所示:
在这里插入图片描述
在这里插入图片描述
菜的数量出现了“负数”,为啥会出现这个问题?

问题分析:

在这里插入图片描述
解决措施:
1)被唤醒的线程,应该重新判断条件是否要继续wait
2)生产者唤醒消费者,消费者唤醒生产者,wait和notify方法无法实现

备注:第二种解决措施需要用到多线程高级的应用知识,这里只讨论第一种

修改代码如下:

public class TestTearoom {
    public static void main(String[] args) {
        Tearoom t=new Tearoom();
        new Thread("厨师1"){
            @Override
            public void run() {
                while (true){
                    t.put();
                }
            }
        }.start();

        new Thread("服务员2"){
            @Override
            public void run() {
                while (true) {
                    t.take();
                }
            }
        }.start();

        new Thread("厨师2"){
            @Override
            public void run() {
                while (true){
                    t.put();
                }
            }
        }.start();


        new Thread("服务员1"){
            @Override
            public void run() {
                while (true) {
                    t.take();
                }
            }
        }.start();
    }
}


class Tearoom{
    private final int MAX_TOTAL=5;
    private int total;

    public synchronized void put(){
        while (total>=MAX_TOTAL){ //替换了while
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        total++;
        System.out.println(Thread.currentThread().getName()+"做了一盘菜,数量是:"+total);
        this.notify();
    }

    public synchronized void take(){
       while (total<=0){ //替换了while
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        total--;
        System.out.println(Thread.currentThread().getName()+"拿了一盘菜,数量是:"+total);
        this.notify();
    }
}

在这里插入图片描述
tips:

如果出现运行卡顿,将this.notify()改为this.notifyAll(),唤醒所有wai的进程。


八、线程生命周期

8.1 观点1:5种状态(JDK1.5之前)

简单来说,线程的生命周期有五种状态:新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)、死亡(Dead)。CPU需要在多条线程之间切换,于是线程状态会多次在运行、阻塞、就绪之间切换。

在这里插入图片描述
1. 新建

当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状。此时它和其他Java对象一样,仅仅由JVM为其分配了内存,并初始化了实例变量的值。此时的线程对象并没有任何线程的动态特征,程序也不会执行它的线程体run()。

2. 就绪

但是当线程对象调用了start()方法之后,就不一样了,线程就从新建状态转为就绪状态。JVM会为其创建方法调用栈和程序计数器,当然,处于这个状态中的线程并没有开始运行,只是表示已具备了运行的条件,随时可以被调度。至于什么时候被调度,取决于JVM里线程调度器的调度。

注意:

程序只能对新建状态的线程调用start(),并且只能调用一次,如果对非新建状态的线程,如已启动的线程或已死亡的线程调用start()都会报错IllegalThreadStateException异常。

3. 运行

如果处于就绪状态的线程获得了CPU,开始执行run()方法的线程体代码,则该线程处于运行状态。如果计算机只有一个CPU,在任何时刻只有一个线程处于运行状态,如果计算机有多个处理器,将会有多个线程并行(Parallel)执行。

当然,美好的时光总是短暂的,而且CPU讲究雨露均沾。对于抢占式策略的系统而言,系统会给每个可执行的线程一个小时间段来处理任务,当该时间用完,系统会剥夺该线程所占用的资源,让其回到就绪状态等待下一次被调度。此时其他线程将获得执行机会,而在选择下一个线程时,系统会适当考虑线程的优先级。

4. 阻塞

当在运行过程中的线程遇到如下情况时,线程会进入阻塞状态:

  • 线程调用了sleep()方法,主动放弃所占用的CPU资源;
  • 线程试图获取一个同步监视器,但该同步监视器正被其他线程持有;
  • 线程执行过程中,同步监视器调用了wait(),让它等待某个通知(notify);
  • 线程执行过程中,同步监视器调用了wait(time)
  • 线程执行过程中,遇到了其他线程对象的加塞(join);
  • 线程被调用suspend方法被挂起(已过时,因为容易发生死锁);

当前正在执行的线程被阻塞后,其他线程就有机会执行了。针对如上情况,当发生如下情况时会解除阻塞,让该线程重新进入就绪状态,等待线程调度器再次调度它:

  • 线程的sleep()时间到;
  • 线程成功获得了同步监视器;
  • 线程等到了通知(notify);
  • 线程wait的时间到了
  • 加塞的线程结束了;
  • 被挂起的线程又被调用了resume恢复方法(已过时,因为容易发生死锁);

5. 死亡

线程会以以下三种方式之一结束,结束后的线程就处于死亡状态:

  • run()方法执行完成,线程正常结束
  • 线程执行过程中抛出了一个未捕获的异常(Exception)或错误(Error)
  • 直接调用该线程的stop()来结束该线程(已过时,因为容易发生死锁)

8.2 观点2:6种状态(JDK1.5之后)

我们在java.lang.Thread.State的枚举类中这样看到:
在这里插入图片描述
首先它没有区分:就绪和运行状态,因为对于Java对象来说,只能标记为可运行,至于什么时候运行,不是JVM来控制的了,是OS来进行调度的,而且时间非常短暂,因此对于Java对象的状态来说,无法区分。只能我们人为的进行想象和理解。

其次根据Thread.State的定义,阻塞状态是分为三种的:BLOCKED、WAITING、TIMED_WAITING。

  • BLOCKED:是指互有竞争关系的几个线程,其中一个线程占有锁对象时,其他线程只能等待锁。只有获得锁对象的线程才能有执行机会。
  • TIMED_WAITING:当前线程执行过程中遇到Thread类的sleep或join,Object类的wait,LockSupport类的park方法,并且在调用这些方法时,设置了时间,那么当前线程会进入TIMED_WAITING,直到时间到,或被中断。
  • WAITING:当前线程执行过程中遇到遇到Object类的wait,Thread类的join,LockSupport类的park方法,并且在调用这些方法时,没有指定时间,那么当前线程会进入WAITING状态,直到被唤醒。
    • 通过Object类的wait进入WAITING状态的要有Object的notify/notifyAll唤醒;
    • 通过Condition的await进入WAITING状态的要有Conditon的signal方法唤醒;
    • 通过LockSupport类的park方法进入WAITING状态的要有LockSupport类的unpark方法唤醒
    • 通过Thread类的join进入WAITING状态,只有调用join方法的线程对象结束才能让当前线程恢复;

说明:当从WAITING或TIMED_WAITING恢复到Runnable状态时,如果发现当前线程没有得到监视器锁,那么会立刻转入BLOCKED状态

在这里插入图片描述


九、释放锁操作与死锁

9.1 释放锁的操作

当前线程的同步方法、同步代码块执行结束

当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致当前线程异常结束.

当前线程在同步代码块、同步方法中执行了锁对象的wait()方法,当前线程被挂起,并释放锁

9.2 不会释放锁的操作

线程执行同步代码块或同步方法时,程序调用Thread.sleep()、Thread.vield0方法暂停当前线程的执行.

9.3 死锁

不同的线程分别锁住对方需要的同步监视器对象不释放,都在等待对方先放弃时就形成了线程的死锁。一旦出现死锁,整个程序既不会发生异常,也不会给出任何提示,只是所有线程处于阻塞状态,无法继续.

十、 面试题

sleep()和wait()方法的区别?

(1)sleep()不释放锁,wait()释放锁

(2)sleep()指定休眠的时间,wait()可以指定时间也可以无限等待直到notify或notifyAll

(3)sleep()在Thread类中声明的静态方法,wait方法在Object类中声明

因为我们调用wait()方法是由锁对象调用,而锁对象的类型是任意类型的对象。那么希望任意类型的对象都要有的方法,只能声明在Object类中。


  • 10
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
评论 8
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陌上少年,且听这风吟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值