关于Java多线程的40个问题。

一、Thread类基础

Q: Thread的deprecated过期方法是哪3个?作用是啥
A:

  • stop(), 终止线程的执行。
  • suspend(), 暂停线程执行。
  • resume(), 恢复线程执行。

Q: 废弃stop的原因是啥?
A:调用stop时,会直接终止线程并释放线程上已锁定的锁,线程内部无法感知,并且不会做线程内的catch操作!即线程内部不会处理stop后的烂摊子。如果其他线程等在等着上面的锁去取数据, 那么拿到的可能是1个半成品。

变成题目的话应该是下面这样,问会输出什么?

public class Test {

    public static void main(String[] args) throws InterruptedException {

        System.out.println("start");
        Thread thread = new MyThread();
        thread.start();
        Thread.sleep(1000);
        thread.stop();
        // thread.interrupt();

    }
}

class MyThread extends Thread {
    public void run() {
        try {
            System.out.println("run");
            Thread.sleep(5000);
        } catch (Exception e) {
            //处理烂摊子,清理资源
            System.out.println("clear resource!");
        }
    }
}

答案是输出 start和run,但是不会输出clear resource

Q: stop的替代方法是什么?
A: interrupt()。
调用thread.interrupt()终止时, 不会直接释放锁,可通过调用interrupt()或者捕捉sleep产生的中断异常,来判断是否被终止,并处理烂摊子。

上题把thread.stop()改成thread.interrupt(),在Thread.sleep()过程中就会抛出interrupException(注意,InterrupExcetpion是sleep抛出的)因此就会输出clear resource。如果没有做sleep操作, 可以用isInterrupted()来判断自己这个线程是否被终止了,来做清理。

另外注意一下interrupt和isInterrupted的区别:

Q: suspend/resume的废弃原因是什么?
A: :调用suspend不会释放锁。
如果线程A暂停后,他的resume是由线程B来调用的,但是线程B又依赖A里的某个锁,那么就死锁了。例如下面这个例子,就要知道会引发死锁:

public class Test {
    public static Object lockObject = new Object();
    public static void main(String[] args) throws InterruptedException {

        System.out.println("start");
        Thread thread = new MyThread();
        thread.start();
        Thread.sleep(1000);

        System.out.println("主线程试图占用lockObject锁资源");
        synchronized (Test.lockObject) {
            // 用Test.lockObject做一些事
            System.out.println("做一些事");
        }
        System.out.println("恢复");
        thread.resume();

    }
}

class MyThread extends Thread {
    public void run() {
        try {
            synchronized (Test.lockObject) {
                System.out.println("占用Test.lockObject");
                suspend();
            }
            System.out.println("MyThread释放TestlockObject锁资源");
        }
        catch (Exception e){}
    }
}

答案输出

MyThread内部暂停后,外部的main因为没法拿到锁,所以无法执行后面的resume操作。

Q: 上题的suspend和resume可以怎么替换,来解决死锁问题?
A: 可以用wait和noitfy来处理(不过尽量不要这样设计,一般都是用run内部带1个while循环的)

public class Test {
    public static Object lockObject = new Object(); //拿来做临时锁对象
    public static void main(String[] args) throws InterruptedException {

        Thread thread = new MyThread();
        thread.start();
        Thread.sleep(1000);

        System.out.println("主线程试图占用lockObject锁资源");
        synchronized (Test.lockObject) {
            // 用Test.lockObject做一些事
            System.out.println("做一些事");
        }
        System.out.println("恢复");

        synchronized (Test.lockObject) {
            Test.lockObject.notify();
        }

    }
}

class MyThread extends Thread {
    public void run() {
        try {
            synchronized (Test.lockObject) {
                System.out.println("占用Test.lockObject");
                Test.lockObject.wait();
            }
            System.out.println("MyThread释放TestlockObject锁资源");
        }
        catch (Exception e){}
    }
}

如此执行,结果正常:

Q: 下面这例子为什么会运行异常,抛出IllegalMonitorStateException错误?

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new MyThread();
        thread.start();
        thread.notify();
    }

A: notify和wait的使用前提是必须持有这个对象的锁, 即main代码块 需要先持有thread对象的锁,才能使用notify去唤醒(wait同理)。

改成下面就行了:

        Thread thread = new MyThread();
        thread.start();
        synchronized (thread) {
            thread.notify();
        }

Q: Thread.sleep()和Object.wait()的区别
A:sleep不会释放对象锁, 而wait会释放对象锁。

Q:Runnable接口和Callable的区别。
A: Callable可以和Futrue配合,并且启动线程时用的时call,能够拿到线程结束后的返回值,call方法还能抛出异常。

Q:thread.alive()表示线程当前是否处于活跃/可用状态。
活跃状态: 线程已经启动且尚未终止。线程处于正在运行或准备开始运行的状态,就认为线程是“存活的

thread.start()后,是否alive()一定返回true?

public class Main {
    public static void main(String[] args) {
        TestThread tt = new TestThread();
        System.out.println("Begin == " + tt.isAlive());
        tt.start();
        System.out.println("end == " + tt.isAlive());
    }
}

A:不一定,有可能在打印时,线程已经运行结束了,或者start后,还未真正启动起来(就是还没进入到run中)

Q: 线程A如下:

public class A extends Thread {
    @Override
    public void run() {
        System.out.println("this.isAlive()=" + this.isAlive());
    }
}

把线程A作为构造参数,传给线程B

A a = new A();
Thread b = new Thread(a);
b.start()

此时会打印什么?
A:此时会打印false!

因为把a作为构造参数传入b中, b执行start时, 实际上是在B线程中去调用了 A对象的run方法,而不是启用了A线程。

如果改成

A a = new A();
a.start()

那么就会打印true了

Q:把FutureTask放进Thread中,并start后,会正常执行callable里的内容吗?

public static void main(String[] args) throws Exception {
    Callable<Integer> callable = () -> {
    System.out.println("call 100");
    return 100;
    };
 
    FutureTask<Integer> task = new FutureTask<>(callable);
    Thread thread = new Thread(task);
    thread.start();
}

A:能正常打印

二、synchronized关键字

  • 即可作为方法的修饰符,也可以作为代码块的修饰符
  • 注意修饰方法时,并不是这个方法上有锁, 而是调用该方法时,需要取该方法所在对象上的锁。
class A{
     synchroized f(){
     }   
}

即调用这个f(), 并不是说f同一时刻只能进入一次,而是说进入f时,需要取到A上的锁。

Q: 调用下面的f()时,会出现死锁吗?

class A{
     synchroized f(){
        t()
     }
 
     synchroized t(){
     }
}

A:不会。
1个线程内, 可以重复进入1个对象的synchroized 块。

  • 原理:
    当线程请求自己的锁时。JVM会记下锁的持有者,并且给这个锁计数为1。如果该线程再次请求自己的锁,则可以再次进入,计数为2。退出时计数-1,直到全部退出时才会释放锁。

Q:2个线程同时调用f1和f2会产生同步吗?

class A{
	private static synchronized void f1(){};
	private synchronized void f2(){};
}

A:不会产生同步。二者不是1个锁。
f1是类锁,等同于synchronized(A.class)
f2是对象锁。

三、其他的同步工具

CountDownLatch

final CountDownLatch latch = new CountDownLatch(2);

2是计数器初始值。

然后执行latch.await()时, 就会阻塞,直到其他线程中把这个latch进行latch.countDown(),并且计数器降低至0。

  • 和join的区别:
    join阻塞时,是只等待单个线程的完成
    而CountDownLatch可能是为了等待多个线程

Q: countDownLatch的内部计数值能被重置吗?
A:不能重置了。如果要重新计数必须重新new一个。毕竟他的类名就叫DownLatch

FutureTask

可以理解为一个支持有返回值的线程
FutureTask<Integer> task = new FutureTask<>(runable);
当调用task.get()时,就能能达到线程里的返回值

Q:调用futrueTask.get()时,这个是阻塞方法吗?如果是阻塞,什么时候会结束?
A:是阻塞方法。

  1. 线程跑完并返回结果
  2. 阻塞时间达到futrueTask.get(xxx)里设定的xxx时间
  3. 线程出现异常InterruptedException或者ExecutionException
  4. 线程被取消,抛出CancellationException

Semaphore

信号量:就是操作系统里常见的那个概念,java实现,用于各线程间进行资源协调。
用Semaphore(permits)构造一个包含permits个资源的信号量,然后某线程做了消费动作, 则执行semaphore.acquire(),则会消费一个资源,如果某线程做了生产动作,则执行semaphore.release(),则会释放一个资源(即新增一个资源)

更详细的信号量方法说明:
https://blog.csdn.net/hanchao5272/article/details/79780045

Q: 信号量中,公平模式和非公平模式的区别?下面设成true就是公平模式

//new Semaphore(permits,fair):初始化许可证数量和是否公平模式的构造函数
semaphore = new Semaphore(5, true);

A:其实就是使用哪种公平锁还是非公平锁。

Java并发中的fairSync和NonfairSync主要区别为:

  • 如果当前线程不是锁的占有者,则NonfairSync并不判断是否有等待队列,直接使用compareAndSwap去进行锁的占用,即谁正好抢到,就给谁用!
  • 如果当前线程不是锁的占有者,则FairSync则会判断当前是否有等待队列,如果有则将自己加到等待队列尾,即严格的先到先得!

CyclicBarrier

栅栏,一般是在线程中去调用的。它的构造需要指定1个线程数量,和栅栏被破坏前要执行的操作,每当有1个线程调用barrier.await(),就会进入阻塞,同时barrier里的线程计数-1。
当线程计数为0时, 调用栅栏里指定的那个操作后,然后破坏栅栏, 所有被阻塞在await上的线程继续往下走。

Exchanger

我理解为两方栅栏,用于交换数据。
简单说就是一个线程在完成一定的事务后,想与另一个线程交换数据,则第一个先拿出数据的线程会一直等待第二个线程,直到第二个线程拿着数据到来时才能彼此交换对应数据。

原子类AtomicXXX

就是内部已实现了原子同步机制
Q:下面输出什么?(考察getAndAdd的用法)

AtomicInteger num = new AtomicInteger(1);
System.out.println(num.getAndAdd(1));
System.out.println(num.get());

A:输出1、2
顾名思义, getAndAdd(),那么就是先get,再加, 类似于num++。
如果是addAndGet(),那么就是++num

Q:AtomicReference和AtomicInteger的区别?
A:AtomicInteger是对整数的封装,而AtomicReference则对应普通的对象引用。也就是它可以保证你在修改对象引用时的线程安全性。即可能会有多个线程修改atomicReference里包含的引用。

  • 经典用法:
    boolean exchanged = atomicStringReference.compareAndSet(initialReference, newReference)就是经典的CAS同步法
    compreAndSet它会将将引用与预期值(引用)进行比较,如果它们相等,则在AtomicReference对象内设置一个新的引用。类似于一个非负责的自旋锁。
  • AtomicReferenceArray是原子数组, 可以进行一些原子的数组操作例如 set(index, value),

java中已实现的全部原子类:

注意,没有float,没有short和byte。

四、线程池

Q: ThreadPoolExecutor线程池构造参数中,corePoolSize和maximumPoolSize有什么区别?
A:当提交新线程到池中时

  • 如果当前线程数 < corePoolSize,则会创建新线程
  • 如果当前线程数=corePoolSize,则新线程被塞进一个队列中等待。
  • 如果队列也被塞满了,那么又会开始新建线程来运行任务,避免任务阻塞或者丢弃
  • 如果队列满了的情况下, 线程总数超过了maxinumPoolSize,那么就抛异常或者阻塞(取决于队列性质)。
  • 调用prestartCoreThread()可提前开启一个空闲的核心线程
  • 调用prestartAllCoreThreads(),可提前创建corePoolSize个核心线程。

Q: 线程池的keepalive参数是干嘛的?
A:当线程数量在corePoolSize到maxinumPoolSize之间时, 如果有线程已跑完,且空闲时间超过keepalive时,则会被清除(注意只限于corePoolSize到maxinumPoolsize之间的线程)

Q: 线程池有哪三种队列策略?
A:

  1. 握手队列
    相当于不排队的队列。可能造成线程数量无限增长直到超过maxinumPoolSize(相当于corePoolSize没什么用了,只以maxinumPoolSize做上限)
  2. 无界队列
    队列队长无限,即线程数量达到corePoolSize时,后面的线程只会在队列中等待。(相当于maxinumPoolSize没什么用了)
    缺陷: 可能造成队列无限增长以至于OOM
  3. 有界队列

Q: 线程池队列已满且maxinumPoolSize已满时,有哪些拒绝策略?
A:

  • AbortPolicy 默认策略:直接抛出RejectedExecutionException异常
  • DiscardPolicy 丢弃策略: 直接丢了,什么错误也不报
  • DiscardOldestPolicy 丢弃队头策略: 即把最先入队的人从队头扔出去,再尝试让该任务进入队尾(队头任务内心:不公平。。。。)
  • CallerRunsPolicy 调用者处理策略: 交给调用者所在线程自己去跑任务(即谁调用的submit或者execute,他就自己去跑)
  • 也可以用实现自定义新的RejectedExecutionHandler

Q:有以下五种Executor提供的线程池,注意记忆一下他们的用途,就能理解内部的原理了。

  • newCachedThreadPool: 缓存线程池
    corePoolSize=0, maxinumPoolSize=+∞,队列长度=0 ,因此线程数量会在corePoolSize到maxinumPoolSize之间一直灵活缓存和变动, 且不存在队列等待的情况,一来任务我就创建,用完了会释放。

  • newFixedThreadPool :定长线程池
    corePoolSize= maxinumPoolSize=构造参数值, 队列长度=+∞。因此不存在线程不够时扩充的情况
  • newScheduledThreadPool :定时器线程池
    提交定时任务用的,构造参数里会带定时器的间隔和单位。 其他和FixedThreadPool相同,属于定长线程池。
  • newSingleThreadExecutor : 单线程池
    corePoolSize=maxinumPoolSize=1, 队列长度=+∞,只会跑一个任务, 所以其他的任务都会在队列中等待,因此会严格按照FIFO执行
  • newWorkStealingPool(继承自ForkJoinPool ): 并行线程池
    如果你的任务执行时间很长,并且里面的任务运行并行跑的,那么他会把你的线程任务再细分到其他的线程来分治。ForkJoinPool介绍:https://blog.csdn.net/m0_37542889/article/details/92640903

Q: submit和execute的区别是什么?
A:

  • execute只能接收Runnable类型的任务,而submit除了Runnable,还能接收Callable(Callable类型任务支持返回值)
  • execute方法返回void, submit方法返回FutureTask。
  • 异常方面, submit方法因为返回了futureTask对象,而当进行future.get()时,会把线程中的异常抛出,因此调用者可以方便地处理异常。(如果是execute,只能用内部捕捉或者设置catchHandler)

Q:线程池中, shutdown、 shutdownNow、awaitTermination的区别?
A:

  • shutdown: 停止接收新任务,等待所有池中已存在任务完成( 包括等待队列中的线程 )。异步方法,即调用后马上返回。
  • shutdownNow: 停止接收新任务,并 停止所有正执行的task,返回还在队列中的task列表 。
  • awaitTermination: 仅仅是一个判断方法,判断当前线程池任务是否全部结束。一般用在shutdown后面,因为shutdown是异步方法,你需要知道什么时候才真正结束。

五、Thread状态转换

Q: 线程的6种状态是:
A:

  • New: 新建了线程,但是还没调用start
  • RUNNABLE: 运行, 就绪状态包括在运行态中
  • BLOCKED: 阻塞,一般是因为想拿锁拿不到
  • WAITING: 等待,一般是wait或者join之后
  • TIMED_WAITING: 定时等待,即固定时间后可返回,一般是调用sleep或者wait(时间)的。
  • TERMINATED: 终止状态。

欣赏一幅好图,能了解调用哪些方法会进入哪些状态。

原图链接
Q: java线程什么时候会进入阻塞(可能按多选题考):
A:

  • sleep
  • wati()挂起, 等待获得别的线程发送的Notify()消息
  • 等待IO
  • 等待锁

六、Volatile

用volatile修饰成员变量时, 一旦有线程修改了变量,其他线程可立即看到改变。

Q: 不用volatile修饰成员变量时, 为什么其他线程会无法立即看到改变?
A:线程可以把变量保存在本地内存(比如机器的寄存器)中,而不是直接在主存中进行读写。
这就可能造成一个线程在主存中修改了一个变量的值,而另外一个线程还继续使用它在寄存器中的变量值。

Q: 用了volatile是不是就可以不用加锁啦?
A: 不行。

  • 锁并不是只保证1个变量的互斥, 有时候是要保证几个成员在连续变化时,让其他线程无法干扰、读取。
  • 而volatile保证1个变量可变, 保证不了几个变量同时变化时的原子性。

Q:展示一段《Java并发编程实战》书里的一个经典例子,在科目二考试里也出现了,只是例子换了个皮。为什么下面这个例子可能会死循环,或者输出0?

A:首先理解一下java重排序,可以看一下这篇博文:https://www.cnblogs.com/coshaho/p/8093944.html

然后分析后面那2个奇怪的情况是怎么发生的。

  • 永远不输出:
    经过程序的指令排序,出现了这种情况:
  1. ReaderThread在while里读取ready值, 此时是false, 于是存入了ReaderThread的寄存器。
  2. 主线程修改ready和number。
  3. ReaderThread没有感知到ready的修改(对于ReaderThread线程,感知不到相关的指令,来让他更新ready寄存器的值),因此进入死循环。
  • 输出0
    经过程序的指令排序,出现了这种情况:
    1)主线程设置ready为true
    2)ReaderThread在while里读取ready值,是true,于是退出while循环
  1. ReaderThread读取到number值, 此时number还是初始化的值为0,于是输出0
  2. 主线程这时候才修改number=42,此时ReaderThread已经结束了!

上面这个问题,可以用volatile或者加锁。当你加了锁时, 如果变量被写了,会有指令去更新另一个寄存器的值,因此就可见了。

七、线程群组

为了方便管理一批线程,我们使用ThreadGroup来表示线程组,通过它对一批线程进行分类管理

使用方法:

Thread group = new ThreadGroup("group");
Thread thread = new Thread(gourp, ()->{..});

即thread除了Thread(Runable)这个构造方法外,还有个Thread(ThreadGroup, Runnable)构造方法

Q:在线程A中创建线程B, 他们属于同一个线程组吗
A:是的

线程组的一大作用是对同一个组线程进行统一的异常捕捉处理,避免每次新建线程时都要重新去setUncaghtExceptionHandler。即线程组自身可以实现一个uncaughtException方法。

ThreadGroup group = new ThreadGroup("group") {
	@Override
	public void uncaughtException(Thread thread, Throwable throwable) {
		System.out.println(thread.getName() + throwable.getMessage());
		}
	};
}

线程如果抛出异常,且没有在线程内部被捕捉,那么此时线程异常的处理顺序是什么?相信很多人都看过下面这段话,好多讲线程组的博客里都这样写:
(1)首先看看当前线程组(ThreadGroup)有没有父类的线程组,如果有,则使用父类的UncaughtException()方法。
(2)如果没有,就看线程是不是调用setUncaughtExceptionHandler()方法建立Thread.setUncaughtExceptionHandler实例。如果建立,直接使用它的UncaughtException()方法处理异常。
(3)如果上述都不成立就看这个异常是不是ThreadDead实例,如果是,什么都不做,如果不是,输出堆栈追踪信息(printStackTrace)。

来源:
https://blog.csdn.net/qq_43073128/article/details/90597006
https://blog.csdn.net/qq_43073128/article/details/88280469

好,别急着记,先看一下下面的题目,问输出什么:
Q:

展开阅读全文

本文系作者在时代Java发表,未经许可,不得转载。

如有侵权,请联系nowjava@qq.com删除。

编辑于

关注时代Java

关注时代Java