多线程的基本概念和实现方式,线程的调度,守护线程、礼让线程、插入线程

简介: 多线程的基本概念和实现方式,线程的调度,守护线程、礼让线程、插入线程

一、什么是多线程

线程:

线程是操作系统能够进行运算调度的最小单位。

线程被包含在进程之中,是进程中的实际运作单位。

进程:

进程是程序的基本执行实体

可以说一个软件运行后,就是一个进程。

任务管理器中我们可以看到在电脑上运行的一个个进程。

所以线程可以简单理解为:应用软件中互相独立,可以同时运行的功能。

有了多线程,我们就可以让程序同时做多件事情。

多线程的作用:

可以充分利用程序当中的等待时间,让CPU在多个程序当中切换,提高程序的运行效率。

多线程的应用场景:

只要想让多个事情同时运行就需要用到多线程(如软件中的耗时操作、聊天软件、服务器等)。

二、多线程的两个概念(并发和并行)

1.并发:在同一时刻,有多个指令在单个CPU上交替执行

2.并行:在同一时刻,有多个指令在多个CPU上同时执行

计算机的CPU可以分为2核四4线程、4核8线程、8核16线程、16核32线程、32核64线程。

以2核4线程为例:表示在计算机当中如果只有4条线程,那么这四个线程可以同时执行,不需要切换,但线程数超过了4条,就需要切换执行。

所以说并发和并行有可能同时进行。

三、多线程的实现方式

3.1继承Thread类的方式

1.自己定义一个类继承Thread

2.重写run方法

3.创建子类的对象,并启动线程。

package com.practice;
/**
 * @Author YJ
 * @Date 2023/7/21 9:41
 * Description:继承Thread类的方式
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        //书写线程要执行的方法
        //getName()获取线程名
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":hello world");
        }
    }
}
package com.practice;
/**
 * @Author YJ
 * @Date 2023/7/21 9:37
 * Description:继承Thread类的方式
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        //创建对象,启动线程
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        //为线程命名
        thread1.setName("线程1");
        thread2.setName("线程2");
        //开启线程
        thread1.start();
        thread2.start();
    }
}

3.2实现Runnable接口的方式

.1.自己定义一个类实现Runnable接口

2.重写里面的run方法

3.创建自己的类的对象

4.创建一个Thread类的对象,并开启线程。

package com.practice.threaddemo2;
/**
 * @Author YJ
 * @Date 2023/7/21 9:53
 * Description:实现Runnable接口的方式
 */
public class MyRun implements Runnable{
    @Override
    public void run() {
        //获取当前线程的对象
        Thread thread = Thread.currentThread();
        for (int i = 0; i < 100; i++) {
            System.out.println(thread.getName() + ":hello world!");
        }
    }
}
package com.practice.threaddemo2;
/**
 * @Author YJ
 * @Date 2023/7/21 9:53
 * Description:实现Runnable接口的方式
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //创建自己类MyRun的对象
        MyRun myRun = new MyRun();
        //创建线程对象,并传递任务
        Thread thread1 = new Thread(myRun);
        Thread thread2 = new Thread(myRun);
        //给线程命名
        thread1.setName("线程1");
        thread2.setName("线程2");
        //开启线程
        thread1.start();
        thread2.start();
    }
}

3.3利用Callable接口和Future接口方式

特点:可以获取到多线程运行的结果

1.创建一个类实现Callable接口

2.重写call(有返回值,表示多线程运行的结果)

3.创建实现Callable接口的类的对象(表示多线程要执行的任务)

4.创建FutureTask的对象(作用管理多线程运行的结果)

5.创建Thread类的对象,并启动线程。

package com.practice.threaddemo3;
import java.util.concurrent.Callable;
/**
 * @Author YJ
 * @Date 2023/7/21 10:11
 * Description:利用Callable接口和Future接口方式
 */
public class MyCallable implements Callable<Integer> {
    //求1-100的和
    int sum = 0;
    @Override
    public Integer call() throws Exception {
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}
package com.practice.threaddemo3;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * @Author YJ
 * @Date 2023/7/21 10:11
 * Description:利用Callable接口和Future接口方式
 */
public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建实现Callable接口的类的对象(表示多线程要执行的任务)
        MyCallable mc = new MyCallable();
        //创建FutureTask的对象(作用管理多线程运行的结果)
        FutureTask<Integer> ft = new FutureTask<>(mc);
        //创建Thread类的对象,并启动线程。
        Thread t1 = new Thread(ft);
        Thread t2 = new Thread(ft);
        //启动线程
        t1.start();
        t2.start();
        //获取结果
        Integer result = ft.get();
        System.out.println(result);
    }
}

四、多线程中常用的成员方法

4.1基本成员方法

String getName()返回线程名字

void setName()设置线程名字(Thread 构造方法也可实现)

细节:

1.如果没有给线程设置名字,线程有默认名字(格式:Thread-X(X是序号,从0开始))

2.如果要给线程设置名字,可以通过set方法设置,也可通过构造方法设置。

package com.practice.threaddemo4;
/**
 * @Author YJ
 * @Date 2023/7/21 10:26
 * Description:构造方法设置名字
 */
public class MyThread extends Thread{
    public MyThread() {
    }
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "@" + i);
        }
    }
}
package com.practice.threaddemo4;
/**
 * @Author YJ
 * @Date 2023/7/21 10:26
 * Description:构造方法设置名字
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //创建线程对象
        MyThread t1 = new MyThread("蓝1");
        MyThread t2 = new MyThread("红2");
        //开启线程
        t1.start();
        t2.start();
    }
}

static Thread currentThread()获取当前线程对象

细节:

当JVM虚拟机启动之后,会自动地启动多条线程,其中有一条线程就叫做main线程,

它的作用就是去调用main方法,并执行里面的代码

在以前我们写的所有的代码,都是运行在main线程中的。

static void sleep(long time):让线程休眠指定的时间,单位为毫秒

细节:

1.哪条线程执行到这里,该线程就会在此停留对应的时间

2.方法的参数,表示睡眠的时间,单位毫秒

3.当时间到了,线程会自动醒来,继续执行代码。

package com.practice.threaddemo4;
/**
 * @Author YJ
 * @Date 2023/7/21 10:43
 * Description:sleep演示
 */
public class ThreadDemoSleep {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("你好~");
        Thread.sleep(5000);
        System.out.println("hi~");
    }
}

4.2线程的优先级

线程的调度:

1.抢占式调度:多个线程在抢夺CPU的执行权,CPU执行线程是不确定的,执行多长时间也不确定(随机性);

2.非抢占式调度:所有的线程轮流执行。

Java中用的是抢占式调度(注意随机性

Java中优先级分为1-10级

Thread .getPriority()获取优先级

Thread .setPriority()设置优先级

优先级越高,抢占到CPU的概率越大,但并不是一定的

package com.practice.threaddemo5;
/**
 * @Author YJ
 * @Date 2023/7/21 11:04
 * Description:
 */
public class ThreadDemo {
    public static void main(String[] args) {
        MyRun mr = new MyRun();
        Thread t1 = new Thread(mr,"1");
        Thread t2 = new Thread(mr,"2");
        t1.setPriority(1);
        t2.setPriority(10);
        t1.start();
        t2.start();
    }
}

4.3守护线程

final void setDaemon()

当其他非守护线程执行完毕后,守护线程会陆续结束,守护线程不一定执行完

例如:有两个线程,线程1为1号线程,线程2为2号线程,把线程2设置为守护线程,当两个线程执行的时候,若1号线程执行完毕2号线程没有执行完毕,此时2号线程会陆续结束,即使它没有执行完也会结束。

因为非守护线程已经执行完,守护线程就没有存在的必要了。

package com.practice.threaddemo6;
/**
 * @Author YJ
 * @Date 2023/7/21 11:19
 * Description:
 */
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
        t1.setName("1号");
        t2.setName("2号");
        //设置2号为守护线程(备胎线程)
        //当1号线程结束了,2号线程就没有存在的必要了
        t2.setDaemon(true);
        t1.start();
        t2.start();
    }
}

4.4出让/礼让线程

public static void yield()

尽可能将线程均匀

package com.practice.threaddemo7;
/**
 * @Author YJ
 * @Date 2023/7/21 9:41
 * Description:
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        //书写线程要执行的方法
        //getName()获取线程名
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "@" + i);
            Thread.yield();
        }
    }
}

4.5插入线程

public static void join()

表示把某个线程插入到当前线程之前

当插入的线程执行完后,才执行当前线程

package com.practice.threaddemo8;
/**
 * @Author YJ
 * @Date 2023/7/21 11:19
 * Description:
 */
public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.setName("1号");
        t1.start();
        //执行在main线程上的
        //当前线程:main线程
        //表示将t1线程插入到main线程之前
        t1.join();
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程" + i);
        }
    }
}

五、线程的生命周期

新建状态:创建线程对象start()

就绪状态(不停的抢CPU):有执行资格,没有执行权

运行状态(代码):有执行资格,有执行权

1.若被其他线程抢走CPU执行权就会回到就绪状态

2.若是有sleep()或是其他阻塞式方法会变成阻塞状态

3.若是执行完毕run()会变成死亡状态:线程死亡,变成垃圾

阻塞状态(等着):没有执行资格,没有执行权

死亡状态:线程死亡,变成垃圾

总结

经过本篇文章,我们了解到了线程的基本概念及如何实现多线程,欢迎各位伙伴评论+点赞!!!

我会持续学习并更新博客,欢迎各位评论!!!

相关文章
|
4天前
|
Java API
详细探究Java多线程的线程状态变化
Java多线程的线程状态主要有六种:新建(NEW)、可运行(RUNNABLE)、阻塞(BLOCKED)、等待(WAITING)、超时等待(TIMED_WAITING)和终止(TERMINATED)。线程创建后处于NEW状态,调用start()后进入RUNNABLE状态,表示准备好运行。当线程获得CPU资源,开始执行run()方法时,它处于运行状态。线程可以因等待锁或调用sleep()等方法进入BLOCKED或等待状态。线程完成任务或发生异常后,会进入TERMINATED状态。
|
4天前
|
存储 安全 Java
Java多线程中线程安全问题
Java多线程中的线程安全问题主要涉及多线程环境下对共享资源的访问可能导致的数据损坏或不一致。线程安全的核心在于确保在多线程调度顺序不确定的情况下,代码的执行结果始终正确。常见原因包括线程调度随机性、共享数据修改以及原子性问题。解决线程安全问题通常需要采用同步机制,如使用synchronized关键字或Lock接口,以确保同一时间只有一个线程能够访问特定资源,从而保持数据的一致性和正确性。
|
11天前
|
缓存 Java 测试技术
Java性能优化(八)-多线程调优-线程池大小设置
Java性能优化(八)-多线程调优-线程池大小设置
13 0
|
13天前
|
安全 Java 容器
多线程(进阶四:线程安全的集合类)
多线程(进阶四:线程安全的集合类)
15 0
|
20天前
|
设计模式 监控 Java
Java多线程基础-11:工厂模式及代码案例之线程池(一)
本文介绍了Java并发框架中的线程池工具,特别是`java.util.concurrent`包中的`Executors`和`ThreadPoolExecutor`类。线程池通过预先创建并管理一组线程,可以提高多线程任务的效率和响应速度,减少线程创建和销毁的开销。
34 2
|
13天前
|
开发框架 监控 Java
【.NET Core】多线程之线程池(ThreadPool)详解(二)
【.NET Core】多线程之线程池(ThreadPool)详解(二)
30 3
|
13天前
|
SQL 开发框架 Java
【.NET Core】多线程之线程池(ThreadPool)详解(一)
【.NET Core】多线程之线程池(ThreadPool)详解(一)
22 2
|
19天前
|
安全 Linux 编译器
从C语言到C++_40(多线程相关)C++线程接口+线程安全问题加锁(shared_ptr+STL+单例)(下)
从C语言到C++_40(多线程相关)C++线程接口+线程安全问题加锁(shared_ptr+STL+单例)
22 0
|
19天前
|
安全 C语言 C++
从C语言到C++_40(多线程相关)C++线程接口+线程安全问题加锁(shared_ptr+STL+单例)(中)
从C语言到C++_40(多线程相关)C++线程接口+线程安全问题加锁(shared_ptr+STL+单例)
20 0
|
19天前
|
Linux 调度 C语言
从C语言到C++_40(多线程相关)C++线程接口+线程安全问题加锁(shared_ptr+STL+单例)(上)
从C语言到C++_40(多线程相关)C++线程接口+线程安全问题加锁(shared_ptr+STL+单例)
23 0

相关实验场景

更多