亲宝软件园·资讯

展开

多线程,线程类三种方式,线程调度,线程同步,死锁,线程间的通信,阻塞队列,wait和sleep区别?

赶星而至 人气:0

　　　　　　　　　　　　　　　　　　　　　　重难点梳理

　　　　　　　　　　　　　　　　　　　　　　知识点梳理

 

 

 

　　　　　　　　　　　　　　　　　　　　　　　　　　学习目标

1、能够知道什么是进程什么是线程（进程和线程的概述，多进程和多线程的意义）

2、能够掌握线程常见API的使用

3、能够理解什么是线程安全问题

4、能够知道什么是锁

5、能够知道什么是死锁

6、能够掌握线程3种创建方式（3种创建方式）

7、能够知道什么是等待唤醒机制

 

　　　　　　　　　　　　　　　　　　　　　　　　　　超详细讲义

==知识点==

  1. 多线程的概念

  2. 多线程的实现方式

  3. 线程类的常见方法

  4. 线程同步

  5. 死锁

  6. 生产者消费者

1.多线程的概念

1.1初步了解多线程【重点】

1.什么是多线程？

采用多线程技术可以同时执行多个任务（比如:迅雷同时下载多个任务），多线程需要硬件支持

1.2并发和并行【重点】

1.什么是并行？

在同一时刻，有多条线程在多个CPU上同时执行

2.什么是并发？

在一段时间内，有多条线程在单个CPU上交替执行

1.3进程和线程【重点】

（共4点）

1.什么是进程？

可以理解为正在运行的程序

2.什么是线程？

线程它是进程的一部分，是进程中的单个控制流，是一条执行路径（执行一项任务）

一个进程，可以有多条线程，至少有一条线程(线程才是CPU执行的最小单元)

线程只能在进程中运行

==3.为什么要学习多线程==

可以让程序同时执行多个任务,提高程序的执行效率（例如一次上传多张图片，同时打开多个网页）

2.多线程的实现方式

2.1实现多线程方式一：继承Thread类【重点】

1.实现多线程的方式有哪些？

  • 继承Thread类的方式进行实现

  • 实现Runnable接口的方式进行实现

  • 利用Callable和Future接口方式实现

2.方法介绍

方法名说明
void run() 在线程开启后，此方法将被调用执行
void start() 使此线程开始执行，Java虚拟机会调用run方法()

3.实现步骤

  • 定义一个类MyThread继承Thread类

  • 在MyThread类中重写run()方法

  • 创建MyThread类的对象

  • 启动线程

代码演示

package com.itheima.threaddemo1;
​
public class MyThread extends Thread{
    @Override
    public void run() {
        //代码就是线程在开启之后执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println("线程开启了" + i);
        }
    }
}
​
package com.itheima.threaddemo1;
​
public class Demo {
    public static void main(String[] args) {
        //创建一个线程对象
        MyThread t1 = new MyThread();
        //创建一个线程对象
        MyThread t2 = new MyThread();
​
        //t1.run();//表示的仅仅是创建对象,用对象去调用方法,并没有开启线程.
        //t2.run();
        //开启一条线程
        t1.start();
        //开启第二条线程
        t2.start();
    }
}

2.2 多线程的实现方式-两个小问题【了解】

1.为什么要重写run()方法？

因为run()是用来封装被线程执行的代码

2.run()方法和start()方法的区别？

run()：封装线程执行的代码，直接调用，相当于普通方法的调用

start()：启动线程；然后由JVM调用此线程的run()方法

2.3实现多线程方式二：实现Runnable接口【重点】

（共3点）

1.Thread构造方法

方法名说明
Thread(Runnable target) 分配一个新的Thread对象

2.实现步骤

  • 定义一个类MyRunnable实现Runnable接口

  • 在MyRunnable类中重写run()方法

  • 创建MyRunnable类的对象

  • 创建Thread类的对象，把MyRunnable对象作为构造方法的参数

  • 启动线程

代码演示

package com.itheima.threaddemo2;
​
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程启动后执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "第二种方式实现多线程" + i);
        }
    }
}
​
package com.itheima.threaddemo2;
​
public class Demo {
    public static void main(String[] args) {
        //创建了一个参数的对象
        MyRunnable mr = new MyRunnable();
        //创建了一个线程对象,并把参数传递给这个线程.
        //在线程启动之后,执行的就是参数里面的run方法
        Thread t1 = new Thread(mr);
        //开启线程
        t1.start();
​
​
        MyRunnable mr2 = new MyRunnable();
        Thread t2 = new Thread(mr2);
        t2.start();
​
    }
}

==3.线程的执行是顺序是随机的==

2.4 实现多线程方式三: 实现Callable接口【重点】

1.方法介绍

方法名说明
V call() 计算结果，如果无法计算结果，则抛出一个异常
FutureTask(Callable<V> callable) 创建一个 FutureTask，一旦运行就执行给定的 Callable
V get() 如有必要，等待计算完成，然后获取其结果

2.实现步骤

  • 定义一个类MyCallable实现Callable接口

  • 在MyCallable类中重写call()方法

  • 创建MyCallable类的对象

  • 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数

  • 创建Thread类的对象，把FutureTask对象作为构造方法的参数

  • 启动线程

  • 再调用get方法，就可以获取线程结束之后的结果。

3.注意事项

get()方法的调用一定要在Thread类对象调用start()方法之后

代码演示

package com.itheima.threaddemo3;
​
import java.util.concurrent.Callable;
​
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }
}
​
​
package com.itheima.threaddemo3;
​
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
​
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();
​
        //Thread t1 = new Thread(mc);
​
        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);
​
        //创建线程对象
        Thread t1 = new Thread(ft);
​
        String s = ft.get();
        //开启线程
        t1.start();
​
        //String s = ft.get();
        System.out.println(s);
    }
}

2.5 三种实现方式的对比【重点】

1.实现Runnable、Callable接口

  • 好处: 扩展性强，实现该接口的同时还可以继承其他的类

  • 缺点: 编程相对复杂，不能直接使用Thread类中的方法

2.继承Thread类

  • 好处: 编程比较简单，可以直接使用Thread类中的方法

  • 缺点: 可以扩展性较差，不能再继承其他的类

3.线程类中的常见方法

3.1设置和获取线程名称【重点】

方法介绍

方法名说明
void setName(String name) 将此线程的名称更改为等于参数name
String getName() 返回此线程的名称

代码演示

package com.itheima.threaddemo4;
​
public class MyThread extends Thread {
​
    public MyThread() {
    }
    
    public MyThread(String name) {
        super(name);
    }
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "@@@" + i);
        }
    }
}
​
package com.itheima.threaddemo4;
​
public class Demo {
    //1,线程是有默认名字的,格式:Thread-编号
    public static void main(String[] args) {
        MyThread t1 = new MyThread("小蔡");
        MyThread t2 = new MyThread("小强");
​
        //t1.setName("小蔡");
        //t2.setName("小强");
​
        t1.start();
        t2.start();
    }
}

3.2 Tread方法-获得当前线程对象【重点】

方法名说明
static Thread currentThread() 返回对当前正在执行的线程对象的引用 
package com.itheima.threaddemo5;
public class Demo {
    public static void main(String[] args) {
        String name = Thread.currentThread().getName();
        System.out.println(name);
    }
}

3.3 线程休眠【应用】【重点】

1.相关方法

方法名说明
static void sleep(long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数

代码演示

package com.itheima.threaddemo6;
​
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
​
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}
package com.itheima.threaddemo6;
​
public class Demo {
    public static void main(String[] args) throws InterruptedException {
        /*System.out.println("睡觉前");
        Thread.sleep(3000);
        System.out.println("睡醒了");*/
​
        MyRunnable mr = new MyRunnable();
​
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
​
        t1.start();
        t2.start();
    }
}

3.4 线程优先级【了解】

1.优先级相关方法

方法名说明
final int getPriority() 返回此线程的优先级
final void setPriority(int newPriority) 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10

代码演示

package com.itheima.threaddemo7;
​
import java.util.concurrent.Callable;
​
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}
package com.itheima.threaddemo7;
​
import java.util.concurrent.FutureTask;
​
public class Demo {
    public static void main(String[] args) {
        //优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();
​
        FutureTask<String> ft = new FutureTask<>(mc);
​
        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        //System.out.println(t1.getPriority());//5
        t1.start();
​
        MyCallable mc2 = new MyCallable();
​
        FutureTask<String> ft2 = new FutureTask<>(mc2);
​
        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        //System.out.println(t2.getPriority());//5
        t2.start();
    }
}

 

3.5 守护线程【了解】

1.什么是守护线程？

守护线程是程序运行的时候在后台提供一种通用服务的线程（保镖与主人）

2.守护线程的特点？

被守护的线程结束，不会立即结束，挣扎一会儿才结束

3.如何使用守护线程？

相关方法

方法名说明
void setDaemon(boolean on) 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

代码演示

package com.itheima.threaddemo8.example;
​
​
public class MyThread1 extends Thread{
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.getName()+"---"+i);
        }
    }
}
package com.itheima.threaddemo8.example;
​
​
public class MyThread1 extends Thread{
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.getName()+"---"+i);
        }
    }
}
package com.itheima.threaddemo8.example;
​
​
public class Test {
​
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();//保镖
        t1.setDaemon(true);
        MyThread2 t2 = new MyThread2();//主人
       t1.setName("保镖");
       t2.setName("主人");
       t2.start();
       t1.start();
    }
}

4.线程同步

4.1卖票【难点】

  • 案例需求

    某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

  • 实现步骤

    • 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;

    • 在SellTicket类中重写run()方法实现卖票，代码步骤如下

    • 判断票数大于0，就卖票，并告知是哪个窗口卖的

    • 卖了票之后，总票数要减1

    • 票卖没了，线程停止

    • 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下

    • 创建SellTicket类的对象

    • 创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称

    • 启动线程

  • 代码实现

    package com.itheima.threaddemo9;
    ​
    public class Ticket implements Runnable {
        //票的数量
        private int ticket = 100;
    ​
        @Override
        public void run() {
            while(true){
                
                    if(ticket <= 0){
                        //卖完了
                        break;
                    }else{
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        ticket--;
                        System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                    }
                }
            
      }
    }
    ​
    package com.itheima.threaddemo9;
    ​
    public class Demo {
        public static void main(String[] args) {
            Ticket ticket = new Ticket();
    ​
            Thread t1 = new Thread(ticket);
            Thread t2 = new Thread(ticket);
            Thread t3 = new Thread(ticket);
    ​
            t1.setName("窗口一");
            t2.setName("窗口二");
            t3.setName("窗口三");
    ​
            t1.start();
            t2.start();
            t3.start();
        }
    }

4.2 线程安全问题-原因分析【难点】

1.卖票出现了问题

  • 相同的票出现了多次

     

     

  • 出现了负数的票

     

     

     

    出现问题的根本原因？

    线程执行的随机，在卖票的过程中CPU随机的执行了多条线程(也可以说是在卖票的过程中多条线程操作了共享数据ticket)

4.3同步代码块解决数据安全问题【重点】

1.如何解决上述问题呢？

  • 任意时刻只有一条线程可以操作共享变量

  • Java中如何解决？

同步代码块格式：

synchronized(任意对象) { 
    多条语句操作共享数据的代码 
}

synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

2.synchronized同步代码块的特点？

默认情况下是打开的，只要有一个线程进去执行代码了，锁就会关闭

当线程执行完出来时，锁才会自动打开

 

 

 

3.什么样的情况下，会有线程安全问题

3.1 多线程环境

3.2 有共享数据

3.3 有对共享数据的操作(增、删、改(除了long、double类的基本数据类型直接赋值)、查)

代码演示

package com.itheima.threaddemo9;
public class Ticket implements Runnable {
    //票的数量
    private int ticket = 100;
    private Object obj = new Object();
​
    @Override
    public void run() {
        while(true){
            synchronized (obj){//多个线程必须使用同一把锁.
                if(ticket <= 0){
                    //卖完了
                    break;
                }else{
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                }
            }
        }
    }
}
​
package com.itheima.threaddemo9;
​
public class Demo {
    public static void main(String[] args) {
        /*Ticket ticket1 = new Ticket();
        Ticket ticket2 = new Ticket();
        Ticket ticket3 = new Ticket();
​
        Thread t1 = new Thread(ticket1);
        Thread t2 = new Thread(ticket2);
        Thread t3 = new Thread(ticket3);*/
​
        Ticket ticket = new Ticket();
​
        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);
​
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
​
        t1.start();
        t2.start();
        t3.start();
    }
}

4.4 线程安全问题-锁对象唯一【重点】

1.锁对象为什么要唯一？

不同线程如果锁的不是同一个对象，就解决不了线程的安全问题

package com.itheima.threaddemo10;
​
public class MyThread extends Thread {
    private static int ticketCount = 100;
    private static Object obj = new Object();
​
    @Override
    public void run() {
        while(true){
            synchronized (obj){ //就是当前的线程对象.
                if(ticketCount <= 0){
                    //卖完了
                    break;
                }else{
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticketCount--;
                    System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
                }
            }
        }
    }
}
​
package com.itheima.threaddemo010;
​
public class Demo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
​
        t1.setName("窗口一");
        t2.setName("窗口二");
​
        t1.start();
        t2.start();
    }
}

4.5同步方法解决数据安全问题【重点】

(共4点)

1.同步方法的格式

同步方法：就是把synchronized关键字加到方法上

修饰符 synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}

2.同步方法的锁对象是什么呢?

this

public class MyRunnableCommon implements Runnable {
    private static int ticketCount = 100;
    @Override
    public void run() {
        while(true){
            if("窗口一".equals(Thread.currentThread().getName())){
                //同步方法
                boolean result = synchronizedMthod();
                if(result){
                    break;
                }
            }

            if("窗口二".equals(Thread.currentThread().getName())){
                //同步代码块
                synchronized (this){
                    if(ticketCount == 0){
                       break;
                    }else{
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        ticketCount--;
                        System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
                    }
                }
            }

        }
    }

    private  synchronized boolean synchronizedMthod() {
        if(ticketCount == 0){
            return true;
        }else{
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketCount--;
            System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
            return false;
        }
    }
}

3.静态同步方法的格式

同步静态方法：就是把synchronized关键字加到静态方法上

修饰符 static synchronized 返回值类型 方法名(方法参数) { 
	方法体；
}

4.同步静态方法的锁对象是什么呢?

类名.class

代码演示

package com.itheima.threaddemo011;

public class MyRunnable implements Runnable {
    private static int ticketCount = 100;

    @Override
    public void run() {
        while(true){
            if("窗口一".equals(Thread.currentThread().getName())){
                //同步方法
                boolean result = synchronizedMthod();
                if(result){
                    break;
                }
            }

            if("窗口二".equals(Thread.currentThread().getName())){
                //同步代码块
                synchronized (MyRunnable.class){
                    if(ticketCount == 0){
                       break;
                    }else{
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        ticketCount--;
                        System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
                    }
                }
            }

        }
    }

    private static synchronized boolean synchronizedMthod() {
        if(ticketCount == 0){
            return true;
        }else{
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketCount--;
            System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
            return false;
        }
    }
}


package com.itheima.threaddemo011;

public class Demo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

        t1.setName("窗口一");
        t2.setName("窗口二");

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

4.6 Lock锁【重点】（视频19 5‘’）

1.如何手动开关锁呢？

使用lock

2.如何使用Lock？

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

ReentrantLock构造方法

方法名说明
ReentrantLock() 创建一个ReentrantLock的实例

加锁解锁方法

方法名说明
void lock() 获得锁
void unlock() 释放锁

代码演示

package com.itheima.threaddemo012;

import java.util.concurrent.locks.ReentrantLock;

public class Ticket implements Runnable {
    //票的数量
    private int ticket = 100;
    private Object obj = new Object();
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            //synchronized (obj){//多个线程必须使用同一把锁.
            try {
                lock.lock();
                if (ticket <= 0) {
                    //卖完了
                    break;
                } else {
                    Thread.sleep(100);
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
            // }
        }
    }
}

package com.itheima.threaddemo012;

public class Demo {
    public static void main(String[] args) {
        /*Ticket ticket1 = new Ticket();
        Ticket ticket2 = new Ticket();
        Ticket ticket3 = new Ticket();

        Thread t1 = new Thread(ticket1);
        Thread t2 = new Thread(ticket2);
        Thread t3 = new Thread(ticket3);*/

        Ticket ticket = new Ticket();

        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

4.7 死锁【了解】

1.什么是死锁?(吃饭)

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行

代码演示

 

 

 

5.生产者消费者

5.1 生产者和消费者思路分析【难点】

 

 

 

5.2生产者和消费者案例【难点】

Object类的等待和唤醒方法

方法名说明
void wait() 导致当前线程等待同时释放锁，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
void notify() 唤醒正在等待单个线程,并不立即释放锁
void notifyAll() 唤醒正在等待所有线程,并不立即释放锁

案例需求

  • 桌子类(Desk)：定义表示包子数量的变量,定义锁对象变量,定义标记桌子上有无包子的变量

  • 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

    1.判断是否有包子,决定当前线程是否执行

    2.如果有包子,就进入等待状态,如果没有包子,继续执行,生产包子

    3.生产包子之后,更新桌子上包子状态,唤醒消费者消费包子

  • 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务

    1.判断是否有包子,决定当前线程是否执行

    2.如果没有包子,就进入等待状态,如果有包子,就消费包子

    3.消费包子后,更新桌子上包子状态,唤醒生产者生产包子

  • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下

    创建生产者线程和消费者线程对象

    分别开启两个线程

 

 

 

代码实现

package com.itheima.threaddemo014;

public class Desk {

    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    public static boolean flag = false;

    //汉堡包的总数量
    public static int count = 10;

    //锁对象
    public static final Object lock = new Object();
}

package com.itheima.threaddemo014;

public class Cooker extends Thread {
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。
    @Override
    public void run() {
        while(true){
            synchronized (Desk.lock){
                if(Desk.count == 0){
                    break;
                }else{
                    if(!Desk.flag){
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        Desk.flag = true;
                        Desk.lock.notifyAll();
                    }else{
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

package com.itheima.threaddemo014;

public class Foodie extends Thread {
    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一

        //套路:
            //1. while(true)死循环
            //2. synchronized 锁,锁对象要唯一
            //3. 判断,共享数据是否结束. 结束
            //4. 判断,共享数据是否结束. 没有结束
        while(true){
            synchronized (Desk.lock){
                if(Desk.count == 0){
                    break;
                }else{
                    if(Desk.flag){
                        //有
                        System.out.println("吃货在吃汉堡包");
                        Desk.flag = false;
                        Desk.lock.notifyAll();
                        Desk.count--;
                    }else{
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }

    }
}

5.3生产者和消费者案例优化【难点】

  • 需求

    • 将Desk类中的变量,采用面向对象的方式封装起来

    • 生产者和消费者类中构造方法接收Desk类对象,之后在run方法中进行使用

    • 创建生产者和消费者线程对象,构造方法中传入Desk类对象

    • 开启两个线程

  • 代码实现

    package com.itheima.threaddemo015;

public class Desk {

    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
  //public static boolean flag = false;
    private boolean flag;

    //汉堡包的总数量
    //public static int count = 10;
    //以后我们在使用这种必须有默认值的变量
 // private int count = 10;
    private int count;

    //锁对象
  //public static final Object lock = new Object();
    private final Object lock = new Object();

    public Desk() {
      this(false,10);
    }

    public Desk(boolean flag, int count) {
        this.flag = flag;
      this.count = count;
    }

    public boolean isFlag() {
      return flag;
    }

    public void setFlag(boolean flag) {
      this.flag = flag;
    }

    public int getCount() {
      return count;
    }

    public void setCount(int count) {
      this.count = count;
    }

    public Object getLock() {
      return lock;
    }

    @Override
    public String toString() {
        return "Desk{" +
                "flag=" + flag +
                ", count=" + count +
                ", lock=" + lock +
                '}';
  }
}

package com.itheima.threaddemo015;

public class Cooker extends Thread {

    private Desk desk;

    public Cooker(Desk desk) {
        this.desk = desk;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。
	
        //套路:
            //1. while(true)死循环
            //2. synchronized 锁,锁对象要唯一
            //3. 判断,共享数据是否结束. 结束
            //4. 判断,共享数据是否结束. 没有结束
    @Override
    public void run() {
        while(true){
            synchronized (desk.getLock()){
                if(desk.getCount() == 0){
                    break;
                }else{
                    //System.out.println("验证一下是否执行了");
                    if(!desk.isFlag()){
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        desk.setFlag(true);
                        desk.getLock().notifyAll();
                    }else{
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}


package com.itheima.threaddemo015;

public class Desk {

    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    //public static boolean flag = false;
    private boolean flag;

    //汉堡包的总数量
    //public static int count = 10;
    //以后我们在使用这种必须有默认值的变量
   // private int count = 10;
    private int count;

    //锁对象
    //public static final Object lock = new Object();
    private final Object lock = new Object();

    public Desk() {
        this(false,10);
    }

    public Desk(boolean flag, int count) {
        this.flag = flag;
        this.count = count;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public Object getLock() {
        return lock;
    }

    @Override
    public String toString() {
        return "Desk{" +
                "flag=" + flag +
                ", count=" + count +
                ", lock=" + lock +
                '}';
    }
}

package com.itheima.threaddemo015;

public class Foodie extends Thread {
    private Desk desk;

    public Foodie(Desk desk) {
        this.desk = desk;
    }

    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一

        //套路:
            //1. while(true)死循环
            //2. synchronized 锁,锁对象要唯一
            //3. 判断,共享数据是否结束. 结束
            //4. 判断,共享数据是否结束. 没有结束
        while(true){
            synchronized (desk.getLock()){
                if(desk.getCount() == 0){
                    break;
                }else{
                    //System.out.println("验证一下是否执行了");
                    if(desk.isFlag()){
                        //有
                        System.out.println("吃货在吃汉堡包");
                        desk.setFlag(false);
                        desk.getLock().notifyAll();
                        desk.setCount(desk.getCount() - 1);
                    }else{
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }

    }
}

5.4阻塞队列基本使用【重点】

(共4点)

1.什么是阻塞队列？

阻塞队列是一个在队列基础上又支持了两个附加操作的队列

2.附加的方法

put(anObject): 将参数放入队列,如果放不进去会阻塞

take(): 取出第一个数据,取不到会阻塞

3.阻塞队列继承结构

 

 

 

4.常见BlockingQueue实现类

ArrayBlockingQueue: 底层是数组,有界

LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值

代码示例

package com.itheima.threaddemo016;

import java.util.concurrent.ArrayBlockingQueue;

public class Demo {
    public static void main(String[] args) throws InterruptedException {
         // 创建阻塞队列的对象,容量为 1
         ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(1);

         // 存储元素
         arrayBlockingQueue.put("汉堡包");

         // 取元素
         System.out.println(arrayBlockingQueue.take());
         System.out.println(arrayBlockingQueue.take()); // 取不到会阻塞

         System.out.println("程序结束了");
    }
}

5.5阻塞队列实现等待唤醒机制【难点】

案例需求

  • 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

    1.构造方法中接收一个阻塞队列对象

    2.在run方法中循环向阻塞队列中添加包子

    3.打印添加结果

  • 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务

    1.构造方法中接收一个阻塞队列对象

    2.在run方法中循环获取阻塞队列中的包子

    3.打印获取结果

  • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下

    创建阻塞队列对象

    创建生产者线程和消费者线程对象,构造方法中传入阻塞队列对象

    分别开启两个线程

 

 

 

代码实现

package com.itheima.threaddemo016;

import java.util.concurrent.ArrayBlockingQueue;

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue<String> bd = new ArrayBlockingQueue<>(1);
        Foodie f = new Foodie(bd);
        Cooker c = new Cooker(bd);
        f.start();
        c.start();
    }
}
package com.itheima.threaddemo016;

import com.itheima.threaddemo015.Desk;

import java.util.concurrent.ArrayBlockingQueue;

public class Cooker extends Thread {

    private ArrayBlockingQueue<String> bd;

    public Cooker(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }
    @Override
    public void run() {
        while (true) {
            try {
                bd.put("汉堡包");
                System.out.println("厨师放入一个汉堡包");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
package com.itheima.threaddemo016;

import com.itheima.threaddemo015.Desk;

import java.util.concurrent.ArrayBlockingQueue;

public class Foodie extends Thread {
    private ArrayBlockingQueue<String> bd;

    public Foodie(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }

    @Override
    public void run() {
        while (true) {
            try {
                String take = bd.take();
                System.out.println("吃货将" + take + "拿出来吃了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

总结：

在java中如何实现等待和唤醒机制?

1.wait和notify()或notifyAll()

wait:让线程等待，同时立即释放锁 --->sleep():让线程休眠，但是不会释放锁

notify()或notifyAll(): 唤醒等待的线程，但是不会立即释放锁

2.阻塞队列

put:存,如果队例满的话，会阻塞(等待)

take:取,如果取不到，会阻塞(等待)

 

 

 

　　　　　　　　　　　　　　　　　　　　　　　　扩展练习

题目1

编写程序，创建两个线程对象，一根线程循环输出“播放背景音乐”，另一根线程循环输出“显示画面”; 要求:

1: 1个线程使用Runnable接口的匿名内部类实现

2: 另一个线程使用lambda实现

效果:

 

 

 

参考答案:

package day13.No_1;
​
public class Demo {
    public static void main(String[] args) {
        //匿名内部类实现
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("播放背景音乐!");
                }
            }
        }).start();
        //lambda实现
        new Thread(() -> {
            while (true) {
                System.out.println("显示画面!");
            }
        }).start();
    }
}
​

题目2

3.请使用继承Thread类的方式定义一个线程类，在run()方法中循环10次，每1秒循环1次，每次循环按“yyyy-MM-dd HH:mm:ss”的格式打印当前系统时间。 请定义测试类，并定义main()方法，启动此线程，观察控制台打印。

要求:

1: 使用匿名内部类配合SimpleDateFormat和Date实现

2: 使用lambda配合LocalDateTime和DateTimeFormatter实现

效果:

 

 

 

参考答案:

package day13.No_2;
​
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
​
public class Demo {
    public static void main(String[] args) {
  /*
  //方式一内部类实现
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Date date = new Date();
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String format = sdf.format(date);
                    System.out.println(format);
                }
            }
        }).start();
        */
  //方式二:lambda实现
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                LocalDateTime now = LocalDateTime.now();
                DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                String format = dateTimeFormatter.format(now);
                System.out.println(format);
            }
        }).start();
    }
}
​

 运行效果:

 

 

 

题目3

请编写多线程应用程序，模拟多个人通过一个山洞： (1).这个山洞每次只能通过一个人，每个人通过山洞的时间为1秒； (2).创建10个线程，同时准备过此山洞，并且定义一个变量用于记录通过隧道的人数。显示每次通过山洞人的姓名，和通过顺序；

要求:

保证安全问题,不能出现多个人同时通过山洞的现象;(必须逐一通过)

效果:

 

 

 

参考答案:

线程文件:

package day13.No_3;
​
public class MyRunnable implements Runnable {
    private static int count = 10;
    private final static Object obj = new Object();
    private static int i = 1;
​
    @Override
    public void run() {
        synchronized (obj) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count--;
            System.out.println(Thread.currentThread().getName() + "通过山洞,他是第" + i + "个通过");
            i++;
        }
    }
}
​
​
​

测试文件:

package day13.No_3;
​
public class Demo {
    public static void main(String[] args) {
　　　　　//此处可以使用for循环创建线程
        MyRunnable mr = new MyRunnable();
        Thread tr1 = new Thread(mr, "线程1");
        tr1.start();
        Thread tr2 = new Thread(mr, "线程2");
        tr2.start();
        Thread tr3 = new Thread(mr, "线程3");
        tr3.start();
        Thread tr4 = new Thread(mr, "线程4");
        tr4.start();
        Thread tr5 = new Thread(mr, "线程5");
        tr5.start();
        Thread tr6 = new Thread(mr, "线程6");
        tr6.start();
        Thread tr7 = new Thread(mr, "线程7");
        tr7.start();
        Thread tr8 = new Thread(mr, "线程8");
        tr8.start();
        Thread tr9 = new Thread(mr, "线程9");
        tr9.start();
        Thread tr10 = new Thread(mr, "线程10");
        tr10.start();
​
    }
}
​

 运行效果:

 

 

 

题目4

拼手速抽奖案例.

1.现有一个集合装了10个奖品在里面,分别是:{"电视机","电冰箱","电脑","游戏机","洗衣机","空调","手机","平板电脑","电动车","电饭煲"};

2.假如有3个人同时去抽这10个奖品.最后打印出来.三个人各自都抽到了什么奖品.

例如:

张三: “电视机”,”电冰箱”,”电脑”,”游戏机”,”洗衣机”

李四: ”空调”,”手机”,”平板电脑”,

王五: ”电动车”,”电饭煲

要求:

1:3个人同时开始抽奖,每次抽奖需要使用0.5秒才能完成抽奖;

2:需要控制住同一个奖项不能同时被多个人抽走;

效果:

 

 

 

参考答案:

线程类

package day13.No_4;
​
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
​
public class MyRunnable implements Runnable {
    private static ArrayList<String>list=new ArrayList<>(List.of("电视机","电冰箱","电脑","游戏机","洗衣机","空调","手机","平板电脑","电动车","电饭煲"));
    private static Object object=new Object();
    @Override
    public void run() {
        while (list.size()>0){
            synchronized (object){
                if (list.size()==0){
                    return;
                }
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String name = list.remove(new Random().nextInt(list.size()));
                System.out.println(Thread.currentThread().getName()+"抽到了"+name);
            }
        }
    }
}
​

测试类:

package day13.No_4;
​
public class Demo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr, "张三");
        Thread t2 = new Thread(mr, "李四");
        Thread t3 = new Thread(mr, "王五");
        t1.start();
        t2.start();
        t3.start();
    }
}
​

运行效果:

 

 

 

 

 

加载全部内容
相关教程
猜你喜欢
用户评论