JAVA之线程状态和线程池

最新推荐文章于 2022-03-24 10:30:03 发布

MilkBerg

最新推荐文章于 2022-03-24 10:30:03 发布

阅读量651

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/weixin_43153854/article/details/103038770

版权

java 专栏收录该内容

42 篇文章 0 订阅

订阅专栏

一.各种线程状态

在这里插入图片描述

Timed Waiting线程状态
锁阻塞状态
Waiting状态（等待唤醒）

二.Waiting状态详解

等待唤醒案例代码实现

package WaitAndNotify;

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

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

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

 */
public class Demo01WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        // 创建一个顾客线程（消费者）,使用匿名内部类
        new Thread() {
            @Override
            public void run() {
                //死循环，一直等着买包子
                while (true) {
                    //保证等待和唤醒只能有一个在执行,需要使用同步技术
                    synchronized (obj) {
                        System.out.println("告知老板要的包子的种类和数量");
                        //用锁对象调用wait方法
                        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);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj) {
                        //做好包子之后调用notify方法，唤醒顾客吃包子
                        System.out.println("老板5秒之后，告知顾客");
                        obj.notify();
                    }
                }
            }
        }.start();
    }
}

带参的wait方法和notify方法
进入到TimeWaiting(计时等待)有俩种方法
1.使用sleep（Long m）方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
2.使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态

唤醒的方法：
void notify()唤醒在此对象监视器上等待的单个线程。
void notifyAll() 唤醒在此对象监视器上等待的所有线程。

package WaitAndNotify;

/*
    进入到TimeWaiting(计时等待)有俩种方法
    1.使用sleep（Long m）方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
    2.使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态

    唤醒的方法：
     void notify()唤醒在此对象监视器上等待的单个线程。
     void notifyAll() 唤醒在此对象监视器上等待的所有线程。
 */
public class Demo02WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        // 创建一个顾客线程（消费者）,使用匿名内部类
        new Thread() {
            @Override
            public void run() {
                //死循环，一直等着买包子
                while (true) {
                    //保证等待和唤醒只能有一个在执行,需要使用同步技术
                    synchronized (obj) {
                        System.out.println("顾客1告知老板要的包子的种类和数量");
                        //用锁对象调用wait方法
                        try {
                            obj.wait(5000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了，顾客1可以吃了！");
                        System.out.println("--------------------------");
                    }
                }
            }
        }.start();

        // 创建一个顾客线程（消费者）,使用匿名内部类
        new Thread() {
            @Override
            public void run() {
                //死循环，一直等着买包子
                while (true) {
                    //保证等待和唤醒只能有一个在执行,需要使用同步技术
                    synchronized (obj) {
                        System.out.println("顾客2告知老板要的包子的种类和数量");
                        //用锁对象调用wait方法
                        try {
                            obj.wait(5000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了，顾客2可以吃了！");
                        System.out.println("--------------------------");
                    }
                }
            }
        }.start();

        // 创建一个老板线程（生产者）,使用匿名内部类
        new Thread() {
            @Override
            public void run() {
                //死循环，一直做包子
                while (true) {
                    //花了5秒做包子
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj) {
                        //做好包子之后调用notify方法，唤醒顾客吃包子
                        System.out.println("老板5秒之后，告知顾客");
//                        obj.notify();//如果有多个等待线程，随机唤醒一个
                        obj.notifyAll();//唤醒所有等待线程
                    }
                }
            }
        }.start();
    }
}

三.等待唤醒机制

线程间的通信
等待唤醒机制

在这里插入图片描述

等待唤醒机制代码实现

需求分析
在这里插入图片描述
代码实现

BaoZi类

package WaitAndNotify02;

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

BaoZiPu类

package WaitAndNotify02;

/*
    生产者（包子铺）类：是一个线程类，可以继承Thread
    设置线程任务（run）：生产包子
    对包子的状态进行判断
    true：有包子
           包子铺调用wait方法进入等待
    false：没有包子
           包子铺生产包子
           增加一些趣味性：交替生产俩种包子
                         有俩种状态（i%2==0）
           包子铺生产好了包子
           修改包子的状态为true
           唤醒吃货线程，让吃货线程吃包子

    注意：
        包子铺线程和包子线程的关系-->通信（互斥）
        必须同时同步技术保证俩个线程只能有一个在执行
        锁对象必须保证唯一，可以使用包子对象作为锁对象
        包子铺类和吃货类就需要把包子对象作为参数传递进来
            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 {
                    sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //包子铺生产好了包子
                // 修改包子的状态为true
                bz.flag = true;
                //唤醒吃货线程，让吃货线程吃包子
                bz.notify();
                System.out.println("包子铺已经生产好了：" + bz.pi + bz.xian + "包子");
            }

        }
    }
}

ChiHuo类

package WaitAndNotify02;

/*
    消费者（吃货）类：是一个线程类，可以继承Thread
    设置线程任务（run）:吃包子
    对包子的状态进行判断
    false:没有包子
        吃货调用wait方法进入等待状态
    true：有包子
        吃货吃包子
        吃货吃完包子
        修改包子的状态为false没有
        吃货唤醒包子铺线程，生产包子
 */
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) {
                    //吃货调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                //被唤醒之后执行的代码，吃包子
                System.out.println("吃货正在吃：" + bz.pi + bz.xian + "的包子");
                //吃货吃完包子
                //修改包子的状态为false没有
                bz.flag = false;
                //吃货唤醒包子铺线程，生产包子
                bz.notify();
                System.out.println("吃货已经把：" + bz.pi + bz.xian + "的包子吃完了，包子铺开始生产包子");
                System.out.println("-----------------------------------");
            }
        }
    }
}

Demo测试类

package WaitAndNotify02;

/*
    测试类：
    包含main方法，程序执行的入口，启动程序
    创建包子对象
    创建包子铺线程，开启，生产包子；
    创建吃货线程，开启，吃包子
 */
public class Demo {
    public static void main(String[] args) {
        //创建包子对象
        BaoZi bz = new BaoZi();
        //创建包子铺线程，开启，生产包子。
        new BaoZiPu(bz).start();
        //创建吃货线程，开启，吃包子
        new ChiHuo(bz).start();
    }
}

四.线程池

线程池概念
如果并发的线程数量很多，并且每一个线程都是执行一个时间很短的任务就结束了，频繁创建线程会大大降低系统的效率，频繁创建线程和销毁线程需要时间。使用线程池可以解决这个问题。

工作原理：
线程池的使用
线程池是JDK1.5之后提供的
java.util.concurrent.Executors：线程池的工厂类，用来生产线程池
Executors类中的静态方法：
static ExecutorService newFixedThreadPool(int nThreads)创建一个可重用固定线程数的线程池。
参数：
int nThreads:创建线程池中包含的线程数量
返回值：
ExecutorService接口，返回的是ExecutorService接口的实现类对象，我们可以使用ExecutorService接口接收（面向接口编程）
java.util.concurrent.ExecutorService：线程池接口
用来从线程池中获取线程，调用start方法，执行线程任务
submit(Runnable task)
提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
关闭/销毁线程池的方法
shutdown()
启动一次顺序关闭，执行以前提交的任务，但不接受新任务。

线程池的使用步骤：
1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
3.调用ExecutorService中的方法submit传递线程任务（实现类），开启线程，执行run方法
4.调用ExecutorService中的方法shutdown销毁线程池（不建议执行）

代码实现：
ThreadPool类

package ThreadPool;

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.ExecutorService：线程池接口
        用来从线程池中获取线程，调用start方法，执行线程任务
            submit(Runnable task)
          提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
        关闭/销毁线程池的方法
            shutdown()
          启动一次顺序关闭，执行以前提交的任务，但不接受新任务。

    线程池的使用步骤：
        1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        2.创建一个类，实现Runnable接口，重写run方法，设置线程任务
        3.调用ExecutorService中的方法submit传递线程任务（实现类），开启线程，执行run方法
        4.调用ExecutorService中的方法shutdown销毁线程池（不建议执行）
 */
public class Demo01ThreadPool {
    public static void main(String[] args) {
        //1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //3.调用ExecutorService中的方法submit传递线程任务（实现类），开启线程，执行run方法
        es.submit(new RunnableImpl());//pool-1-thread-2创建了一个新的线程
        //线程池会一直开启，使用完了线程，会自动把线程归还给线程池，线程可以继续使用
        es.submit(new RunnableImpl());//pool-1-thread-1创建了一个新的线程
        es.submit(new RunnableImpl());//pool-1-thread-2创建了一个新的线程

        //4.调用ExecutorService中的方法shutdown销毁线程池（不建议执行）
        es.shutdown();
        //es.submit(new RunnableImpl());//会抛出异常，线程池已经没有了，不能再获取线程
    }
}

实现类

package ThreadPool;

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

MilkBerg

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA之线程状态和线程池

一.各种线程状态Timed Waiting线程状态锁阻塞状态Waiting状态（等待唤醒）二.Waiting状态详解等待唤醒案例代码实现package WaitAndNotify;/* 等待唤醒案例：线程之间的通信创建一个顾客线程（消费者）：告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入到WAITING状态（无限等待...
复制链接

扫一扫