《Java》第二篇创建线程的方式和生命周期

最新推荐文章于 2023-11-26 22:42:54 发布

搬砖界的小白

最新推荐文章于 2023-11-26 22:42:54 发布

阅读量203

点赞数 1

分类专栏： Java # 线程文章标签：多线程 java

本文链接：https://blog.csdn.net/weixin_44167408/article/details/105226326

版权

Java 同时被 2 个专栏收录

25 篇文章 0 订阅

订阅专栏

线程

8 篇文章 0 订阅

订阅专栏

Java线程与进程

一.线程与进程的区别
 二.Java中创建线程的方式
 三.线程的生命周期

一.线程与进程的区别

项目开发目标：高可用、高性能、高并发

区别	进程	线程
定义区别	是任务调度的最小单位，每个进程有各自独立的一块内存，使得各个进程之间内存地址相互隔离。	程序执行中一个单一的顺序控制流程，是程序执行流的最小单元，是处理器调度和分派的基本单位
组成部分	程序，数据集合和进程控制块	线程ID，当前指令指针PC，寄存器和堆栈
特征	动态性，并发性，独立性，结构性	生命周期，并发性，共享性
开销	每个进程都有独立的代码和数据空间（进程上下文），进程间的切换开销大	线程上下文切换比进程上下文切换要快得多，开销小
所处环境	操作系统（OS）可以同时运行多个进程/程序	同一个进程/程序中，可以允许多个顺序流同时执行
内存分配	系统在运行时会为每个进程分配不同的内存区域，区域之间完全隔离	不会为线程分配区间，每个线程共享所属进程的资源和内存，拥有相同的地址空间
二者关联	没有线程的进程可以被视为单线程的，如果一个进程拥有多个线程，则执行过程不是一条直线的，而是多条线共同完成	线程是进程的一部分，所以线程被称为轻权或轻量级进程

注意：大多线程是模拟出来的（感官上的多线程同步），真正的多线程指的是有多个CPU/核。
核心概念：
1.线程就是独立的执行路径
2.main()称之为主线程，为系统的入口点，用于执行整个程序
3.一个进程中开辟了多个线程，线程的运行由调度器安排调度，调度器是与OS紧密相关的，先后顺序无法人为干预
4.对于同一份资源操作时会存在抢夺问题，需要加入并发控制
5.线程会带来额外的开销，如CPU调度时间、并发控制开销
6.每个线程在自己的工作内存（与主内存交互）交互，加载和存储主内存控制不当会造成数据不一致

二.Java中创建线程的方式

继承Thread
实现Runnable
实现Callable
通过线程池启动多线程
注意：Java中少用继承 extends 多用实现 implements，避免单继承的局限性。一个类仅在他们需要被加强或者修改时才会被继承
start（）方法能够异步地调用普通方法run（），才能达到多线程的目的
在这里插入图片描述

1.继承Thread类

run()为线程类的核心方法，相当于主线程的main方法，是每个线程的入口
a.一个线程调用两次start()方法将会抛出线程状态异常，也就是的start()只可以被调用一次 b. run()方法是由jvm创建完本地操作系统级线程后回调的方法，不可以手动调用（否则就是普通方法）

public class FirstThreadTest extends Thread{
    public FirstThreadTest() {

    }
    @Override
    public void run() {
        for(int i=0;i<10;i++) {
            System.out.println(Thread.currentThread()+":"+i);
        }
    }
    public static void main(String[] args) {
        FirstThreadTest mThread1=new FirstThreadTest();
        FirstThreadTest mThread2=new FirstThreadTest();
        FirstThreadTest myThread3=new FirstThreadTest();
        mThread1.start();
        //mThread1.start(); 同一个线程调用多次start方法，会抛出异常
        mThread2.start();
        myThread3.start();
    }
}

执行结果:
在这里插入图片描述

2.实现Runnable

a.覆写Runnable接口实现多线程可以避免单继承局限
b.当子类实现Runnable接口，此时子类和Thread的代理模式（子类负责真是业务的操作，thread负责资源调度与线程创建辅助真实业务。

public class SecondThreadTest implements Runnable {

    public static int count = 20;

    @Override
    public void run() {
        while (count > 1) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 0) {
                System.out.println(Thread.currentThread().getName() + "当前剩余票数:" + count + ",不好意思,票卖完了");
            } else {
                System.out.println(Thread.currentThread().getName() + "当前剩余票数:" + count--);
            }
        }
    }

    public static void main(String[] args) {
        SecondThreadTest sThread = new SecondThreadTest();
        Thread thread1 = new Thread(sThread, "卖票窗口1-");
        Thread thread2 = new Thread(sThread, "卖票窗口2-");
        Thread thread3 = new Thread(sThread, "卖票窗口3-");

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

执行结果:
在这里插入图片描述

3.实现Callable(JDK1.5)

a.核心方法叫call()方法，有返回值
b.有返回值

public class ThirdThreadTest implements Callable<String> {
    private int count = 30;

    @Override
    public String call() throws Exception {
        for (int i = count; i > 0; i--) {
            System.out.println(Thread.currentThread().getName() + "当前剩余票数:" + i);
        }
        return "不好意思,票卖完了";
    }

    public static void main(String[] args) {
        Callable<String> callable = new ThirdThreadTest();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        Thread thread1 = new Thread(futureTask);
        Thread thread2 = new Thread(futureTask);
        Thread thread3 = new Thread(futureTask);

        thread1.start();
        thread2.start();
        thread3.start();
        System.out.println(futureTask.get());
    }
}

执行结果:
在这里插入图片描述
4.通过线程池启动多线程
通过Executor 的工具类可以创建四种类型的普通线程池：
4-1 newFixedThreadPool (); 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
4-2 SingleThreadPoolExecutor() :创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
4-3 newCachedThreadPool(); 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
4-4 newScheduledThreadPool (); 创建一个定长线程池，支持定时及周期性任务执行

注意:Executors创建的4种线程池的使用，参考地址，写的十分详细https://my.oschina.net/sdlvzg/blog/2222136

三.线程的生命周期

3-1 生命周期的状态
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked) 和 死亡(Dead) 5种状态。尤其是当线程启动以后，它不可能一直"霸占"着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换
在这里插入图片描述
A.新建(New):当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时仅由JVM为其分配内存，并初始化其成员变量的值
B.就绪（Runnable）:当线程对象调用了start()方法之后，该线程处于就绪状态。Java虚拟机会为其创建方法调用栈和程序计数器，等待调度运行
C.运行（Running）:如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态
D.阻塞(Blocked):处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种
D-1 等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态
D-2 同步阻塞：线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态
D-3 其他阻塞：通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态
E.死亡(Dead):线程执行完了或者因异常退出了run()方法，该线程结束生命周期

3-2 线程状态之间的切换
3-2-1 新建和就绪状态
当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时它和其他的Java对象一样，仅仅由Java虚拟机为其分配内存，并初始化其成员变量的值。此时的线程对象没有表现出任何线程的动态特征，程序也不会执行线程的线程执行体。

当线程对象调用了start()方法之后，该线程处于就绪状态。Java虚拟机会为其创建方法调用栈和程序计数器，处于这个状态中的线程并没有开始运行，只是表示该线程可以运行了。至于该线程何时开始运行，取决于JVM里线程调度器的调度。

注意：启动线程使用start()方法，而不是run()方法。永远不要调用线程对象的run()方法。调用start0方法来启动线程，系统会把该run()方法当成线程执行体来处理；但如果直按调用线程对象的run()方法，则run()方法立即就会被执行，而且在run()方法返回之前其他线程无法并发执行。也就是说，系统把线程对象当成一个普通对象，而run()方法也是一个普通方法，而不是线程执行体。需要指出的是，调用了线程的run()方法之后，该线程已经不再处于新建状态，不要再次调用线程对象的start()方法。只能对处于新建状态的线程调用start()方法，否则将引发IllegaIThreadStateExccption异常。
在这里插入图片描述
调用线程对象的start()方法之后，该线程立即进入就绪状态——就绪状态相当于"等待执行"，但该线程并未真正进入运行状态。如果希望调用子线程的start()方法后子线程立即开始执行，程序可以使用Thread.sleep(1) 来让当前运行的线程（主线程）睡眠1毫秒，1毫秒就够了，因为在这1毫秒内CPU不会空闲，它会去执行另一个处于就绪状态的线程，这样就可以让子线程立即开始执行。

3-2-2 运行和阻塞状态
线程调度
如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态，如果计算机只有一个CPU。那么在任何时刻只有一个线程处于运行状态，当然在一个多处理器的机器上，将会有多个线程并行执行；当线程数大于处理器数时，依然会存在多个线程在同一个CPU上轮换的现象。

当一个线程开始运行后，它不可能一直处于运行状态（除非它的线程执行体足够短，瞬间就执行结束了）。线程在运行过程中需要被中断，目的是使其他线程获得执行的机会，线程调度的细节取决于底层平台所采用的策略。对于采用抢占式策略的系统而言，系统会给每个可执行的线程一个小时间段来处理任务；当该时间段用完后，系统就会剥夺该线程所占用的资源，让其他线程获得执行的机会。在选择下一个线程时，系统会考虑线程的优先级。

所有现代的桌面和服务器操作系统都采用抢占式调度策略，但一些小型设备如手机则可能采用协作式调度策略，在这样的系统中，只有当一个线程调用了它的sleep()或yield()方法后才会放弃所占用的资源——也就是必须由该线程主动放弃所占用的资源。

线程阻塞
当发生如下情况时，线程将会进入阻塞状态
① 线程调用sleep()方法主动放弃所占用的处理器资源
② 线程调用了一个阻塞式IO方法，在该方法返回之前，该线程被阻塞
③ 线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有。关于同步监视器的知识、后面将存更深入的介绍
④ 线程在等待某个通知（notify）
⑤ 程序调用了线程的suspend()方法将该线程挂起。但这个方法容易导致死锁，所以应该尽量避免使用该方法
当前正在执行的线程被阻塞之后，其他线程就可以获得执行的机会。被阻塞的线程会在合适的时候重新进入就绪状态，注意是就绪状态而不是运行状态。也就是说，被阻塞线程的阻塞解除后，必须重新等待线程调度器再次调度它。

解除阻塞
针对上面几种情况，当发生如下特定的情况时可以解除上面的阻塞，让该线程重新进入就绪状态：
① 调用sleep()方法的线程经过了指定时间。
② 线程调用的阻塞式IO方法已经返回。
③ 线程成功地获得了试图取得的同步监视器。
④ 线程正在等待某个通知时，其他线程发出了个通知。
⑤ 处于挂起状态的线程被调甩了resdme()恢复方法
在这里插入图片描述
从图中可以看出，线程从阻塞状态只能进入就绪状态，无法直接进入运行状态。而就绪和运行状态之间的转换通常不受程序控制，而是由系统线程调度所决定。当处于就绪状态的线程获得处理器资源时，该线程进入运行状态；当处于运行状态的线程失去处理器资源时，该线程进入就绪状态。但有一个方法例外，调用yield()方法可以让运行状态的线程转入就绪状态。关于yield()方法后面有更详细的介纽。