Java教程

JAVA并发一(Java线程)

本文主要是介绍JAVA并发一(Java线程),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

1.并发和并行的区别

并发是一个CPU在不同的时间去不同线程中执行指令。

并行是多个CPU同时处理不同的线程。

引用 Rob Pike 的一段描述:
        并发(concurrent)是同一时间应对(dealing with)多件事情的能力
        并行(parallel)是同一时间动手做(doing)多件事情的能力

2.进程与线程

进程:

        程序由指令和数据组成,但这些指令要运行,数据要读写,就必须将指令加载至 CPU,数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的。

        当一个程序被运行,从磁盘加载这个程序的代码至内存,这时就开启了一个进程。
        进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程(例如记事本、画图、浏览器、word等),也有的程序只能启动一个实例进程(例如网易云音乐、一些游戏进程等)

线程:

        一个进程之内可以分为一到多个线程。
        一个线程就是一个指令流,将指令流中的一条条指令以一定的顺序交给 CPU 执行 。
        Java 中,线程作为小调度单位,进程作为资源分配的小单位。 在 windows 中进程是不活动的,只是作为线程的容器。

        比如你可以在音乐软件听歌的同时进行搜索功能,这就需要至少两个线程完成这两个工作。

二者对比

        进程基本上相互独立的,而线程存在于进程内,是进程的一个子集 进程拥有共享的资源,如内存空间等,供其内部的线程共享。
        进程间通信较为复杂 同一台计算机的进程通信称为 IPC(Inter-process communication)
不同计算机之间的进程通信,需要通过网络,并遵守共同的协议,例如 HTTP
        线程通信相对简单,因为它们共享进程内的内存,一个例子是多个线程可以访问同一个共享变量。

        线程更轻量,线程上下文切换成本一般上要比进程上下文切换低。

3.Java线程

3.1 创建和运行线程

        方法一,直接使用 Thread;

    public void creat1(){
        Thread t1 = new Thread(){
            @Override
            public void run(){
                System.out.println("线程1启动了");
            }
        };
        t1.start();
    }

 lamda表达式写法:

        Thread t2 = new Thread(() -> 
                System.out.println("线程2启动了")
        );
        t2.start();

        方法二,实现runnable接口,使用 Runnable 配合 Thread:

    public void creat2(){
        Runnable task1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程3启动了");
            }
        };
        Thread t3 = new Thread(task1);
        t3.start();
    }

小结
        方法1 是把线程和任务合并在了一起
        方法2 是把线程和任务分开了,用 Runnable 更容易与线程池等高级 API 配合 用 Runnable 让任务类脱离了 Thread 继承体系,更灵活。

        方法三,FutureTask 配合 Thread;

        FutureTask 能够接收 Callable 类型的参数,用来处理有返回结果的情况;Runnable的run方法没有返回值。

        

    public void creat3() throws ExecutionException, InterruptedException {
        FutureTask<Integer> futureTask = new FutureTask<>(new Callable<>() {
            @Override
            public Integer call() {
                System.out.println("带返回结果的线程t4开始执行了");
                return 1;
            }
        });
        Thread t4 = new Thread(futureTask);
        t4.start();
        System.out.println("线程t4运行结束,结果为"+futureTask.get());
    }

        Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果,该方法会阻塞直到任务返回结果。

总结
        使用继承方式的好处是方便传参,你可以在子类里面添加成员变量,通过set方法设置参数或者通过构造函数进行传递。

        而如果使用Runnable方式,则只能使用主线程里面被声明为final的变量。不好的地方是Java不支持多继承,如果继承了Thread类,那么子类不能再继承其他类,而Runable则没有这个限制。

        前两种方式都没办法拿到任务的返回结果,但是Futuretask方式可以。

3.2 线程运行原理

        虚拟机栈与栈帧

        栈描述的是Java方法执行的内存模型:每个方法被执行的时候都会同时创建一个栈帧(stack frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息,是属于线程的私有的。当java中使用多线程时,每个线程都会维护它自己的栈帧!每个线程只能有一个活动栈帧,对应着当前正在执行的那个方法;

        线程上下文切换(Thread Context Switch)

因为以下一些原因导致 cpu 不再执行当前的线程,转而执行另一个线程的代码

  • 线程的 cpu 时间片用完(每个线程轮流执行,看前面并行的概念)

  • 垃圾回收

  • 有更高优先级的线程需要运行

  • 线程自己调用了 sleepyieldwaitjoinparksynchronizedlock 等方法

当 Context Switch 发生时,需要由操作系统保存当前线程的状态,并恢复另一个线程的状态,Java 中对应的概念 就是程序计数器(Program Counter Register),它的作用是记住下一条 jvm 指令的执行地址,是线程私有的。

3.3 常用方法

 3.3.1 start 和run 方法:

        被创建的Thread对象直接调用重写的run方法时, run方法是在主线程中被执行的,而不是在我们所创建的线程中执行。所以如果想要在所创建的线程中执行run方法,需要使用Thread对象的start方法。

3.3.2 sleep()方法:

        在介绍sleep之前,首先介绍一下线程的状态:

        操作系统层面,线程的五种状态:

 

  1. 初始状态,仅仅是在语言层面上创建了线程对象,即Thead thread = new Thead();,还未与操作系统线程关联

  2. 可运行状态,也称就绪状态,指该线程已经被创建,与操作系统相关联,等待cpu给它分配时间片就可运行

  3. 运行状态,指线程获取了CPU时间片,正在运行

    1. 当CPU时间片用完,线程会转换至【可运行状态】,等待 CPU再次分配时间片,会导致我们前面讲到的上下文切换

  4. 阻塞状态

    1. 如果调用了阻塞API,如BIO读写文件,那么线程实际上不会用到CPU,不会分配CPU时间片,会导致上下文切换,进入【阻塞状态】

    2. 等待BIO操作完毕,会由操作系统唤醒阻塞的线程,转换至【可运行状态】

    3. 与【可运行状态】的区别是,只要操作系统一直不唤醒线程,调度器就一直不会考虑调度它们,CPU就一直不会分配时间片

  5. 终止状态,表示线程已经执行完毕,生命周期已经结束,不会再转换为其它状态

        线程状态之六种状态:

这是从 Java API 层面来描述的,我们主要研究的就是这种。

 

  1. NEW 跟五种状态里的初始状态是一个意思

  2. RUNNABLE 是当调用了 start() 方法之后的状态,注意,Java API 层面的 RUNNABLE 状态涵盖了操作系统层面的【可运行状态】、【运行状态】和【io阻塞状态】(由于 BIO 导致的线程阻塞,在 Java 里无法区分,仍然认为是可运行)

  3. BLOCKED WAITING TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分。

基本状态介绍完了,然后可以重新介绍sleep状态了 :

sleep

  1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态(阻塞)

  2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程,那么被打断的线程这时就会抛出 InterruptedException异常【注意:这里打断的是正在休眠的线程,而不是其它状态的线程】

  3. 睡眠结束后的线程未必会立刻得到执行(需要分配到cpu时间片)

  4. 建议用 TimeUnit 的 sleep() 代替 Thread 的 sleep()来获得更好的可读性:

    //休眠一秒
    TimeUnit.SECONDS.sleep(1);
    //休眠一分钟
    TimeUnit.MINUTES.sleep(1);

 3.3.3 yield()方法:

        让出当前线程。

        1. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态(仍然有可能继续被执行),然后调度执行其它线程;
        2. 具体的实现依赖于操作系统的任务调度器。

        yield使cpu调用其它线程,但是cpu可能会再分配时间片给该线程;而sleep需要等过了休眠时间之后才有可能被分配cpu时间片

3.3.4 join()方法:

        用于等待某个线程结束。哪个线程调用join()方法,就等待哪个线程结束,然后再去执行其他线程。如在主线程中调用ti.join(),则是主线程等待t1线程结束;

    private static void test1() throws InterruptedException {
        log.debug("开始");
        Thread t1 = new Thread(() -> {
            log.debug("开始");
            sleep(1);
            log.debug("结束");
            r = 10;
        },"t1");
        t1.start();
        t1.join();
        log.debug("结果为:{}", r);
        log.debug("结束");
    }

 

 流程图:

main函数开始,运行到t1.start,然后阻塞到t1.join等待t1运行结束,

3.3.5 interrupt 方法

用于打断阻塞(sleep wait join…)的线程。 处于阻塞状态的线程,CPU不会给其分配时间片。

sleep,wait,join 的线程,这几个方法都会让线程进入阻塞状态:

        如果一个线程在在运行中被打断,线程并不会暂停,只是调用方法,打断标记会被置为true。
        如果是打断因sleep wait join方法而被阻塞的线程,会将打断标记置为false

//用于查看打断标记,返回值被boolean类型
t1.isInterrupted();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while(true) {
                boolean interrupted = Thread.currentThread().isInterrupted();
                if(interrupted) {
                    System.out.println("被打断了, 退出循环");
                    break;
                }
            }
        }, "t1");
        t1.start();
        Thread.sleep(1000);
        System.out.println("interrupt");
        t1.interrupt();
    }

interrupt方法的应用——两阶段终止模式:

        当我们在执行线程一时,想要终止线程二,这是就需要使用interrupt方法来优雅的停止线程二。、

        如下所示:因为线程的isInterrupted()方法可以取得线程的打断标记,

        如果线程在睡眠sleep期间被打断,打断标记是不会变的,为false,但是sleep期间被打断会抛出异常,我们据此手动设置打断标记为true

        如果是在程序正常运行期间被打断的,那么打断标记就被自动设置为true。处理好这两种情况那我们就可以放心地来料理后事啦!

 实现代码:

public class TwoStepInterupter {
    Thread t1;
    public void start(){
        t1 = new Thread(() -> {
            while(true){
                if(Thread.currentThread().isInterrupted()){
                    System.out.println("处理后事");
                    System.out.println("处理后事完毕,线程正常结束");
                    break;
                }
                System.out.println("监控器运行中,监控是否被打断");
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                    //sleep 被打断后会抛出错误 ,但是打断标记不会被设置为True 所以需要再次执行打断方法。
                    Thread.currentThread().interrupt();
                }
            }
        });
        t1.start();
    }

    public void stop(){
        t1.interrupt();
    }

    @Test
    public void test() throws InterruptedException {
        start();
        Thread.sleep(2000);
        stop();
    }
}

3.3.6 sleep,yiled,wait,join 对比

补充:

  1. sleep,join,yield,interrupted是Thread类中的方法

  2. wait/notify是object中的方法

sleep 不释放锁、释放cpu

join 释放锁、抢占cpu

yiled 不释放锁、释放cpu

wait 释放锁、释放cpu

 

3.4 守护线程

        默认情况下,java进程需要等待所有的线程结束后才会停止,但是有一种特殊的线程,叫做守护线程,在其他线程全部结束的时候即使守护线程还未结束代码未执行完java进程也会停止。普通线程t1可以调用t1.setDeamon(true); 方法变成守护线程;

        垃圾回收器线程就是一种守护线程

        Tomcat 中的 Acceptor 和 Poller 线程都是守护线程,所以 Tomcat 接收到 shutdown 命令后,不会等待它们处理完当前请求

这篇关于JAVA并发一(Java线程)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!