并发--基本概念

2021-12-10 本文已影响0人 zhemehao819

一、基本概念

1、进程与线程

进程: 资源分配的最小单位。进程是线程的容器, 一个进程中包含多个线程, 真正执行任务的是线程
线程: 资源调度的最小单位

进程

程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的。
当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等）

线程

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

二者对比

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

2、并发与并行

并发 (concurrent)

微观串行, 宏观并行
在单核 cpu下，线程实际还是串行执行的。操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于cpu 在线程间（时间片很短）的切换非常快，给人的感觉是同时运行的。一般会将这种线程轮流使用 CPU的做法称为并发（concurrent）
将线程轮流使用cpu称为并发(concurrent)

1583408729416

并行

多核 cpu下，每个核（core）都可以调度运行线程，这时候线程可以是并行的，不同的线程同时使用不同的cpu在执行。
1583408812725

二者对比

并发（concurrent）: 是同一时间应对（dealing with）多件事情的能力
并行（parallel）: 是同一时间动手做（doing）多件事情的能力例子

3、同步和异步

以调用方的角度讲

如果需要等待结果返回才能继续运行的话就是同步
如果不需要等待就是异步

1 设计

多线程可以让方法执行变为异步的（即不要巴巴干等着）比如说读取磁盘文件时，假设读取操作花费了 5 秒钟，如果没有线程调度机制，这5秒cpu什么都做不了，其它代码都得暂停。

2 结论

比如在项目中，视频文件需要转换格式等操作比较费时，这时开一个新线程处理视频转换，避免阻塞主线程
tomcat 的异步 servlet 也是类似的目的，让用户线程处理耗时较长的操作，避免阻塞 tomcat 的工作线程
UI 程序中，开线程进行其他操作，避免阻塞 UI 线程

二、Java线程

1、线程的创建

方法1、继承于Thread类，重写run()方法。

public class CreateThread {
    public static void main(String[] args) {
        Thread myThread = new MyThread();
        // 启动线程
        myThread.start();
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("my thread running...");
    }
}

缺点：Java不支持多继承，如果继承了Thread类，那么就不能再继承其他类。另外任务与线程代码耦合，当多个线程执行一样的任务时需要多份任务代码。

下面是使用匿名内部类的方式创建：

public static void main(String[] args) {
        // 匿名内部类方式创建 Thread
        Thread t = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running");
            }
        };
        
        t.start();
        log.debug("running");
    }

方法2、使用Runnable配合Thread(推荐)

实现Runnable接口，并且实现run()方法。在创建线程时作为参数传入该类的实例即可。

public class CreateThread2 {

   private static class MyRunnable implements Runnable {
      @Override
      public void run() {
         System.out.println("my runnable running...");
      }
   }

   public static void main(String[] args) {
      Thread thread = new Thread(new MyRunnable());
      thread.start();
   }
}

使用lambda表达式简化
当一个接口带有@FunctionalInterface注解时，是可以使用lambda来简化操作的
所以方法二中的代码可以被简化为：

public class Test2 {
    public static void main(String[] args) {
        //创建线程任务
        Runnable r = () -> {
            //直接写方法体即可
            System.out.println("Runnable running");
            System.out.println("Hello Thread");
        };
        //将Runnable对象传给Thread
        Thread t = new Thread(r);
        t.start();
    }
}

通过查看源码可以发现，方法2其实还是通过使用 Thread 类中的 run 方法执行的，Thread类中的run方法是先判断target（Runnable实现类）不为空时就调用target中的run方法。

方法3、通过Callable和FutureTask创建线程

实际上FutureTask继承了Runnable，可以作为线程Thread对象的构造参数
Callable接口里也只有一个call方法，可以用lamada表达式简化

public class Test3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //需要传入一个Callable对象
        FutureTask<Integer> task = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println("线程执行!");
                Thread.sleep(1000);
                return 100;
            }
        });

        Thread r1 = new Thread(task, "t2");
        r1.start();
        //获取线程中方法执行后的返回结果
        System.out.println(task.get());
    }
}

方法4、使用线程池

class NumberThread implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

class Number2Thread implements Callable {
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for(int i = 1;i<=10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            sum+=i;
        }
        return sum;
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);//创建一个可重用固定线程数为10的线程池

        //查看该对象是哪个类造的
        System.out.println(service.getClass());//class java.util.concurrent.ThreadPoolExecutor
        //设置线程池的属性
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合使用于Runnable
        Future future = service.submit(new Number2Thread());//适合使用于Callable
        try {
            System.out.println(future.get());//输出返回值
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //3.关闭连接池
        service.shutdown();
    }
}

runnable 和 callable 有什么区别？

相同点：

都是接口
都可以编写多线程程序
都采用Thread.start()启动线程

主要区别：

Runnable 接口 run 方法无返回值；
Callable 接口 call 方法有返回值，支持泛型，和Future、FutureTask配合可以用来获取异步执行的结果
Runnable 接口 run 方法只能抛出运行时异常，且无法捕获处理；Callable 接口 call 方法允许抛出异常，可以获取异常信息
注：Callalbe接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

2、线程的运行原理

栈与栈帧

Java Virtual Machine Stacks （Java 虚拟机栈）
我们都知道 JVM 内存由堆、栈、方法区所组成，其中栈内存是给谁用的呢？

其实就是线程，每个线程启动后，虚拟机就会为其分配一块栈内存
每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

线程上下文切换（Thread Context Switch

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

线程的 cpu 时间片用完
垃圾回收
有更高优先级的线程需要运行
线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

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

状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
Context Switch 频繁发生会影响性能

3、常用方法

(1)start() vs run()

被创建的Thread对象直接调用重写的run方法时， run方法是在主线程中被执行的，这个线程对象会处一直处在新建状态。
使用 start 方式，CPU 会为创建的线程分配时间片，线程进入运行状态，然后线程调用 run 方法执行逻辑。

(2)sleep()与yield()

sleep (使线程阻塞)

调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞），可通过state()方法查看；
其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
睡眠结束后的线程未必会立刻得到执行

建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性。如：

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

在while（true）的情况下可以使用sleep来避免cpu空转（持续100%），sleep可以使当前线程状态变成time_waiting状态。（无需加锁就能实现）

yield （让出当前线程）

调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态（仍然有可能被执行），然后调度执行其它线程
具体的实现依赖于操作系统的任务调度器

线程优先级

线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用

设置方法：

thread1.setPriority(Thread.MAX_PRIORITY); //设置为优先级最高

(3)join()方法

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

Thread thread = new Thread();
//等待thread线程执行结束
thread.join();
//最多等待1000ms,如果1000ms内线程执行完毕，则会直接执行下面的语句，不会等够1000ms
thread.join(1000);

(4)interrupt()方法

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

每一个线程都有一个boolean类型的标志，此标志是当前的请求是否请求中断，默认为false。当一个线程A调用了线程B的interrupt方法时，那么线程B的是否请求的中断标志变为true。而线程B可以调用方法检测到此标志的变化。

打断的是阻塞方法时（sleep、wait、join）：如果线程B调用了阻塞方法，如果是否请求中断标志变为了true，那么它会抛出InterruptedException异常。抛出异常的同时它会将线程B的是否请求中断标志重置为false；
打断的是非阻塞方法时：只是会将打断标记为true，并不会对程序有其他影响，程序不会停止，会继续执行。如果要让线程在被打断后停下来，需要使用打断标记来判断。

while(true) {
    if(Thread.currentThread().isInterrupted()) {
        break;
    }
}

可以通过线程B的isInterrupted方法进行检测是否请求中断标志，另外还有一个静态的方法interrupted方法也可以检测标志，但是静态方法它检测完以后会自动的将是否请求中断标志位置为false。

//用于查看打断标记，返回值被boolean类型
t1.isInterrupted();
//静态方法检测中断标志，并检测完后重置false
Thread.interrupted();

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

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

代码：

public class Test7 {
    public static void main(String[] args) throws InterruptedException {
        Monitor monitor = new Monitor();
        monitor.start();
        Thread.sleep(3500);
        monitor.stop();
    }
}

class Monitor {

    Thread monitor;

    /**
     * 启动监控器线程
     */
    public void start() {
        //设置线控器线程，用于监控线程状态
        monitor = new Thread() {
            @Override
            public void run() {
                //开始不停的监控
                while (true) {
                    //判断当前线程是否被打断了
                    if(Thread.currentThread().isInterrupted()) {
                        System.out.println("处理后续任务");
                        //终止线程执行
                        break;
                    }
                    System.out.println("监控器运行中...");
                    try {
                        //线程休眠
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        //如果是在休眠的（打断的是阻塞方法）时候被打断，打断标记置为true，但抛出InterruptedException异常后又重置为false。所以此时需要再次设置为true
                        Thread.currentThread().interrupt();//非阻塞方法设置打断标记为true
                    }
                }
            }
        };
        monitor.start();
    }

    /**
     *  用于停止监控器线程
     */
    public void stop() {
        //打断线程
        monitor.interrupt();
    }
}

(5)不推荐使用的打断方法

stop方法停止线程运行（可能造成共享资源无法被释放，其他线程无法使用这些共享资源）
suspend（暂停线程）/resume（恢复线程）方法

(6)守护线程

当JAVA进程中有多个线程在执行时，只有当所有非守护线程都执行完毕后，JAVA进程才会结束。但当非守护线程全部执行完毕后，守护线程无论是否执行完毕，也会一同结束。

//将线程设置为守护线程, 默认为false
monitor.setDaemon(true);

守护线程的应用

垃圾回收器线程就是一种守护线程
Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

4、线程的状态

(1)五种状态

从 操作系统 层面来描述：

【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联（例如线程调用了start方法）
【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
【运行状态】指获取了 CPU 时间片运行中的状态
-当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
【阻塞状态】
-如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】
-等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
-与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们
【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

(2)六种状态

从 Java API 层面来描述：
根据 Thread.State 枚举，分为六种状态

NEW 线程刚被创建，但是还没有调用 start() 方法
RUNNABLE 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了操作系统层面的【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行）
BLOCKED ， WAITING ， TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分，如sleep就位TIMED_WAITING， join为WAITING状态。后面会在状态转换一节详述。
TERMINATED 当线程代码运行结束

演示线程6中状态：

@Slf4j(topic = "heyuanjun.test")
public class Thread6StatusCode {

    public static void main(String[] args) {

        //NEW
        Thread t1 = new Thread(() -> {
            log.info("----t1-----");
        }, "t1");

        //RUNNABLE
        Thread t2 = new Thread(() -> {
            while (true) {
                // log.info("----t2-----");
            }
        }, "t2");
        t2.start();

        //TERMINATED
        Thread t3 = new Thread(() -> {
            log.info("----t3-----");
        }, "t3");
        t3.start();

        //time_waiting
        Thread t4 = new Thread(() -> {
            synchronized (Thread6StatusCode.class) {
                try {
                    Thread.sleep(10 * 1000);
                    log.info("----t4-----");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t4.start();

        //waiting
        Thread t5 = new Thread(() -> {
            try {
                t2.join();
                log.info("----t5-----");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t5.start();

        //blocked
        Thread t6 = new Thread(() -> {
            synchronized (Thread6StatusCode.class) {
                log.info("----t6-----");
            }
        });
        t6.start();


        try {
            Thread.sleep(2 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("t1 线程状态：{}", t1.getState());
        log.info("t2 线程状态：{}", t2.getState());
        log.info("t3 线程状态：{}", t3.getState());
        log.info("t4 线程状态：{}", t4.getState());
        log.info("t5 线程状态：{}", t5.getState());
        log.info("t6 线程状态：{}", t6.getState());
        log.info("============结束==============");
    }
}

执行结果：

13:39:38.408 [t3] INFO heyuanjun.test - ----t3-----
13:39:40.406 [main] INFO heyuanjun.test - t1 线程状态：NEW
13:39:40.408 [main] INFO heyuanjun.test - t2 线程状态：RUNNABLE
13:39:40.408 [main] INFO heyuanjun.test - t3 线程状态：TERMINATED
13:39:40.408 [main] INFO heyuanjun.test - t4 线程状态：TIMED_WAITING
13:39:40.408 [main] INFO heyuanjun.test - t5 线程状态：WAITING
13:39:40.408 [main] INFO heyuanjun.test - t6 线程状态：BLOCKED
13:39:40.408 [main] INFO heyuanjun.test - ============结束==============
13:39:48.405 [t4] INFO heyuanjun.test - ----t4-----
13:39:48.405 [t6] INFO heyuanjun.test - ----t6-----

并发--基本概念

一、基本概念

1、进程与线程

进程

线程

二者对比

2、并发与并行

并发 (concurrent)

并行

二者对比

3、同步和异步

1 设计

2 结论

二、Java线程

1、线程的创建

方法1、继承于Thread类，重写run()方法。

方法2、使用Runnable配合Thread(推荐)

方法3、通过Callable和FutureTask创建线程

方法4、使用线程池

runnable 和 callable 有什么区别？

2、线程的运行原理

栈与栈帧

线程上下文切换（Thread Context Switch

3、常用方法

(1)start() vs run()

(2)sleep()与yield()

sleep (使线程阻塞)

yield （让出当前线程）

线程优先级

(3)join()方法

(4)interrupt()方法

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

(5)不推荐使用的打断方法

(6)守护线程

4、线程的状态

(1)五种状态

(2)六种状态

猜你喜欢

热点阅读