Java多线程--1_java 一个进程中的多个线程执行时间是相同的-CSDN博客

本文链接：https://blog.csdn.net/Ther_123/article/details/116575619

Java 多线程 (Thread)

文章目录

Java 多线程 (Thread)
@[toc]
一、基本概念：程序、进程、线程
二、线程的创建和使用
多线程的创建方式一：继承Thread类：
Thread类的常用方法
线程的调度
线程的优先级：
多线程的方式二：实现Runnable接口：

三、线程的生命周期

一、基本概念：程序、进程、线程

程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即一段静态的代码，静态对象
进程(process)：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
- 如：运行的QQ，运行中的播放器
- 程序是静态的，进程是动态的
- 进程作为资源分配的单位，系统在运行的时候会为每个进程分配不同的内存区域。
线程（tread）：进程可进一步细化为线程，是一个程序内部的一条执行路径。
- 若一个进程同一时间并执行多个线程，就是支持多线程的
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小
- 一个进程中的多个线程共享相同的内存单元/内存地址空间–>它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间的通信更简便、高效。但多个线程操作的系统资源可能就会带来安全隐患
单核CPU和多核CPU的理解：
- 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个多线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费的才能通过，那么CPU就好比收费人员。如果有某个人不想去交钱，那么收费人员可以把他“挂起”。但是因为CPU时间单元特别短，因此感觉不出来。
- 如果是多核的话，才能更好的发挥多线程的效率。
- 一个Java应用程序java.exe，其实至少有三个线程：**main()主线程，gc()垃圾回收线程，异常处理线程。**当然如果异常发生，会影响主线程
并行与并发
- 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事
- 并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀，多个人做同一件事。

使用多线程的优点

**背景：**以单核CPU为例，只使单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需要多线程呢？

提高应用程序的响应。对图形化界面更有意义，可增强用户体验
提高计算机系统CPU的利用率
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

什么时候需要使用多线程

程序需要同时执行两个或多个任务时。
程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
需要一些后台运行的程序时。

二、线程的创建和使用

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现

Thread类的特性：

每个线程都是通过某个特定的Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

多线程的创建方式一：继承Thread类：

创建一个继承于Thread类的子类
重写Thread类的run()：将此线程执行的操作声明在run()中
创建Thread类的子类的对象
通过此对象调用start():
1. 启动当前线程
2. 调用当前线程的run方法
3. 注意：直接通过对象调用run()相当于还是在主线程
4. 注意：再启动一个线程，不可以让已经start()的线程去执行，会报异常。这个时候就需要重新new一个对象。

示例代码：

package JavaSE.Thread;

/*
多线程的创建方式一：继承Thread类
1.创建一个继承于Thread类的子类
2.重写Thread类的run()
3.创建Thread类的子类的对象
4.通过此对象调用start()
    1.启动当前线程
    2.调用当前线程的run方法
 */


class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+"分线程");
        }
    }
}

public class Tread_Test {
    public static void main(String[] args) {
        var myThread = new MyThread();
        var myThread2 = new MyThread();
        myThread.start();//分线程
        myThread2.start();
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+"主线程");//主线程
        }

        //可以从输出结果上来看，主线程和分线程出现了交互

    }
}

练习：

package JavaSE.Thread.exr;

/**
 * 创建两个线程，一个遍历一百以内的偶数，一个遍历一百以内的奇数
 */

public class ThreadDemo2 {
    public static void main(String[] args) {
        //创建匿名子类
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                        if (i % 2 == 0)
                            System.out.println(Thread.currentThread().getName() + "-----" + i);
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i % 2 != 0)
                        System.out.println(Thread.currentThread().getName() + "-----" + i);
                }
            }
        }.start();
    }
}

Thread类的常用方法

方法名	说明
public synchronized void start()	启动当前的线程，调用当前线程的run()方法
public void run()	通常需要重写Thread类中的方法，将创建的线程要执行的操作声明在此方法中
public static native Thread currentThread()	静态方法，返回执行当前代码的线程
public final String getName()	获取当前线程的名字
public final synchronized void setName(String name)	设置自定义当前线程的名字
yield()	释放当前CPU的执行，有可能下一次又分配到当前的线程
join()	在线程A中调用线程B的join()方法，此时线程A就进入到阻塞状态，直到线程B完全执行之后，线程A才结束阻塞
stop()	(过时的方法)当执行此方法时，强制结束当前的线程
sleep()	单位是ms，在该时间内当前线程阻塞。
isAlive()	判断当前线程是否还存活。

线程的调度

调度策略：
- 时间片：（时间片的概念：时间片即CPU分配给各个程序的时间，每个进程被分配一个时间段，称作它的时间片，即该进程允许运行的时间）
- 抢占式：高优先级的线程抢占CPU
Java的调度方法
- 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
- 对高优先级，使用优先调度的抢占式策略。

线程的优先级：

线程的优先等级：

/**
     * The minimum priority that a thread can have.
     */
    public static final int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public static final int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public static final int MAX_PRIORITY = 10;

MAX_PRIORITY : 10
MIN_PRIORITY : 1
NORM_PRIORITY : 5

涉及的方法：
- getPriority():返回线程优先值
- setPriority(int newPriority):改变线程的优先级
说明：
- 线程创建时，继承父线程的优先级
- 低优先级只是获得的调度概率低，并非一定是在高优先级线程之后才被调用

多线程的方式二：实现Runnable接口：

步骤：

创建一个实现了Runnable接口的类
实现类去实现Runnable中的抽象方法：run()
创建实现类的对象
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
通过Thread类的对象调用start()

示例代码

package JavaSE.Thread;
/*
创建多线程的方式二：实现Runnable接口
 */
public class Thread_Test3 {
    //1.创建一个实现了Runnable接口的类
    static class MyRun implements Runnable{

	//2.实现类去实现Runnable中的抽象方法：run()
        @Override
        public void run() {
                System.out.println(Thread.currentThread().getName() + "Hello");
        }
    }

    public static void main(String[] args) {
        //3.创建实现类的对象
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        var t1 = new Thread(new MyRun());
        var t2 = new Thread(new MyRun());
        var t3 = new Thread(new MyRun());
        //5.通过Thread类的对象调用start()
        t1.start();
        t2.start();
        t3.start();
    }
}