多线程

作者: 笺札code | 来源:发表于2020-03-23 23:25 被阅读0次

多线程

并发与并行

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生(同时发生)。

83.png

线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

84.png

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程。

85.png

线程调度

分时调度

所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
抢占式调度

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

主线程

执行主(main)方法的线程

单线程程序：java程序中只有一个线程，执行从main方法开始，从上到下依次执行。

86.png

创建线程类

第一种方式：创建Thread类的子类

package com.jz.thread;

// 1.创建一个Thread类的子类
public class MyThread extends Thread{
//2.在Thread类的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么?)
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run: " + i);
        }
    }
}

package com.jz.thread;

/*
    创建多线程程序的第一种方式：创建Thread类的子类
    java.util.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类

    实现步骤：
        1.创建一个Thread类的子类
        2.在Thread类的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么?)
        3.创建Thread类的子类对象
        4.调用Thread类中的方法start方法，开启新的线程，执行run方法
            void start() 使该线程开始执行; Java虚拟机调用该线程的run方法。
            结果是两个线程并发地运行；当前线程(main线程)和另一个线程（创建的新线程，执行其run方法）。
            多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。

   java程序属于抢占式调度，那个线程的优先级高，那个线程先执行；同一个优先级，随机选择一个执行
 */
public class threadDemo01 {
    public static void main(String[] args) {
        // 3.创建Thread类的子类对象
        MyThread mt = new MyThread();
        // 4.调用Thread类中的方法start方法，开启新的线程，执行run方法
        mt.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main： " + i);
        }
    }
}

第二种方式：实现Runnable接口

java.lang.Runnable：Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。

package com.jz.thread;

//1.创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
    // 2.在实现类中重写Runnable接口的run方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

package com.jz.thread;

/*
    java.lang.Thread类的构造方法
        Thread(Runnable target) 分配新的 Thread 对象。
        Thread(Runnable target, String name) 分配新的 Thread 对象。

    实现步骤：
        1.创建一个Runnable接口的实现类
        2.在实现类中重写Runnable接口的run方法，设置线程任务
        3.创建一个Runnable接口的实现类对象
        4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        5.调用Thread类中的start方法，开启新的线程执行run方法5.调用Thread类中的start方法，开启新的线程执行run方法
 */
public class RunnableDemo {
    public static void main(String[] args) {
        // 3.创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        // 4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(run);
        // 5.调用Thread类中的start方法，开启新的线程执行run方法5.调用Thread类中的start方法，开启新的线程执行run方法
        t.start();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

实现Runnable接口创建多线程程序好处：

避免了单继承的局限性

一个类只能继承一个类，类继承了Thread类就不能继承其他的类，而实现了Runnable接口，还可以继承其他的类，实现其他的接口。
增强了程序的扩展性，降低了程序的耦合性(解耦)

实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离(解耦)

实现类中，重写了run方法：用来设置线程任务

创建Thread类对象，调用start方法：用来开启新线程

匿名内部类方式实现线程创建

package com.jz.thread;

/*
   匿名内部类作用：简化代码
       把子类继承父类，重写父类的方法，创建子类对象合成一步完成
       把实现类实现接口，重写接口中的方法，创建实现类对象合成一步完成
   匿名内部类的最终产物：子类/实现类对象，而这个类没有名字

   格式：
       new 父类/接口(){
           重复父类/接口中的方法
       };
*/
public class InnerClassThreadDemo {
   public static void main(String[] args) {
       // 线程的父类是Thread
       // 之前是 new MyThread().start();
       new Thread(){
           // 重写run方法，设置线程任务
           @Override
           public void run() {
               for (int i = 0; i < 20; i++) {
                   System.out.println(Thread.currentThread().getName() + "-->" + i);
               }
           }
       }.start();

       // 线程的接口Runnable
       // Runnable r = new RunnableImpl();
       /*
       Runnable r = new Runnable(){
           // 重写run方法，设置线程任务
           @Override
           public void run() {
               for (int i = 0; i < 20; i++) {
                   System.out.println(Thread.currentThread().getName() + "-->" + "程序员");
               }
           }
       };
       new Thread(r).start();
       */

       // 简化接口的方式
       new Thread(new Runnable(){
           // 重写run方法，设置线程任务
           @Override
           public void run() {
               for (int i = 0; i < 20; i++) {
                   System.out.println(Thread.currentThread().getName() + "-->" + "程序员");
               }
           }
       }).start();
   }
}

多线程原理

87.png

多线程内存图解

88.png

Thread类

常用方法：

获取线程名称

使用Thread类中的方法getName()

String getName() 返回该线程名称。
可以先获取到当前正在执行的进程，使用进程中的方法getName()获取线程的名称。

static Thread currentThread()返回对当前正在执行的线程对象的引用。

package com.jz.thread;

public class MyThread extends Thread{
    @Override
    public void run() {
        // 获取线程的名称
        // 方法一
        /*String name = getName();
        System.out.println(name);*/

        // 方法二
       /* Thread thread = Thread.currentThread();
        System.out.println(thread); // Thread[Thread-1,5,main]

        String name = thread.getName();
        System.out.println(name);*/

       // 链式编程
        String name = Thread.currentThread().getName();
        System.out.println(name);
    }
}

package com.jz.thread;

/*
    线程的名称:
        主线程：main
        新线程：Thread-0, Thread-1, Thread-2
 */
public class threadDemo01 {
    public static void main(String[] args) {
        // 创建Thread类的子类对象
        MyThread mt = new MyThread();
        // 调用start方法，开启新线程，执行run方法
        mt.start();

        new MyThread().start();
        new MyThread().start();

        // 链式编程
        String name = Thread.currentThread().getName();
        System.out.println(name);
    }
}

设置线程名称

使用Thread类中的方法setName(名字)

void setName(String name)改变线程名称，使之与参数 name 相同。
创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名称传递给父类，让父类(Thread)给子线程起一个名字

Thread(String name)分配新的 Thread 对象。

package com.jz.thread;

public class MyThread extends Thread{
    public MyThread(){

    }

    public MyThread(String name){
        super(name); // 把线程名称传递给父类，让父类(Thread)给子线程起一个名字
    }

    @Override
    public void run() {
        // 获取线程名称
        System.out.println(Thread.currentThread().getName());
    }
}

package com.jz.thread;

public class threadDemo01 {
    public static void main(String[] args) {
        // 开启多线程
        MyThread mt = new MyThread();
        mt.setName("小明");
        mt.start();

        // 开启多线程
        new MyThread("旺财").start();
    }
}

sleep 暂停

public static void sleep(long millis)：使当前正在执行的线程以指定的毫秒数在那听

package com.jz.thread;

public class SleepDemo {
    public static void main(String[] args) {
        for (int i = 0; i <= 60; i++) {
            System.out.println(i);

            // 使用Thread类的sleep方法让程序睡眠1秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程安全

多线程访问了共享的数据，会产生线程安全问题。

89.png

线程安全问题的代码实现

package com.jz.threadSafe;

/*
    实现卖票案例
 */
public class RunnableImpl implements Runnable{
    // 定义一个多个线程共享的票源
    private int ticket = 100;

    // 设置线程任务：卖票
    @Override
    public void run() {
        while(true){
            // 先判断票是否存在
            if(ticket > 0){
                // 票存在，卖票 ticket--
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖" + ticket);
                ticket --;
            }
        }
    }
}

package com.jz.threadSafe;

/*
    模拟卖票案例
    创建3个线程，同时开启，对共享的票进行出售
 */
public class TicketDemo {
    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        // 调用start开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

线程安全问题产生的原理

90.png

线程同步

解决线程安全问题：

完成同步的三种方式：

同步代码块
同步方法
锁机制

同步代码块

synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式：

synchronized(同步锁){
    需要同步操作的代码
}

注意：

通过代码块中的锁对象，可以使用任意的对象
必须保证多个线程使用的锁对象是同一个
锁对象作用：

把同步代码块锁住，只让一个线程在同步代码块中执行。

package com.jz.synchronizedDemo;

/*
    卖票案例出现了线程安全问题
    卖出了不存在的票和重复的票

 */
public class RunnableImpl implements Runnable{
    // 定义一个多个线程共享的票源
    private int ticket = 100;

    // 创建锁对象
    Object obj = new Object();

    // 设置线程任务：卖票
    @Override
    public void run() {
        while(true){
            // 同步代码块
            synchronized (obj){
                // 先判断票是否存在
                if(ticket > 0){
                    // 票存在，卖票 ticket--
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在卖" + ticket);
                    ticket --;
                }
            }
        }
    }
}

package com.jz.synchronizedDemo;

/*
    模拟卖票案例
    创建3个线程，同时开启，对共享的票进行出售
 */
public class TicketDemo {
    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        // 调用start开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

同步技术的原理：

91.png

同步方法

使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。

格式：

修饰符 synchronized 返回值类型 方法名(参数列表){
    可能会产生线程安全问题的代码(访问了共享数据的代码)
}

使用步骤：

把访问了共享数据的代码抽取出来，方法一个方法中
在方法上添加synchronized修饰符

package com.jz.synchronizedDemo2;

/*
     卖票案例出现了线程安全问题
     卖出了不存在的票和重复的票
 */
public class RunnableImpl implements Runnable{
    // 定义一个多个线程共享的票源
    private int ticket = 100;

    // 设置线程任务：卖票
    @Override
    public void run() {
        while(true){
            payTicket();
        }
    }

    /*
        定义一个同步方法
     */
    public synchronized void payTicket(){
        // 先判断票是否存在
        if(ticket > 0){
            // 票存在，卖票 ticket--
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖" + ticket);
            ticket --;
        }
    }
}

package com.jz.synchronizedDemo2;

/*
    模拟卖票案例
    创建3个线程，同时开启，对共享的票进行出售
 */
public class TicketDemo {
    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        // 调用start开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

同步方法原理:

同步方法也会把方法内部的代码锁住，只让一个线程执行。同步方法的锁对象就是实现类对象 new RunnableImpl()也就是this。

静态同步方法

package com.jz.synchronizedDemo2;

/*
     卖票案例出现了线程安全问题
     卖出了不存在的票和重复的票
 */
public class RunnableImpl implements Runnable{
    // 定义一个多个线程共享的票源
    private static int ticket = 100;

    // 设置线程任务：卖票
    @Override
    public void run() {
        while(true){
            payTicketStatic();
        }
    }

    /*
        定义一个同步方法
     */
    public static synchronized void payTicketStatic(){
        // 先判断票是否存在
        if(ticket > 0){
            // 票存在，卖票 ticket--
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖" + ticket);
            ticket --;
        }
    }
}

package com.jz.synchronizedDemo2;

/*
    模拟卖票案例
    创建3个线程，同时开启，对共享的票进行出售
 */
public class TicketDemo {
    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        // 调用start开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

静态的同步方法：

静态同步方法的锁对象是本类的class属性 --> class文件对象(反射)

Lock锁

java.util.concurrent.locks.Lock接口
Lock实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。

Lock接口中的方法：

void lock()：获取锁
void unclock()：释放锁

实现类：java.util.concurrent.locks.ReentrantLock implements Lock接口

使用步骤：

在成员位置创建一个ReentrantLock对象
在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

package com.jz.lockDemo;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
    卖票案例出现了线程安全问题
    卖出了不存在的票和重复的票
 */
public class RunnableImpl implements Runnable{
    // 定义一个多个线程共享的票源
    private int ticket = 100;

    //1.在成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();

    // 设置线程任务：卖票
    @Override
    public void run() {
        while(true){
            // 2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
            l.lock();

            // 先判断票是否存在
            if(ticket > 0){
                // 票存在，卖票 ticket--
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + "正在卖" + ticket);
                    ticket --;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally{
                    // 3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
                    l.unlock(); // 无论程序是否异常，都会把锁释放掉
                }
            }
        }
    }


    /*// 设置线程任务：卖票
    @Override
    public void run() {
        while(true){

            // 2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
            l.lock();

            // 先判断票是否存在
            if(ticket > 0){
                // 票存在，卖票 ticket--
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖" + ticket);
                ticket --;
            }

            // 3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
            l.unlock();
        }
    }*/
}

package com.jz.lockDemo;

/*
    模拟卖票案例
    创建3个线程，同时开启，对共享的票进行出售
 */
public class TicketDemo {
    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        // 调用start开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

线程状态

线程状态概述

92.png

Timed Waiting（计时等待）

93.png

进入到TimedWaiting(计时等待)：

使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态

package com.jz.waitAndNotifyDemo;

public class WaitAndNotifyTest {

    public static void main(String[] args) {
        // 创建锁对象，保证唯一
        Object obj = new Object();
        // 创建一个顾客线程(消费者)
        new Thread(){
            @Override
            public void run() {
               while(true){
                   //保证等待和唤醒只能有一个在执行,使用同步技术
                   synchronized (obj){
                       System.out.println("告知老板要的包子的种类和数量");
                       try {
                           obj.wait(3000);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       // 唤醒之后执行的代码
                       System.out.println("包子已经做好了，开吃！");
                       System.out.println("------------------");
                   }
               }
            }
        }.start();
    }
}

BLOCKED（锁阻塞）

94.png

Waiting（无限等待）

一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

95.png

package com.jz.waitAndNotifyDemo;

/*
    等待唤醒案例：线程之间的通信
        创建一个顾客线程(消费者)：告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入WAITING状态(无线等待)
        创建一个老板线程(生产者)：花了5秒做包子，做好包子之后，调用notify方法，唤醒顾客吃包子

    注意：
        顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
        同步使用的锁对象必须保证唯一
        只有锁对象才能调用 wait 和 notify 方法

    Object类中的方法
    void wait()
        在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
    void notify()
        唤醒在此对象监视器上等待的单个线程。
        会继续执行 wait 方法之后的代码
 */
public class WaitAndNotifyTest {

    public static void main(String[] args) {
        // 创建锁对象，保证唯一
        Object obj = new Object();
        // 创建一个顾客线程(消费者)
        new Thread(){
            @Override
            public void run() {
               while(true){
                   //保证等待和唤醒只能有一个在执行,使用同步技术
                   synchronized (obj){
                       System.out.println("告知老板要的包子的种类和数量");
                       try {
                           obj.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       // 唤醒之后执行的代码
                       System.out.println("包子已经做好了，开吃！");
                       System.out.println("------------------");
                   }
               }
            }
        }.start();

        // 创建一个老板线程(生产者)
        new Thread(){
            @Override
            public void run() {
                while(true){
                    // 花了5秒做包子
                    try {
                        Thread.sleep(5000); // 花了5秒做包子
                    } catch (InterruptedException e) { // 当阻塞方法收到中断请求的时候就会抛出InterruptedException异常
                        e.printStackTrace();
                    }

                    //保证等待和唤醒只能有一个在执行,使用同步技术
                    synchronized (obj){
                        System.out.println("做好包子之后");
                        // 做好包子后，调用notify方法，唤醒顾客吃包子
                        obj.notify();
                    }
                }
            }
        }.start();
    }
}

唤醒的方法：

notify()：如果有多个线程等待，随机唤醒一个
notifyAll()：唤醒所有等待的线程

等待唤醒机制

线程间通信

概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。

96.png

97.png

为什么要处理线程间通信：**

多个线程并发执行时，在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源：

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。

等待唤醒机制

解决线程间通信问题

wait：线程不再活动，不再参与调度，进入wait set种，因此不会浪费CPU资源，也不会取竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是"通知(notify)"在这个对象上等待的线程从wait set 种释放出来，重新进入到调度队列( ready queue)种。
notify：选取所通知对象的 wait set种的一个线程释放；例如，餐馆有空位置后，等待就餐最久的顾客最先入座。
notifyAll：释放所通知对象的 wait set 上的全部线程。

注意：

如果能获取到锁，线程从WAITING 状态变成 RUNNABLE 状态；
如果没有获得锁，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态。

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

wait方法与notify方法必须要由同一个锁对象调用。

对应的锁对象可以通过 notify 唤醒使用同一个锁对象调用的 wait 方法后的线程。
wait方法与notify 方法是属于Object类的方法的。

锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
wait 方法与 notify 方法必须在同步代码块或同步函数种使用。

必须要通过锁对象调用这2个方法。

案例

98.png

package com.jz.threadDemo;

/*
    资源类:包子类
    设置包子的属性
        皮
        陷
        包子的状态：有 true, 没有 false
 */
public class BaoZi {
    String pi;    // 皮
    String xian;    // 陷
    boolean flag = false; // 包子状态： 有 true， 没有 false, 默认没有
}

package com.jz.threadDemo;

/*
    包子铺类

    注意：
        包子铺线程和包子线程关系 --> 通信（互斥）
        必须同时同步技术保证两个线程只能有一个在执行
        锁对象必须保证唯一，可以使用包子对象作为锁对象
        包子铺类和吃货的类就需要把包子对象作为参数传递进来
            1. 需要在成员位置创建一个包子变量
            2. 使用带参数构造方法，为这个包子变量赋值
 */
public class BaoZiPu extends Thread{
    // 1. 需要在成员位置创建一个包子变量
    private BaoZi bz;

    // 2. 使用带参数构造方法，为这个包子变量赋值
    public BaoZiPu(BaoZi bz){
        this.bz = bz;
    }

    // 设置线程任务(run)：生产包子
    @Override
    public void run() {
        int count = 0;
        while(true){
            // 必须同时同步技术保证两个线程只能有一个在执行
            synchronized (bz){
                // 对包子状态进行判断
                if(bz.flag == true){
                    // 包子铺调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 被唤醒之后，包子铺生产包子
                // 增加一些趣味性：交替生产两种包子
                if(count % 2 == 0){
                    // 生产 薄皮三鲜馅包子
                    bz.pi = "薄皮";
                    bz.xian = "三鲜馅";
                }else{
                    // 生产 冰皮 牛肉大葱陷
                    bz.pi = "冰皮";
                    bz.xian = "牛肉大葱馅";
                }
                count++;
                System.out.println("包子铺正在生产："+bz.pi+bz.xian+"包子");
                // 生产包子需要3秒钟
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 包子铺生产好了包子
                // 修改包子的状态为true 有
                bz.flag = true;
                // 唤醒吃货线程，让吃货线程吃包子
                bz.notify();
                System.out.println("包子铺已经生产好了：" + bz.pi + bz.xian +"包子，吃货已经开始吃了");
            }
        }
    }
}

package com.jz.threadDemo;

public class ChiHuo extends Thread{
    // 1. 需要在成员位置创建一个包子变量
    private BaoZi bz;

    // 2. 使用带参数构造方法，为这个包子变量赋值
    public ChiHuo(BaoZi bz){
        this.bz = bz;
    }

    // 设置线程任务(run)：吃包子
    @Override
    public void run() {
        while(true){
            synchronized (bz){
                if(bz.flag == false){
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 被唤醒之后执行的代码，吃包子
                System.out.println("吃货正在吃："+bz.pi+bz.xian+"包子");
                // 吃货吃完包子
                bz.flag = false;
                bz.notify();
                System.out.println("吃货已经把："+bz.pi+bz.xian+"的包子吃完了，包子铺开始生产包子");
                System.out.println("--------------");
            }
        }
    }
}

package com.jz.threadDemo;

/*
    测试类
 */
public class Test {
    public static void main(String[] args) {
        // 创建包子对象
        BaoZi bz = new BaoZi();
        // 创建包子铺线程，开启，生产包子
        new BaoZiPu(bz).start();
        // 创建吃货线程，开启，吃包子
        new ChiHuo(bz).start();
    }
}

线程池

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无序反复创建线程而消耗过多资源。

底层原理：

99.png

package com.jz.threadDemo2;

// 2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
public class RunnableImpl implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "创建了一个新的线程");
    }
}

package com.jz.threadDemo2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
    线程池：JDK1.5之后提供的
    java.util.concurrent.Executors:线程池的工厂类，用来生成线程池
    Executors类中的静态方法：
        static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
        参数：
            int nThreads：创建线程池中包含的线程数量
        返回值：
            ExecutorService接口，返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接口接收(面向接口编程)
    java.util.concurrent.ExecutorsService：线程池接口
        用来从线程池中获取线程，调用start方法，执行线程任务
            submit(Runnable task) 提交一个 Runnable 任务用于执行
        关闭/销毁线程池的方法
            void shutdown()
    线程池的使用步骤：
        1.使用线程池的工厂类Executors里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
        3.调用ExecutorService中的方法submit，传递线程任务(实现类)，开启线程，执行run方法
        4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
 */
public class TreadPool {
    public static void main(String[] args) {
        //1.使用线程池的工厂类Executors里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        es.submit(new RunnableImpl());
        // 线程池会一直开启，使用完了线程，会自动把线程归还给线程池，线程可以继续使用
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());
        es.shutdown();
    }
}

多线程

多线程

并发与并行

线程与进程

线程调度

主线程

创建线程类

匿名内部类方式实现线程创建

多线程原理

多线程内存图解

Thread类

获取线程名称

设置线程名称

sleep 暂停

线程安全

线程安全问题的代码实现

线程安全问题产生的原理

线程同步

同步代码块

同步方法

静态同步方法

Lock锁

线程状态

线程状态概述

Timed Waiting（计时等待）

BLOCKED（锁阻塞）

Waiting（无限等待）

等待唤醒机制

线程间通信

等待唤醒机制

案例

线程池

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读