【Java Se】常用工具类之多线程

简介: 到多线程这一块说明我们【Java Se】专栏就快结束了,感谢一直看过来的兄弟。多线程其实是非常复杂的,我们只是学一个入门,知道有这么个东西并且怎么运用它!

前言


到多线程这一块说明我们【Java Se】专栏就快结束了,感谢一直看过来的兄弟。多线程其实是非常复杂的,我们只是学一个入门,知道有这么个东西并且怎么运用它!


初始多线程

在学习线程之前你得先知道什么是进程,以及进程与线程的关系与区别。


当一个程序被运行时,就开启了一个进程, 比如启动了QQ,网易云。而一个进程内可分为多个线程,一个线程其实就是一个指令流,cpu调度的最小单位,由cpu一条一条执行指令。


操作系统调度的最小任务单位其实不是进程,而是线程。进程和线程是包含关系。在计算机中,我们把一个任务称为一个进程,浏览器就是一个进程,视频播放器是另一个进程,类似的,音乐播放器和Word都是进程。


某些进程内部还需要同时执行多个子任务。例如,我们在使用Word时,Word可以让我们一边打字,一边进行拼写检查,同时还可以在后台进行打印,我们把子任务称为线程。


进程和线程的关系就是:一个进程可以包含一个或多个线程,但至少会有一个线程。


线程的创建

创建一个线程有两种方法:


1.创建一个Thread类,或者一个Thread子类的对象

2.创建一个实现Runnable接口的类的对象


接下来我们看看如何具体用这两个方法创建线程,这也是本节的重点之处。


Thread类创建线程

用Thread创建一个线程是创建一个新的类,该类继承 Thread 类,然后创建一个该类的实例。


继承Thread类必须重写 run() 方法,该方法是新线程的入口点。它也必须调用 start() 方法才能执行。


我们先看看Thread类的一些重要方法:


方法 说明

Thread() 创建一个线程对象

Thread(String name) 创建一个具有指定名称的线程对象

Thread(Runnable target) 创建一个基于Runnable接口实现类的线程对象

Thread(Runnable target,Stringname) 创建一个基于Runnable接口实现类,并且具有指定名称的线程对象

public void run() 线程相关的代码写在该方法中,一般需要重写

public void start() 启动线程的方法

public static void sleep(long m) 线程休眠m毫秒的方法

public void join() 优先执行调用join()方法的线程

接下来看一下代码案例:

public class Main {
    public static void main(String[] args) {
        //创建一个线程对象
        TestThread1 thread1 = new TestThread1();
        //调用start方法
        thread1.start();
        //main线程,主线程
        for (int i = 0; i < 50; i++) {
            System.out.println("main主线程" + i);
        }
    }
}
//创建线程方式一:继承Thread类,重写run()方法,调用start()开启线程
class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 50; i++) {
            System.out.println("白白创建的线程"+i);
        }
    }
}


Runnable接口创建线程

使用Runnable来创建线程,创建一个实现 Runnable 接口的类。


为了实现 Runnable,一个类只需要执行一个方法调用 run(),声明如下:

public void run()


你可以重写该方法,重要的是理解的 run() 可以调用其他方法,使用其他类,并声明变量,就像主线程一样。


在创建一个实现 Runnable 接口的类之后,你可以在类中实例化一个线程对象。


新线程创建之后,你调用它的 start() 方法它才会运行。


当线程被构造时,需要的代码和数据通过一个对象作为构造函数实参传递进去,这个对象就是实现了Runnable接口的类的实例。


事实上,几乎所有多线程应用都可用Runnable接口方式,接下来看一个代码案例:

class MyThead1 implements Runnable{  //这就是一个多线程的操作类
    private String name;
    public MyThead1(String name) { //定义构造方法
        this.name = name;
    }
    @Override
    public void run(){ //覆写run方法,作为线程的主体操作方法
        for (int x = 0; x <50; x++) {
            System.out.println(this.name+"->"+x);
        }
    }
}
public class Main{
    public static void main(String[] args) {
        MyThead1 myThead1=new MyThead1("白白帅");
        MyThead1 myThead2=new MyThead1("白白牛");
        MyThead1 myThead3=new MyThead1("白白黑");
        new Thread(myThead1).start();
        new Thread(myThead2).start();
        new Thread(myThead3).start();



线程的状态

线程有以下几种状态:新建状态,就绪状态,运行状态,阻塞状态,死亡状态


新建状态


使用 new 关键字和 Thread 类或其子类建立一个线程对象后,该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。


就绪状态


当线程对象调用了start()方法之后,该线程就进入就绪状态。就绪状态的线程处于就绪队列中,要等待JVM里线程调度器的调度。


运行状态


如果就绪状态的线程获取 CPU 资源,就可以执行 run(),此时线程便处于运行状态。处于运行状态的线程最为复杂,它可以变为阻塞状态、就绪状态和死亡状态。


阻塞状态


如果一个线程执行了sleep(睡眠)、suspend(挂起)等方法,失去所占用资源之后,该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种:


等待阻塞:运行状态中的线程执行 wait() 方法,使线程进入到等待阻塞状态。


同步阻塞:线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。


其他阻塞:通过调用线程的 sleep() 或 join() 发出了 I/O 请求时,线程就会进入到阻塞状态。当sleep() 状态超时,

join() 等待线程终止或超时,或者 I/O 处理完毕,线程重新转入就绪状态。


死亡状态


一个运行状态的线程完成任务或者其他终止条件发生时,该线程就切换到终止状态。


Thread类方法

Thread类有许多方法,我们介绍几种常用的方法。


start()


这个方法的作用就是通知线程规划器此现场可以运行了。

要注意,调用start方法的顺序不代表线程启动的顺序,也就是cpu执行哪个线程的代码具有不确定性。。


run()


这个方法是线程类调用start后执行的方法,如果在直接调用run而不是start方法,那么和普通方法一样,没有区别。


isAlive()


是判断当前线程是否处于活动状态。活动状态就是已经启动尚未终止。


getPriority()和setPriority(int newPriority)


首先每一个 Java 线程都有一个优先级,这样有助于操作系统确定线程的调度顺序。


Java 线程的优先级是一个整数,其取值范围是 1 (Thread.MIN_PRIORITY ) - 10 (Thread.MAX_PRIORITY )。


默认情况下,每一个线程都会分配一个优先级 NORM_PRIORITY(5)。


具有较高优先级的线程对程序更重要,并且应该在低优先级的线程之前分配处理器资源。但是,线程优先级不能保证线程执行的顺序,而且非常依赖于平台。


这两个方法是用于获取当前和设置线程的优先级。优先级高的线程得到的cpu多。也就是说,两个等待的线程,优先级高的线程容易被cpu执行。


默认情况下,线程的优先级是5。线程的优先级分为1~10等级。


interrupt()


使用这个方法并不会中断线程。实际上,调用interrupt实际作用是,在线程受到阻塞时抛出一个中断信号,这样线程就得以退出阻塞状态。


join方法


join方法会使得调用join方法的线程(myThread1线程)所在的线程(main线程)无限阻塞,直到调用join方法的线程销毁为止。也就是说,在这个例子当中,当myThread1线程销毁以后,main线程才会继续执行,在这期间都是阻塞的。


sleep(long millis)


sleep方法的作用就是在指定的时间让正在执行的线程休眠。并不释放锁。

要注意sleep()是一个静态方法


多线程的栗子

龟兔赛跑问题

龟兔赛跑:2000米

要求:

(1)兔子每 0.1 秒 5 米的速度,每跑20米休息1秒;

(2)乌龟每 0.1 秒跑 2 米,不休息;

(3)其中一个跑到终点后另一个不跑了!

程序设计思路:

(1)创建一个Animal动物类,继承Thread,编写一个running抽象方法,重写run方法,把running方法在run方法里面调用。

(2)创建Rabbit兔子类和Tortoise乌龟类,继承动物类

(3)两个子类重写running方法

(4)本题的第3个要求涉及到线程回调。需要在动物类创建一个回调接口,创建一个回调对象。

abstract class Animal extends Thread {
    public int length = 2000;// 比赛长度
    public abstract void runing();
    @Override
    public void run() {
        super.run();
        while (length > 0) {
            runing();
        }
    }
    // 在需要回调数据的地方(两个子类需要),声明一个接口
    public static interface Calltoback {
        public void win();
    }
    // 2.创建接口对象
    public Calltoback calltoback;
}
//创建兔子类
class Rabbit extends Animal {
    public Rabbit() {
        setName("兔子");
    }
    @Override
    public void runing() {
        //兔子速度
        int dis = 5;
        length -= dis;
        System.out.println("兔子跑了" + dis + "米,距离终点还有" + length + "米");
        if (length <= 0) {
            length = 0;
            System.out.println("兔子获得了胜利");
            // 给回调对象赋值,让乌龟不要再跑了
            if (calltoback != null) {
                calltoback.win();
            }
        }
        try {
            if ((2000 - length) % 20 == 0) {  // 每20米休息一次,休息时间是1秒
                sleep(1000);
            } else {    //没0.1秒跑5米
                sleep(100);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
//创建一个乌龟类
 class Tortoise extends Animal {
    public Tortoise() {
        setName("乌龟");// Thread的方法,给线程赋值名字
    }
    // 重写running方法,编写乌龟的奔跑操作
    @Override
    public void runing() {
        // 乌龟速度
        int dis = 2;
        length -= dis;
        System.out.println("乌龟跑了" + dis + "米,距离终点还有" + length + "米");
        if (length <= 0) {
            length = 0;
            System.out.println("乌龟获得了胜利");
            // 让兔子不要在跑了
            if (calltoback != null) {
                calltoback.win();
            }
        }
        try {
            sleep(100);      //没0.1秒跑2米
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
//创建一个让动物线程停止的类,这里要实现回调接口
class LetOneStop implements Animal.Calltoback {
    // 动物对象
    Animal an;
    // 获取动物对象,可以传入兔子或乌龟的实例
    public LetOneStop(Animal an) {
        this.an = an;
    }
    // 让动物的线程停止
    @Override
    public void win() {
        // 线程停止
        an.stop();
    }
}
//主方法调用类
public class Main {
    /**
     * 龟兔赛跑:2000米
     */
    public static void main(String[] args) {
        // 实例化乌龟和兔子
        Tortoise tortoise = new Tortoise();
        Rabbit rabbit = new Rabbit();
        // 回调方法的使用,谁先调用calltoback方法,另一个就不跑了
        LetOneStop letOneStop1 = new LetOneStop(tortoise);
        // 让兔子的回调方法里面存在乌龟对象的值,可以把乌龟stop
        rabbit.calltoback = letOneStop1;
        LetOneStop letOneStop2 = new LetOneStop(rabbit);
        // 让乌龟的回调方法里面存在兔子对象的值,可以把兔子stop
        tortoise.calltoback = letOneStop2;
        // 开始跑
        tortoise.start();
        rabbit.start();
    }
}



运行结果为:

微信图片_20220520200321.png

相关文章
|
5天前
|
存储 缓存 安全
java 中操作字符串都有哪些类,它们之间有什么区别
Java中操作字符串的类主要有String、StringBuilder和StringBuffer。String是不可变的,每次操作都会生成新对象;StringBuilder和StringBuffer都是可变的,但StringBuilder是非线程安全的,而StringBuffer是线程安全的,因此性能略低。
|
6天前
|
存储 安全 Java
Java多线程编程中的并发容器:深入解析与实战应用####
在本文中,我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构,并发容器专为多线程场景设计,确保数据访问的线程安全性和高效性。我们将从基础概念出发,逐步深入到`java.util.concurrent`包下的核心并发容器实现,如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等,通过实例代码演示其使用方法,并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者,本文都将为你提供有价值的见解与实践指导。 --- ####
|
12天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
37 9
|
15天前
|
存储 安全 Java
Java多线程编程的艺术:从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
|
12天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
|
15天前
|
Java
JAVA多线程通信:为何wait()与notify()如此重要?
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是实现线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件满足时被唤醒,从而确保数据一致性和同步。相比其他通信方式,如忙等待,这些方法更高效灵活。 示例代码展示了如何在生产者-消费者模型中使用这些方法实现线程间的协调和同步。
31 3
|
14天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
15天前
|
Java UED
Java中的多线程编程基础与实践
【10月更文挑战第35天】在Java的世界中,多线程是提升应用性能和响应性的利器。本文将深入浅出地介绍如何在Java中创建和管理线程,以及如何利用同步机制确保数据一致性。我们将从简单的“Hello, World!”线程示例出发,逐步探索线程池的高效使用,并讨论常见的多线程问题。无论你是Java新手还是希望深化理解,这篇文章都将为你打开多线程的大门。
|
5月前
|
Java
排名前16的Java工具类
排名前16的Java工具类
38 0
|
Java
排名前16的Java工具类
排名前16的Java工具类
191 0
下一篇
无影云桌面