线程的常用方法，Object提供wait()等线程操作-生产者与消费者模式设计，枚举，线程的声明周期，线程池，单例设计模式，定时器

已于 2022-03-12 11:43:29 修改
阅读量277 收藏
点赞数
分类专栏： 线程 java基础 设计模式 文章标签： 设计模式 单例模式 java
于 2022-03-09 22:28:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45800201/article/details/123385665
版权

目录

一、线程的常用方法

1.1 方法的介绍

在这里插入图片描述

  1. 定义一个线程类
package qf22020309_consumer_producer;

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

1.2 stop终止该线程

package qf22020309_consumer_producer;

public class Demo01 {
    public static void main(String[] args) {
        MyThread01 mt1 = new MyThread01();
        mt1.start();
        //停止线程，不会执行停止
        mt1.stop();
        MyThread01 mt2 = new MyThread01();
        mt2.start();
    }
}

1.2 join等待线程执行完终止

package qf22020309_consumer_producer;

public class Demo03 {
    public static void main(String[] args) throws InterruptedException {
        MyThread03 mt1 = new MyThread03();
        mt1.start();
        mt1.join(); //等待mt1线程执行完再终止
        MyThread03 mt2 = new MyThread03();
        mt2.start();
    }
}

1.3 yield礼让线程

package qf22020309_consumer_producer;

public class Demo02 {
    public static void main(String[] args) {
        MyThread02 mt1 = new MyThread02();
        mt1.yield();
        mt1.start(); //礼让mt2线程执行（不一定礼让成功）
        MyThread02 mt2 = new MyThread02();
        mt2.start();
    }
}

二、Object提供wait()等线程操作-生产者与消费者模式设计

2.1 方法的介绍

在这里插入图片描述

2.2 案例应用

  1. 问题：生产者做一个米饭，必须等待消费者吃完才能继续生产，而消费者必须等待生产者生产出来才能吃饭
  2. rice米饭对象
package qf22020309_work.Demo04;

public class Rice {
    private String money;
    private String weight;
    private Boolean flag = false;

    public Rice() {
    }

    public Rice(String money, String weight) {
        this.money = money;
        this.weight = weight;
    }

    public String getMoney() {
        return money;
    }

    public void setMoney(String money) {
        this.money = money;
    }

    public String getWeight() {
        return weight;
    }

    public void setWeight(String weight) {
        this.weight = weight;
    }

    public Boolean getFlag() {
        return flag;
    }

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

    @Override
    public String toString() {
        return "Rice{" +
                "money='" + money + '\'' +
                ", weight='" + weight + '\'' +
                ", flag=" + flag +
                '}';
    }
}
  1. 生产者
package qf22020309_work.Demo04;

public class MyProducer extends Thread{
    private Rice rice;

    public MyProducer(Rice rice) {
        this.rice = rice;
    }

    @Override
    public void run() {
        while (true){
            synchronized (rice){
                try {
                    Thread.sleep(2500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(rice.getFlag()){
                    try {
                        rice.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                rice.setMoney("12元");
                rice.setWeight("5两米饭");
                rice.setFlag(true);
                System.out.println("我在做着"+rice.getMoney()+"，重"+rice.getWeight()+"的米饭");
                rice.notify();
            }
        }
    }
}
  1. 消费者
package qf22020309_work.Demo04;

public class MyConsumer extends Thread {
    private Rice rice;

    public MyConsumer(Rice rice) {
        this.rice = rice;
    }

    @Override
    public void run() {
        while (true){
            synchronized (rice){
                try {
                    Thread.sleep(2500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(!rice.getFlag()){
                    try {
                        rice.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("我在吃"+rice.getMoney()+"，重"+rice.getWeight()+"的米饭");
                rice.setMoney(null);
                rice.setWeight(null);
                rice.setFlag(false);
                rice.notify();
            }
        }
    }
}
  1. 测试类
package qf22020309_work.Demo04;

public class Test01 {
    public static void main(String[] args) {
        Rice rice = new Rice();
        new MyProducer(rice).start();
        new MyConsumer(rice).start();
    }
}

2.3 生产者与消费者设计总结

  1. wait()方法是让自身的线程等待，给其它的线程（需锁的相同对象）有抢夺cpu的执行权的权力
  2. notify是通知此监听器（相同对象）对象上等待的单个线程执行，notifyAll是通知此监听器（相同对象）对象上等待的全部线程执行
  3. 案例总结：
  4. 该案例没有使用资源共享，而只使用了synchronized锁的对象
  5. 两者锁的对象相同，消费者必须等待生产者生产出来了才能吃饭，这个等待时间是无限的，所以使用wait()，礼让等待生产者线程生产，生产者相同
  6. 等待生产者做好了，再发通知，消费者相同，所用使用notify()
  7. 必须锁的相同的对象

三、枚举

3.1 概念

  1. 枚举就是用于表示一些固定的值，可以使用枚举项类进行
  2. 访问修饰 enum 枚举类的名称{
  3.      枚举项
  4. }

3.2 特点

  1. 每一个枚举类都是Enum的子类
  2. 每一个枚举项都是一个对象
  3. 枚举类只能有私有的构造
  4. 枚举项一般都是写在第一行，每个枚举项必须重写本类中的抽象方法，可以定义成员变量
package qf22020309_enum.Demo01;

public enum MyEnum {
    re {
        @Override
        public void add() {

        }
    }, rs {
        @Override
        public void add() {

        }
    };
    private String name;

    public String name1;

    MyEnum() {
    }

    private MyEnum(String name, String name1) {
        this.name = name;
        this.name1 = name1;
    }

    public static void get() {
    }

    public void get1() {
    }

    public abstract void add();
}

四、线程的声明周期

4.1 线程状态图

  1. 线程的生命周期有几种状态
  2. 获取状态：Thread.State
    在这里插入图片描述

4.2 6种状态

  1. NEW：至今尚未启动的线程
  2. RUNNABLE：正在java虚拟机中执行的线程
  3. BLOCKED：受阻塞并等待某个监视器锁的线程
  4. WAITING：无限期的等待另一个线程去执行操作的线程
  5. TIMED_WAITING：等待另一个线程去执行，取决于指定等待的时间的线程
  6. TERMINATED：已退出的线程处于这种状态
package qf22020308_thread.Demo03;

public class Demo02 {
    public static void main(String[] args) {
        Thread thread = new Thread();
        System.out.println(thread.getState());
        thread.start();
        System.out.println(thread.getState());
        /**
         * 结果：
         * NEW
         * RUNNABLE
         */
    }
}

五、线程池

5.1 简介

  1. 没有线程池的问题：A.需要反复的创建销毁 B.大量的的线程不便于管理 C.遭到破坏性较大的的任务，可能会导致线程任务失败
  2. 线程池：A.jdk提供的线程池，可以使用线程池来的对线程进行统一的管理 B. 避免反复的创建和销毁 C. 遇到破坏性较大的任务时，线程任务执行失败后，线程池会重新派线程去执行为，确保任务的执行操作

5.2 创建线程池对象的方法

  1. Executors 线程工具类调用
  2. 调用单一线和多线程对象获取方法图在这里插入图片描述
  3. 提交任务有返回值和无返回值在这里插入图片描述

5.2 案例

  1. 单一线程有返回值-代码实例
package qf22020309_ThreadPool.Demo01;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        return 520;
    }
}


package qf22020309_ThreadPool.Demo01;

import java.util.concurrent.*;

/**
 * 单个线程加入线程池并启动线程
 */
public class Test01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable mc = new MyCallable();
        ExecutorService es = Executors.newSingleThreadExecutor();
        Future<Integer> submit = es.submit(mc);
        System.out.println(submit.get());
    }
}
  1. 多线程无返回值-代码实例
package qf22020309_ThreadPool.Demo02;

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("runnable");
    }
}


package qf22020309_ThreadPool.Demo02;

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

public class Test02 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService es = Executors.newFixedThreadPool(3);
        es.submit(new MyRunnable());
        es.submit(new MyRunnable());
        es.submit(new MyRunnable());
        es.submit(new MyRunnable());
    }
}

六、单例设计模式

  1. 单例设置模式的特点：有且仅实例化一个对象
  2. 使用场景：加载配置信息、工具类、spring、容器对象等
  3. 私有属性、私有构造方法、公有的方法

6.1 懒汉设计模式

  1. 优点：项目启动时，不可能出现卡顿现象
  2. 缺点：没有锁的机制，多线程不安全
  3. 定义类
package qf22020309_design.Demo01;

public class MyDesign {
    //私有属性
    private static MyDesign md;

    //私有构造方法
    private MyDesign() {
    }

    //公开拿取对象的方法
    public static MyDesign getInstance() {
        if (md == null) {
            md = new MyDesign();
        }
        return md;
    }
}
  1. 测试类
package qf22020309_design.Demo01;

/**
 * 懒汉设计模式：随用随创建
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println(MyDesign.getInstance());
        System.out.println(MyDesign.getInstance());
    }
}

6.2 饿汉设计模式

  1. 优点：没有锁的机制、效率比较高
  2. 缺点：项目启动时就创建对象，项目可能会出现卡顿，多线程不安全
  3. 定义类
package qf22020309_design.Demo02;

public class MyDesign {
    //加载开始创建好的对象
    private static MyDesign p = new MyDesign();
    //私有构造方法
    private MyDesign(){};
    //获取对象
    public static MyDesign getInstance(){
        return p;
    }
}
  1. 测试类
package qf22020309_design.Demo02;

/**
 * 饿汉设计模式：创建好
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println(MyDesign.getInstance());
        System.out.println(MyDesign.getInstance());
    }
}

6.3 双重锁设计模式

  1. 代码实例
package qf22020309_design.Demo04;

public class Utils {
    private static Utils utils;

    private Utils() {
    }
    public static synchronized Utils GetInstance(){
        if(utils==null){
            synchronized (Utils.class){
                if(utils==null){
                    return utils = new Utils();
                }
            }
        }
        return utils;
    }
}

6.4 内部类模式

package qf22020309_design.Demo04;

public class Utils {

    private Utils() {
    }

    static class Instance {
        static final Utils UTILS = new Utils();
    }

    public static Utils getInstance() {
        return Instance.UTILS;
    }
}

七、定时器

7.1 设计定时读取文件的内容

  1. 自定义类
package qf22020309_work.Demo01;

import java.io.*;
import java.util.TimerTask;

public class MyTask extends TimerTask {

    @Override
    public void run() {
        InputStreamReader isr = null;
        try {
            isr = new InputStreamReader(new FileInputStream("D:\\test.txt"));
            int temp;
            char[] ch = new char[1024*1024];
            while ((temp=isr.read(ch))!=-1){
                System.out.print(new String(ch, 0, temp));
            }
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(isr!=null){
                    isr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
  1. 测试类
package qf22020309_work.Demo01;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
import java.util.Timer;

/**
 * 定时器
 * 定时读取文件内容
 */
public class Demo01 {
    public static void main(String[] args) throws ParseException {
        //自定义类MyTask实现TimerTask类
        //TimerTask是Runnable的实现类
        MyTask mt = new MyTask();
        //实例化一个Timer对象
        Timer t = new Timer();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入读取文件的时间：");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date parse = sdf.parse(sc.nextLine());
        //传入执行对象、执行的时间（也可以添加重复执行间隔时间）
        t.schedule(mt, parse);
    }
}
IT阿生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
线程操作实例——生产者及消费者
qq_46224953的博客
05-13 472
线程操作案例——生产者及消费者 线程操作中有一个经典案例程序——生产者消费者问题，即生产者不断生产，消费者不断取走生产者生的产品 首先定义一个保存信息的类Info.java class Info { //信息默认值 private String name = "李兴华"; private String content = "Java讲师"; public String getName(){ return name; } public
并发编程（6）Object类对线程的操作（wait/notify/notifyAll）
蜗牛不怕慢的博客
03-16 571
Java Object 类也提供了线程操作的方法，下面我们来了解一下 .1)wait wait方法为Object类的方法，主要用于线程间通信，调用wait()方法的时候，线程会放弃对象锁（sleep 不会放弃对象锁），进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定。 注：因为wait方法放弃了对象锁，所以同步代码块可以被访问。
Thread和Object类中关于线程的相关方法
qq_38217393的博客
05-25 333
Thread和Object类中线程的7个重要方法概览 类 方法名称 简介 Thread sleep相关 相关表示sleep所有的重载方法,参数不同，实际作用大同小异 Thread join() 等待其它线程执行完毕 Thread yield() 放弃已经获得的cpu资源 Thread currentThread() 获取当前线程的引用 Thread start()、run() 启动线程相关 Thread interrtupt相关 中断线程相关 Thread stop(
线程操作案例——生产者和消费者
chaoyv
06-16 200
本章目标加深线程同步操作的理解了解Object类中对线程的支持方法   实例要求在线程操作中有一个经典的案例程序 —— 生产者和消费者问题，生产者不断生产，消费者不断取走生产者生产的产品。  在图中非常清楚的表示出，生产者生产出信息之后将其放到一个区域之中，之后消费者从此区域里取出数据   程序的问题但是在本程序中因为牵涉到线程运行的不确定性，所以会存在以下两点问题：——1、假设生产...
java面试题-object中线程操作方法
songfelicity的博客
02-25 1065
8.下面那个方法不是Object类所提供的线程操作方法？ A. public final void wait() throws InterruptedException； B. public final void notify()； C. public final void notifyAll()； D. public String toString() ...
java—多线程的通信、生产者与消费者模式
12-21
本文将深入探讨Java中的线程通信、生产者-消费者模式，并解释相关的关键概念。 一、线程通信 线程通信是多线程环境下解决线程间数据交互的方式。在Java中，主要通过`wait()`, `notify()`, `notifyAll()`三个方法...
Java多线程之线程通信生产者消费者模式及等待唤醒机制代码详解
08-29
生产者消费者模式是多线程编程中的一种常见模式，它描述了生产者和消费者的关系，生产者负责生产资源，而消费者则负责消费资源。在这个模式中，生产者和消费者都是独立的线程，它们之间通过共享资源进行通信。 二、...
C++ 多线程通信方式简介并结合生产者-消费者模式代码实现
10-15
在C++编程中，多线程通信是一种关键的...生产者-消费者模式是一种常用的线程同步策略，能够有效地解决数据生产和消费的问题。在实际编程中，理解并熟练掌握这些概念和技术，对于提升C++多线程程序的设计能力至关重要。
浅谈java线程中生产者与消费者的问题
09-02
Java线程中的生产者与消费者问题是多线程编程中一个经典的设计模式，它涉及到线程间的同步和通信。这个问题的核心是解决如何在一个有限容量的仓库（通常称为缓冲区）中，使得生产者线程和消费者线程能有效地协同工作...
Java多线程并发生产者消费者设计模式实例解析
08-19
Java多线程并发生产者消费者设计模式实例解析 多线程并发生产者消费者设计模式是Java并发...这个设计模式实例展示了Java多线程并发生产者消费者设计模式的实现细节，包括同步机制、Thread安全和多线程编程等知识点。
Object 关于线程的几个方法
Liu_York的博客
02-21 834
1 sleep() : 当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行, 同时sleep函数不会释放锁资源.   2 yield()： 只是使当前线程重新回到可执行状态，所以执行yield()线程有可能在进入到可执行状态后马上又被执行.   sleep和yield的区别在于, sleep可以使优先级低的线程得到执行的机会, 而yield只能使同优先级的线程...
Object类中提供的线程相关方法的作用
hzyao的博客
09-23 427
notify() 方法：唤醒在此对象监视器上等待的单个线程。 notifyAll() 方法：唤醒在此对象监视器上等待的所有线程。 wait() 方法：线程从处于等待状态，直到其他线程调用此对象的notify() 方法和notifyAll() 方法。 wait(long timeout) 方法：线程从处于等待状态，直到其他线程调用此对象的notify() 方法和notifyAll() 方法，或...
线程操作实例 ------ 生产者及消费者
Rachel_pan的博客
10-25 252
文章目录一 、实例引出二 、程序的基本实现三 、解决问题1 ------- 加入同步，保证数据一致四 、Object类对线程的支持 ------ 等待与唤醒五 、解决问题2 ------ 加入等待与唤醒 一 、实例引出   在线程操作中有一个经典案例程序，即生产者和消费者，生产者不断生产，消费者不断取走生产者生产的产品 二 、程序的基本实现 观察以下程序，会产生什么问题： 1 、定义一个保...
Java 多线程编程5---线程操作案例：生产者和消费者
小蓝的博客
07-16 401
在线程操作中有一个经典的案例，即生产者和消费者问题。生产者不断生产，消费者不断取走生产者生产的产品。即生产者生产出的产品放到一个区域中，消费者从该区域中取走产品.如下图所示。 在上面的方式中，如果使用多线程运行，由于多线程运行的不确定性，会存在以下问题: 假设生产者线程刚向数据存储空间中加入该信息的名称，还没有加入信息的内容，程序就切换到了消费者线程，消费者线程把信息的名称和上一个信息的...
java多线程之Object中关于线程的方法
qq_34785575的博客
11-19 1074
java多线程之Object中关于线程的方法 友情提示：因为方法只是用来展示代码的，有些是伪代码。所以创建方法的时候一定要有含义，不能像我一样只是一个字母就代替了。（本文档种方法纯属比较懒） 在java中Object是所有类的父类，所以Object的方法能被所有类使用，在Object中提供了许多关于线程的类。我们来逐一的看一下 1.wait()函数 wait()函数被调用时该线程会被阻塞挂起，除非两种情况可以解除挂起。一.其他线程调用了该共享对象的notify()或者是notifyAll()方法。二.其他线
Java多线程 | 操作线程的方法详解
最新发布
devops
08-05 454
操作线程的常用方法详解
java基础面试题-高级10道
songfelicity的博客
02-25 2738
1.使用Runtime类的那个方法，可以释放垃圾内存？ A. exec() B. run() C. invoke() D. gc() 正确答案 2.下列那个关键字通常用来为对象加锁，从而使得对对象的访问是排他的？ A. serialize B. transient C. synchronized D. static 正确答案 3.如果要为对象回收做收尾操作，则应该覆写O...
为什么线程的操作方法（wait()、notify()、notifyAll()）要定义在Object类中呢？
weixin_36509612的博客
08-17 1455
如果对象调用了wait方法就会使持有该对象的线程把该对象的控制权交出去，然后处于等待状态（执行该方法之前，必须先获得锁；执行该方法后，会释放锁，使线程等待，进入阻塞队列） 如果对象调用了notify方法就会通知某个正在等待这个对象的控制权的线程可以继续运行 如果对象调用了notifyAll方法就会通知所有等待这个对象控制权的线程继续运行 对于该问题，因为这些方法在操作同步线程时，都必须...
Java Object 线程方法
wwhhff11
03-17 985
sleep()使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常。 例如有两个线程同时执行(没有synchronized)一个线程优先级为MAX_PRIORITY，另一个为MIN_PRIORITY，如果没有Sleep()方法，只有高优先级的线程执行完毕后，低
Java多线程：生产者消费者问题详解与解决方案
Java多线程中的“生产者与消费者”问题是一个经典案例，它涉及到两个或多个线程共享一个具有固定容量的缓冲区，其中一个是生产者（Producer），负责生成数据并放入缓冲区，另一个或多个是消费者（Consumer），负责从...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

IT阿生

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

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

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

打赏作者

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

抵扣说明：

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

余额充值