Java多线程基础(线程与进程的区别,线程的创建方式及常用api,线程的状态)

简介: Java多线程基础(线程与进程的区别,线程的创建方式及常用api,线程的状态)

☘️一. 什么是线程

每一个线程都是一个执行流,都按照自己的顺序执行自己的代码,多个线程之间“同时” (并发并行) 的执行多份代码。Java中的线程是以轻量级进程来实现的

🍒Java中,线程既然是以轻量级进程实现的,那它也具有进程的特征:

需要系统调度CPU来执行

并发:一个CPU以时间调度轮转的方式依次执行每个线程

并行:多个CPU在同一时间同时执行多个线程

🍓线程存在的必要性?

单核CPU发展遇到了瓶颈, 要想提高运算力,就得用到多核CPU, 与此同时,并发编程更能充分利用多核CPU资源

对于某些任务场景,比如等待IO,为了在等待IO的时间内做一些其他事情,也需要用到并发编程

🍅多进程也能实现并发编程,但是线程比进程轻量:

🍁创建线程比创建进程更快
🍁销毁线程比销毁进程更快
🍁调度线程比调度进程更快

🌿二. 线程和进程的区别(面试常问)

🍂进程是包含线程的,而且每一个进程至少包含一个线程(主线程)

🍂进程是系统分配资源的最小单位(基本单位),线程是操作系统调度CPU执行的最小单位(基本单位)

🍂进程状态的改变会消耗很多资源时间,线程的效率更高

🍂进程独占虚拟内存空间,一个进程包含的多个线程可以共享进程的内存

🍂一个进程要访问另一个进程的数据需要使用通信的方式,一个进程的多个线程可以使用共享变量

🍂一个进程如果挂掉是不会影响其他进程的,但是如果一个线程挂掉可能影响整个进程

👁‍🗨️例如:一个线程申请的内存太多超出整个进程的内存(OOM)

🍄三. 线程的创建方式(面试常问)

这里介绍两种创建方式:

· 继承Thread类, this表示当前线程对象的引用

· 实现Runnable接口,this表示的是MyRunnable的引用,当前线程的引用需要使用Thread.currentThread()

🌴1. 继承Thread类


public class Method1 {
    public static void main(String[] args) {
        MyThread t1 = new MyThread(); //创建MyThread的实例
        t1.start(); //调用start方法,才会真正创建操作系统中的线程,并申请系统调度执行
    }
    public static class MyThread extends Thread {
        //必须重写run方法描述线程要执行的任务
        @Override
        public void run() {
            System.out.println("创建方式1");
        }
    }
}

🌵2. 实现Runnable接口


public class Method2 {
    public static void main(String[] args) {
        //先创建Runnable对象,然后当作参数传入Thread的构造方法中
        Thread t2 = new Thread(new MyRunnable());
        t2.start();
    }
    //Runnable接口,表示定义线程任务对象(Thread才是线程本身)
    public static class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("创建方式2");
        }
    }
}

🌾3. 变形的方式创建

🍀使用匿名内部类来创建Thread子类对象


public class Method3 {
    public static void main(String[] args) {
        Thread t3 = new Thread() {
            @Override
            public void run() {
                System.out.println("匿名内部类创建Thread子类对象");
            }
        };
        t3.start();
    }
}

🍀使用匿名内部类来创建Runnable子类对象


public class Method4 {
    public static void main(String[] args) {
        Thread t4 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("使用匿名内部类创建Runnable子类对象");
            }
        });
        t4.start();
    }
}

🍀lambda表达式创建Runnable子类对象


public class Method5 {
    public static void main(String[] args) {
        Thread t5 = new Thread(() -> System.out.println("lambda表达式创建"));
        t5.start();
    }
}

🌻四. Thread常用方法

🍖1. Thread常见构造方法

方法 说明
Thread() 创建线程对象
Thread(Runnable target) 使用Runnable对象创建线程对象
Thread(String name) 创建线程对象并命名
Thread(Runnable target,String name) 使用Runnable对象创建线程对象并命名


Thread t1 = new Thread();
 Thread t2 = new Thread(new MyRunnable());
 Thread t3 = new Thread("名字1");
 Thread t4 = new Thread(new MyRunnable(),"名字2");

🍗2. Thread的常见属性

属性 获取方法
ID getId()
名称 getName()
状态 getState()
优先级 getPriority()
是否有后台线程 isDaemon()
是否存活 isAlive()
是否被中断 isInterrupted()

👁‍🗨️说明:

🍃ID:是线程的唯一标识,多个线程不能重复

🍃名称:是线程的名称

🍃状态:表示线程所处的情况

🍃优先级:理论来说,优先级高的线程优先被调度到

🍃后台线程:JVM会在一个进程的所有非后台线程结束后,才会结束运行

🍃是否存活:简单理解为run方法是否运行结束

🍃中断:下面板块中介绍

🥩3. 介绍说明常用方法

Thread有静态方法也有实例方法:

Thread.静态方法()
thread对象.实例方法()

image.png

image.png

线程中断(重点掌握)

实现线程中断的操作:设置一个标记位,表示是否被中断,线程在执行时循环判断是否被中断


public class Interrupt {
    private static boolean isStop = false; //标记位
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while(!isStop){
                        //每一秒钟打印一次
                        //如果线程处于休眠状态就不会被中断(如休眠100秒)
                        Thread.sleep(1000);
                        System.out.println("hello word");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        //让t线程运行3秒中在中断
        Thread.sleep(3000);
        isStop = true;
    }
}

image.png

Thread.interrupted(),静态方法,调用后会重置标志位,但是多个线程是共享着一起使用的,不推荐使用

重点使用这种方法:


public class Demo {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("执行中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("执行收尾操作");
                    break;
                }
            }
        });
        t.start();
        Thread.sleep(3000);
        t.interrupt();
    }
}

t.interrupt():

  1. t处于就绪态,调用就会将标志位设置为true
  2. t处于阻塞状态(sleep),调用就会触发interruptException

🌼五. 线程的状态(面试常问)

image.png


👁‍🗨️说明:

🍁NEW:Thread对象已经创建好了,但是还没有调用start

🍁RUNNABLE:处于就绪队列中,随时可以被调度到CPU上

🍁BLOCKED:当前线程在等待锁,导致阻塞

🍁WAITING:当前线程等待被唤醒,导致阻塞

🍁TIME_WAITING:当前线程在一定时间内,处于阻塞状态(一定时间到了之后,阻塞解除),sleep,join(时间)

🍁TERMINATED:线程已经执行完毕,销毁了,但是Thread对象还存在

❗注意:RUNNABLE包含就绪态和运行态(程序不知道线程是就绪态还是运行态,由操作系统决定)

🍎六. 线程的优点

🍬创建线程的代价比创建进程的代价小得多

🍬与进程切换相比,线程切换需要操作系统进行的工作量要小的多

🍬线程占用资源比进程少

🍬能充分利用多处理器的可并行数量

🍬在等待慢速I/O操作结束的同时,程序可执行其他的计算任务

🍬计算密集型应用,为了能在多处理器系统上运行,将计算分解到多个线程中实现

🍬I/O密集型应用,为了提高性能,将I/O操作重叠。线程可以同时等待不同的I/O操作



目录
打赏
0
0
0
0
5
分享
相关文章
Java爬虫获取微店店铺所有商品API接口设计与实现
本文介绍如何使用Java设计并实现一个爬虫程序,以获取微店店铺的所有商品信息。通过HttpClient发送HTTP请求,Jsoup解析HTML页面,提取商品名称、价格、图片链接等数据,并将其存储到本地文件或数据库中。文中详细描述了爬虫的设计思路、代码实现及注意事项,包括反爬虫机制、数据合法性和性能优化。此方法可帮助商家了解竞争对手,为消费者提供更全面的商品比较。
【JAVA】封装多线程原理
Java 中的多线程封装旨在简化使用、提高安全性和增强可维护性。通过抽象和隐藏底层细节,提供简洁接口。常见封装方式包括基于 Runnable 和 Callable 接口的任务封装,以及线程池的封装。Runnable 适用于无返回值任务,Callable 支持有返回值任务。线程池(如 ExecutorService)则用于管理和复用线程,减少性能开销。示例代码展示了如何实现这些封装,使多线程编程更加高效和安全。
java语言后台管理若依框架-登录提示404-接口异常-系统接口404异常如何处理-登录验证码不显示prod-api/captchaImage 404 (Not Found) 如何处理-解决方案优雅草卓伊凡
java语言后台管理若依框架-登录提示404-接口异常-系统接口404异常如何处理-登录验证码不显示prod-api/captchaImage 404 (Not Found) 如何处理-解决方案优雅草卓伊凡
30 5
|
2月前
|
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者
Java 多线程 面试题
Java 多线程 相关基础面试题
Java基础-常用API-Object类
继承是面向对象编程的重要特性,允许从已有类派生新类。Java采用单继承机制,默认所有类继承自Object类。Object类提供了多个常用方法,如`clone()`用于复制对象,`equals()`判断对象是否相等,`hashCode()`计算哈希码,`toString()`返回对象的字符串表示,`wait()`、`notify()`和`notifyAll()`用于线程同步,`finalize()`在对象被垃圾回收时调用。掌握这些方法有助于更好地理解和使用Java中的对象行为。
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。
Java多线程是什么
Java多线程简介:本文介绍了Java中常见的线程池类型,包括`newCachedThreadPool`(适用于短期异步任务)、`newFixedThreadPool`(适用于固定数量的长期任务)、`newScheduledThreadPool`(支持定时和周期性任务)以及`newSingleThreadExecutor`(保证任务顺序执行)。同时,文章还讲解了Java中的锁机制,如`synchronized`关键字、CAS操作及其实现方式,并详细描述了可重入锁`ReentrantLock`和读写锁`ReadWriteLock`的工作原理与应用场景。
|
2月前
|
Java多线程编程秘籍:各种方案一网打尽,不要错过!
Java 中实现多线程的方式主要有四种:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点,适用于不同的场景。继承 Thread 类最简单,实现 Runnable 接口更灵活,Callable 接口支持返回结果,线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外,还介绍了多线程相关的常见面试问题及答案,涵盖线程概念、线程安全、线程池等知识点。
228 2
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等