java面试笔记五:线程、进程、以及协程,java多线程实现方式,java线程常见状态
发布日期:2021-05-28 16:44:45 浏览次数:11 分类:技术文章

本文共 7348 字,大约阅读时间需要 24 分钟。

java面试笔记五:线程、进程、以及协程

文章目录

进程、线程、协程

  1. 线程,协程,进程的关系

进程:本质上是一个独立执行的程序,进程是操作系统进行资源分配和调度的基本概念,操作系统进行资源分配和调度的一个独立单位。

线程:是操作系统能够进行运算调度的最小单位,它包含在进程中,是进程的实际操作单位,一个进程可以并发多个线程,每个线程执行的任务不同,切换受系统控制,一个进程的所有线程共享进程的公共资源。

协程:又称为微线程,是一种用户态的轻量级线程,协程不像线程和进程那样需要系统内核的上下文切换,协程的上下文由用户决定,有自己的上下文,一个线程可以有多个协程,线程和进程是同步机制的,而协程是异步的。java原生语法没有实现协程,目前python、lua、Go支持协程。

cpu上真正运行的是线程。

  1. 协程对于多线程有什么优缺点?

优点:

1、非常快速的进行上下文切换,不用系统内核的上下文切换,减小开销。

2、单线程即可实现高并发,单核cpu可以支持上万的协程。

3、由于只有一个线程,也不存在同时写变量的冲突,在协程中控制共享资源不需要加锁。

缺点:

1、协程无法利用多核资源,本质也是一个单线程

2、协程需要进程配合才能运行在多cpu上,

3、目前java没有成熟的第三方库,存在风险。

4、调试bug存在难度,不利于发现问题。

并发和并行

  1. 并发和并行的区别

并发:一台处理器上同时处理任务,这个同是是通过划分cpu处理的时间段,交替执行多个任务的。不是真正意义上的同时。

并行:多个cpu上同时处理多个任务,一个cpu执行一个进程,另一个cpu可以执行另一个进程,两个进程互不抢占资源,可以同时进行。

并发指在一段时间内处理多个任务,并行指同一时刻,多个任务同时执行。

java实现多线程有几种方式?有什么不同?

  1. 继承Thread

继承Thread,然后重写里面的run方法,创建实例,执行start

优点:

1、代码编写简单,直接操作。

缺点:

1、没有返回值,继承一个类后没法继承其他类,扩展比较差。

public class ThreadDemo1 extends Thread{
@Override public void run() {
// TODO Auto-generated method stub System.out.println("继承Thread实现多线程"+Thread.currentThread().getName()); }}
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub ThreadDemo1 threadDemo1=new ThreadDemo1(); threadDemo1.setName("demo1"); threadDemo1.start(); System.out.println("主线程名称"+Thread.currentThread().getName()); }}
  1. 实现Runable

自定义类实现Runnable,实现里面的run方法,创建Thread类,使用Runnable接口的实现对象,作为参数传递给Thread对象,调用start方法。

优点:

​ 线程类可以实现多个接口,可以再继承一个类。

缺点:

​ 没有返回值,不能直接启动,需要通过构造一个Thread实例传递进去启动。

public class ThreadDemo2 implements Runnable{
@Override public void run() {
// TODO Auto-generated method stub System.out.println("通过Runnable实现多线程,名称:"+Thread.currentThread().getName()); }}
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub //ThreadDemo1 threadDemo1=new ThreadDemo1(); ThreadDemo2 threadDemo2 =new ThreadDemo2(); Thread thread =new Thread(threadDemo2); thread.setName("demo2"); thread.start(); System.out.println("主线程名称"+Thread.currentThread().getName()); }}

使用Lambda表达式创建匿名内部类线程

public class Main {
public static void main(String[] args) {
//匿名内部类使用Lambda表达式 Thread thread2=new Thread(()->{
System.out.println("通过Runnable实现多线程,名称"+Thread.currentThread().getName()); }); thread2.setName("demo2,Lambda"); thread2.start(); System.out.println("主线程名称"+Thread.currentThread().getName()); }}
  1. 通过Callable方式实现

创建Callable接口的实现类,并实现call方法。结合FutureTask类包装Callable对象,实现多线程。

优点:

​ 有返回值,扩展性也高

缺点:jdk5之后才支持,需要重写call方法,结合多个类比如:FutureTask和Thread类

public class Main {
public static void main(String[] args) {
//MyTask myTask=new MyTask(); //futureTask继承了Runnable,可以放在Thread中启动 //FutureTask futureTask=new FutureTask(myTask); Thread thread3=new Thread(futureTask); thread3.setName("demo3"); thread3.start(); System.out.println("主线程名称"+Thread.currentThread().getName()); //get()可以设置超时时间,超过多少时间就报异常。 try {
System.out.println((String)futureTask.get()); } catch (InterruptedException e) {
// TODO Auto-generated catch block //阻塞等待中被中断, 则抛出 e.printStackTrace(); } catch (ExecutionException e) {
// TODO Auto-generated catch block //执行过程中,发送异常被抛出 e.printStackTrace(); } }}
public class MyTask implements Callable{
@Override public Object call() throws Exception {
// TODO Auto-generated method stub System.out.println("通过Callable实现多线程,名称:"+Thread.currentThread().getName()); return "这是返回值"; }}

使用Lambda表达式

public class Main {
public static void main(String[] args) {
//使用lambda FutureTask futureTask=new FutureTask(()->{
System.out.println("通过Callable实现多线程,名称:"+Thread.currentThread().getName()); return "使用lambda"; }); //MyTask myTask=new MyTask(); //futureTask继承了Runnable,可以放在Thread中启动 //FutureTask futureTask=new FutureTask(myTask); Thread thread3=new Thread(futureTask); thread3.setName("demo3"); thread3.start(); System.out.println("主线程名称"+Thread.currentThread().getName()); //get()可以设置超时时间,超过多少时间就报异常。 try {
System.out.println((String)futureTask.get()); } catch (InterruptedException e) {
// TODO Auto-generated catch block //阻塞等待中被中断, 则抛出 e.printStackTrace(); } catch (ExecutionException e) {
// TODO Auto-generated catch block //执行过程中,发送异常被抛出 e.printStackTrace(); } }}
  1. 通过线程池创建线程

自定义Runnable接口,实现run方法,创建线程池,调用执行方法传入对象。

优点:安全性能高,复用线程

缺点:jdk5才有,需要结合Runnable进行使用。

public class Main2 {
public static void main(String[] args) {
// TODO Auto-generated method stub ExecutorService executorService=Executors.newFixedThreadPool(3); for(int i=0;i<10;i++) {
executorService.execute(new ThreadDemo4()); } System.out.println("主线程名称"+Thread.currentThread().getName()); //关闭线程池 executorService.shutdown(); }}
public class ThreadDemo4 implements Runnable{
@Override public void run() {
// TODO Auto-generated method stub System.out.println("通过线程池+Runnable实现多线程,名称:"+Thread.currentThread().getName()); }}

一般常用的有Runnable和第四种线程池+Runnable,简单方便扩展,和高性能(池化思想) 。

java线程常见的基本状态

  1. java线程常见的基本状态有哪些?

jdk线程状态分6种,jvm里面9种,我们一般说jdk的线程状态

常见5种状态:

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

就绪:(Runnable)当调用start()方法,线程就进入就绪状态,但是此刻线程调度还没把该线程设置为当前线程,就没有获得cpu使用权。如果线程运行后,从等待或者睡眠中回过来后,也会进入就绪状态。其实就绪就是进入了获取cpu的等待队列。

运行:(Running)获得cpu使用权,开始运行里面的逻辑。

阻塞:(Blocked)(wait,TIMED_WAITING):

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

​ 同步阻塞:线程在获取Synchronized同步锁失败,锁被其他线程占用,它就会进入同步阻塞状态。

​ 备注:

​ 等待:(WAITING)进入该状态的线程需要等待其他线程做出一些特定动作,(通知或中断)

​ 超时等待:(TIMED_WAITING)该状态不同于WAITING,它可以在指定的时间后自行返回。

死亡:(TERMINATED)一个线程run方法执行结束,该线程就死亡了,死亡后的线程不能进入就绪状态。

  1. 画一下线程基本状态转换图

线程基本状态转换

  1. 多线程业务场景?

1、异步任务:用户注册,记录日志

2、定期备份日志,备份数据库

3、分布式计算:Hadoop处理任务,mapreduce,master-work(单机单进程)

4、服务器编程:Socket网络编程,一个连接一个线程。

  1. 举例几个线程不安全的数据结构

HashMap,ArrayList,LinkedList

  1. java中有哪些方法保证线程安全?

1、加锁,Synchronized或者reentrantLock

2、使用volatile声明变量,轻量级同步,不能保证原子性。

3、使用线程安全的安全类(原子类,并发容器,同步容器)ConcurrentHashMap,CopyOnWriteArrayList等。原子类(Atomicxxx)ThreadLocal本地私有变量/信号量Semaphore等。

  1. 了解Volatile关键字,解释一下,和Synchronized有多大区别

Volatile是轻量级的Synchronized,保证了共享变量的可见性,被Volatile修饰的变量如果值发生了变化,其他线程立刻可见,避免出现脏读现象。

Volatile:保证了可见性,但是不能保证原子性。

Synchronized:保证可见性,保证原子性。

使用场景:

1、不能修饰写入操作,依赖当前值的变量,比如Num++,num=num+1,不是原子操作,看起来是,但是jvm内部不是。

2、由于禁止了指令重排,所以JVM相关的优化没了,效率会偏弱。

  1. 为什么会出现脏读?

JAVA内存模型简称:JMM

JMM规定所有变量存在主内存,每个线程有自己的工作内存。线程对变量的操作都是在工作内存中进行的,不能直接对主内存进行操作。

使用Volatile修改的变量:

​ 每次读取前必须是主内存中最新的值。

​ 每次写入需要立刻写到主内存中。

Volatile关键字修饰的变量随时看到的自己最新的值,加入线程a修改了值,线程b立刻可以看到。

主内存和工作内存

  1. 解释一下指令重排

指令重排分两类:编译器重排,和运行时重新排序

JVM在编译java代码或者cpu执行jvm字节码时,对现有的指令进行重新排序,主要目的是优化运行效率。(不会改变程序执行结果)‘

虽然指令排序会提高效率,但是多线程可能会影响结果,可以通过内存屏障解决。

内存屏障:是屏障指令,使cpu对屏障指令之前和之后的内存操作执行结果进行对比的一种约束。

  1. 知道happen-before吗?能否简单解释一下

先行发生原则:Volatile的内存可见性就体现了这一原则。

//线程a

int j=1;

//线程b

int k=j;

//线程c

int j=2;

八大原则:

​ 1、程序次序原则

​ 2、管程锁定原则

​ 3、Volatile变量规则

​ 4、线程启动规则

​ 5、线程中断规则

​ 6、线程终止规则

​ 7、对象终结规则

​ 8、传递性

转载地址:https://blog.csdn.net/qq_33322074/article/details/104852041 如侵犯您的版权,请留言回复原文章的地址,我们会给您删除此文章,给您带来不便请您谅解!

上一篇:java面试笔记六:并发编程,进程调度算法,线程里面的锁,CAS和ABA问题
下一篇:java面试笔记四:集合框架Map集合

发表评论

最新留言

第一次来,支持一个
[***.219.124.196]2024年02月28日 08时55分21秒