Java并发编程

二炮

已于 2022-03-09 16:09:58 修改

阅读量215

点赞数 1

分类专栏： Java 文章标签： java lambda

于 2022-03-08 00:36:23 首次发布

本文链接：https://blog.csdn.net/EP68686688/article/details/123342668

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

进程、线程、协程的关系

进程： 本质上是一个独立执行的程序，进程是操作系统进行资源分配和调度的基本概念，操作系统进行资源分配和调度的一个独立单位。
线程： 是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个进程中可以并发多个线程，每条线程执行不同的任务，切换受系统控制。
协程： 又称为微线程，是一种用户态的轻量级线程，协程不像线程和进程需要进行系统内核上的上下文切换，协程的上下文切换是由用户自己决定的，有自己的上下文，所以说是轻量级的线程，也称之为用户级别的线程就叫协程，一个线程可以多个协程,线程进程都是同步机制，而协程则是异步
Java的原生语法中并没有实现协程,目前python、Lua和GO等语言支持
关系： 一个进程可以有多个线程，它允许计算机同时运行两个或多个程序。线程是进程的最小执行单位，CPU的调度切换的是进程和线程，进程和线程多了之后调度会消耗大量的CPU，CPU上真正运行的是线程，线程可以对应多个协程

在这里插入图片描述

协程对于多线程的优缺点

优点：
非常快速的上下文切换，不用系统内核的上下文切换，减小开销
单线程即可实现高并发，单核CPU可以支持上万的协程
由于只有一个线程，也不存在同时写变量的冲突，在协程中控制共享资源不需要加锁
缺点：
协程无法利用多核资源，本质也是个单线程
协程需要和进程配合才能运行在多CPU上
目前Java没成熟的第三方库，存在风险
调试debug存在难度，不利于发现问题

并行和并发的区别

并行 parallellism：
多个CPU上同时处理多个任务，一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行
并发 concurrency：
一台处理器上同时处理任务,这个同时实际上是交替处理多个任务，程序中可以同时拥有两个或者多个线程，当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程,它只能把CPU运行时间划分成若干个时间段,再将时间段分配给各个线程执行
例子：项目经理A和3个程序B C D的故事
并行：直接找3个项目经理分别分配给3个程序员
并发：A给B讲完需求，B自己去实现，期间A继续给C和D讲，不用等待某个程序员去完成，期间项目经理没空闲下来

Java实现多线程的方式

继承Thread类
继承Thread，重写里面run方法，创建实例，执行start
优点：代码编写最简单直接操作
缺点：没返回值，继承一个类后，没法继承其他的类，拓展性差

// 继承Thread类
public class ThreadDemo extends Thread{
    @Override
    public void run() {
        System.out.println("继承Thread实现多线程，名称："+Thread.currentThread().getName());
    }
}

// main方法(主线程)
public class Main {
    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        threadDemo.setName("demo");		// 给线程命名
        threadDemo.start();     // 开启threadDemo线程
        System.out.println("主线程名称："+Thread.currentThread().getName());
    }
}

运行结果：

实现Runnable接口
自定义类实现Runnable，实现里面run方法，创建Thread类，使用Runnable接口的实现对象作为参数传递给Thread对象，调用strat方法
优点：线程类可以实现多个几接口，可以再继承一个类
缺点：没返回值，不能直接启动，需要通过构造一个Thread实例传递进去启动

// 实现Runnable接口
public class RunnableDemo implements Runnable{
    @Override
    public void run() {
        System.out.println("实现Runnable接口实现多线程，名称："+Thread.currentThread().getName());
    }
}

// main方法(主线程)
public class Main {
    public static void main(String[] args) {
        // 实现Runnable接口实现多线程
//        RunnableDemo runnableDemo = new RunnableDemo();
//        Thread thread = new Thread(runnableDemo);
//        thread.setName("Runnable");
//        thread.start();
//        System.out.println("主线程名称："+Thread.currentThread().getName());

        // 采用lambda表达式 【此方法不需要再定义ThreadDemo类】
        Thread thread = new Thread(() -> {
            System.out.println("实现Runnable接口实现多线程，名称："+Thread.currentThread().getName());
        });
        thread.setName("Runnable");
        thread.start();
        System.out.println("主线程名称："+Thread.currentThread().getName());
    }
}

运行结果：

通过线程池创建线程
自定义Runnable接口，实现run方法，创建线程池，调用执行方法并传入对象
优点：安全高性能，复用线程
缺点：jdk5后才支持，需要结合Runnable进行使用

// 通过线程池+Runnable实现多线程
public class XianChengChi implements Runnable{
    @Override
    public void run() {
        System.out.println("通过线程池+Runnable实现多线程，名称："+Thread.currentThread().getName());
    }
}

// main方法(主线程)
public class Main {
    public static void main(String[] args) {
        // 通过线程池+Runnable实现多线程
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {		// 有三个线程，打印多几个线程
            executorService.execute(new XianChengChi());
        }
        System.out.println("主线程名称："+Thread.currentThread().getName());
        executorService.shutdown();     // 关闭线程池
    }
}

运行结果：
在这里插入图片描述
一般常用实现多线程的方式是实现Runnable接口和第三种线程池+Runnable，因为简单方便扩展，和高性能 (池化的思想)

Java线程常见的基本状态

JDK的线程状态分6种，JVM里面9种，我们一般说JDK的线程状态
常见的5种状态：

创建(NEW)： 生成线程对象，但是并没有调用该对象start(), new Thread()

就绪(Runnable)： 当调用线程对象的start()方法，线程就进入就绪状态，但是此刻线程调度还没把该线程设置为当前线程，就是没获得CPU使用权。如果线程运行后，从等待或者睡眠中回来之后，也会进入就绪状态

注意:有些文档把就绪和运行两种状态统一称为 “运行中”

运行(Running)： 程序将处于就绪状态的线程设置为当前线程，即获得CPU使用权，这个时候线程进入运行状态，开始运行run里面的逻辑

阻塞(Blocked)：
等待阻塞： 进入该状态的线程需要等待其他线程作出一定动作(通知或中断)，这种状态的话CPU不会分配过来，他们需要被唤醒，可能也会无限等待下去。比如调用wait(状态就会变成WAITING状态)，也可能通过调用sleep(状态就会变成TIME_WAITING), join或者发出IO请求，阻塞结束后线程重新进入就绪状态

同步阻塞： 线程在获取synchronized同步锁失败，即锁被其他线程占用，它就会进入同步阻塞状态

备注：相关资料会用细分下面的状态
    等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
    超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回

死亡(TERMINATED)： 一个线程run方法执行结束，该线程就死亡了，不能进入就绪状态

多线程开发里面常用的方法，sleep/yield/join wait/notify/notifyAll

sleep
	属于线程Thread的方法
	让线程暂缓执行，等待预计时间之后再恢复
	交出CPU使用权，不会释放锁
	进入阻塞状态TIME_WAITING，睡眠结束变为就绪Runnable

yield
	属于线程Thread的方法
	暂停当前线程的对象，去执行其他线程
	交出CPU使用权，不会释放锁，和sleep类似
	作用：让相同优先级的线程轮流执行，但是不保证一定轮流
	注意：不会让线程进入阻塞状态，直接变为就绪Runnable，只需要重新获得CPU使用权

join  
	属于线程Thread的方法
	在主线程上运行调用该方法，会让主线程休眠，不会释放已经持有的对象锁
	让调用join方法的线程先执行完毕，在执行其他线程
	类似让救护车警车优先通过


wait
	属于Object的方法
	当前线程调用对象的wait方法，会释放锁，进入线程的等待队列
	需要依靠notify或者notifyAll唤醒，或者wait(timeout)时间自动唤醒

notify
	属于Object的方法
	唤醒在对象监视器上等待的单个线程，选择是任意的

notifyAll
	属于Object的方法
	唤醒在对象监视器上等待的全部线程