多线程基础及常见面试题

最新推荐文章于 2024-03-06 20:22:17 发布

我们new一个

最新推荐文章于 2024-03-06 20:22:17 发布

阅读量415

点赞数

文章标签： java

本文链接：https://blog.csdn.net/a159951333/article/details/124257825

版权

1.多线程基础

1.1 基本概念

进程：
- 程序是静态的，进程就是程序的一次动态执行，是系统进行资源分配和调度的一个单位，当程序进入内存运行时，即为进程，一个程序包含一个或多个进程
线程：
- 是进程的组成单元，一个进程包含一个或多个线程，每个线程负责单独执行一个任务
进程和线程的区别
- 一个进程包含一个或多个线程
- 每个进程都有自己独立的内存空间，线程没有自己独立的内存空间，线程共享所在进程的内存空间
- 进程是重量级的单元，需要系统资源比较多，线程是轻量级单元，需要资源比较少
多进程和多线程
- 多进程是操作系统可以同时运行多个进程。一个CPU内核一个时间只能执行一个进程，CPU会在多个进程之间进行来回切换，因为速度特别快，用户感觉不到
- 多线程是一个进程里面有多个线程，CPU执行进程时会来回切换里面所有的线程，每个线程会分配到一定的CPU的执行时间（CPU时间片）

1.2 基础常见面试题

1.2.1 线程创建的三种方式及区别

常见的创建方式有三种：1.继承Thread类 2.实现Runnable接口 3.实现Callable接口

继承Thread类

优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this即可。
缺点：java是单继承的，故无法再继承其他类

实现Runnable接口

优点：线程类只是实现了Runnable接口，还可以继承其他类。这种情况下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将cpu代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法

Runnable和Callable的区别

Callable：可以抛出异常，异步计算结果，可以通过FutureTask的get方法同步获取结果

Runnable规定的方法是run()，Callable规定的是call()
Runnable的任务执行后无返回值，Callable的任务执行后有返回值
call()方法可以抛出异常，run()方法不可以，因为run()方法本身没有抛出异常，所以自定义的线程类在重写run()方法的时候也无法抛出异常
运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消人物的执行，还可获取执行结果

1.2.2 start()和run()的区别

start()方法用来，开启线程，但是线程开启后并没有立即执行，他需要获取cpu的执行权才可以执行
run()方法是由jvm创建完本地操作系统级线程后回调的方法，不可以手动调用（否则就是普通方法）

1.2.3 线程的生命周期

创建,就绪,运行,阻塞,死亡

1.2.4 线程调度的基本方法

线程调度指按照特定机制为多个线程分配CPU的使用权

方法	说明
void setPriority(int newPriority)	更改线程的优先级
static void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠
void join()	等待该线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程
boolean isAlive()	测试线程是否处于活动状态

注意：join容易出现理解错误

线程A执行了线程B的join方法，线程A必须要等待线程B执行完之后再执行，线程A才能完成自己的工作

1.2.5 守护线程

守护线程：常见的是GC，通常是线程执行完毕，守护线程完毕，生命周期是跟随者其他线程

示例代码
package cn.qf.threaddemo.demo1;

import java.util.concurrent.ExecutionException;

public class DaemonThread {

    private static class UseThread extends Thread {
        @Override
        public void run() {
            try {
                while (!isInterrupted()) {
                    System.out.println(Thread.currentThread().getName() + " I am extends Thread.");
                }
                System.out.println(Thread.currentThread().getName() + " interrupt flag is " + isInterrupted());
            } finally {
                System.out.println("...........finally");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        UseThread useThread = new UseThread();
        //useThread.setDaemon(true);
        useThread.start();
        Thread.sleep(5);
        //useThread.interrupt();
        System.out.println("主线程执行完毕");
    }
}

1.2.6 synchronized

synchornized可以修饰方法跟代码块，核心本质是锁对象，如果是static修饰的，也可以锁类变量
线程拥有锁，锁的是对象，对象的头信息中，指向的指针是线程
偏向锁,自旋锁,轻量锁,重量锁

偏向锁：当程序没有竞争,取消同步操作,发生竞争时,升级为轻量锁

轻量锁：(对象的头信息markword中存放了锁的状态和线程持有的索)如果当前线程用cas将markword锁记录(Lock Record)指针替换成功,获取轻量锁，如果失败尝试自旋,成功获取轻量锁,失败膨胀为重量锁

自旋锁：默认10次,JDK1.8变成自适应自旋,会根据上一个线程自旋的时间的状态来自动增减对该锁的自旋次数,(相当于循环获取锁)

重量锁：竞争失败后,阻塞

修饰方法：

通过ACC_SYNCHORDIZED标记来实现同步，方法级的同步时隐式的
同步方法在常量池中会有一个ACC_SYNCHORDIZED的标识，当线程进入某个方法的时候,会判断有没有这个标识，如果有会获得一个监视器锁(monitorenter)，运行结束释放锁，有其他线程在这个过程中访问该方法会被阻塞，方法出异常时,这个锁会被释放

修饰代码块：