Java多线程——基础知识

最新推荐文章于 2023-01-27 12:10:33 发布

JR加加绒

最新推荐文章于 2023-01-27 12:10:33 发布

阅读量262

点赞数

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

本文链接：https://blog.csdn.net/weixin_37592339/article/details/125722340

版权

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、基础知识

1、线程和进程的区别

什么是进程？

进程是指系统在运行的一个应用程序，程序一旦运行就是进程。
进程的特点是：

一个进程可以包含多个线程。
每个进程都有自己独立的内存空间，而其内部的线程可以共享这些内存空间。而线程有自己单独的栈内存用来存储本地数据。
进程上下文切换开销比较大，不同进程不共享内存空间。

什么是线程：

线程是进程的一个子集

区别与联系？

线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。
不同的进程使用不同的内存空间，而线程共享同一进程的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。
线程作为操作系统能够进行运算调度的最小单位，进程作为资源分配的最小单位。
线程更轻量，线程上下文切换成本一般上要比进程上下文切换低

2、并发与并行？

并发：操作系统的任务调度器调度多个线程轮流使用某个CPU的操作（CPU的时间片为15ms），这个过程中会发生线程的上下文切换。线程调度，轮询。
并行：对于多核CPU来讲，每个核（core）都可以调度运行线程，这时候线程可以是并行的，不同的线程同时使用不同的cpu在执行。这是真的并行。
一般来说对于单核CPU的机器，线程执行是并发的，对于多核CPU来讲，线程执行是既有并行也有并发的

3、Java实现多线程的方法

继承Thread类

public class MyThread extends Thread {
    public void run() {
        System.out.println("MyThread.run()");
    }
}
MyThread myThread1 = new MyThread();
myThread1.start();

实现Runable接口

重写该接口的run()方法

public class MyThread extends OtherClass implements Runnable {
    public void run() {
        System.out.println("MyThread.run()");
    }
}

启动 MyThread，需要首先实例化一个 Thread，并传入自己的 MyThread 实例：

MyThread myThread = new MyThread(); 
Thread thread = new Thread(myThread); 
thread.start();

实现Callable接口

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

public class SomeCallable<V> extends OtherClass implements Callable<V> {
    @Override
    public V call() throws Exception {
        // TODO Auto-generated method stub
        return null;
    }
}
Callable<V> oneCallable = new SomeCallable<V>();   
//由Callable<Integer>创建一个FutureTask<Integer>对象：   
FutureTask<V> oneTask = new FutureTask<V>(oneCallable);   
//注释：FutureTask<Integer>是一个包装器，它通过接受Callable<Integer>来创建，它同时实现了Future和Runnable接口。 
  //由FutureTask<Integer>创建一个Thread对象：   
Thread oneThread = new Thread(oneTask);   
oneThread.start();   
//至此，一个线程就创建完成了

Callable 接口类似于 Runnable，从名字就可以看出来了，但是 Runnable 不会返回结果，并且无法抛出返回结果的异常，而 Callable 功能更强大一些，被线程执行后，可以返回值，这个返回值可以被 Future 拿到，也就是说，Future 可以拿到异步执行任务的返回值。可以认为是带有回调的 Runnable。Future 接口表示异步任务，是还没有完成的任务给出的未来结果。所以说 Callable用于产生结果，Future 用于获取结果
Futuretask类通过传入一个Callable接口创建一个有返回值的线程任务，并且其实现了Future接口，可以通过其get方法拿到这个结果

4、线程的上下文切换是什么？什么时候会发生上下文切换？

多线程的上下文切换是指 CPU 控制权由一个已经正在运行的线程切换到另外一个就绪并等待获取 CPU 执行权的线程的过程。当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态

什么时候上下文切换

当前线程的时间片用完（并发）
垃圾回收
有更高优先级的线程需要执行
线程自己调用了sleep、yield、wait、join、synchronized、lock等方法。

5、Thread的run方法和start方法有什么区别？

run()方法是Thread类的一个普通方法，直接调用相当于直接在主线程调用run方法体。
start方法是用于启动线程的，可以实现并发，而run方法只是一个普通方法，是不能实现并发的，只是在并发执行的时候会调用run方法。
多个线程start方法之后的执行顺序是不确定的，由系统并发调度，当调度到之后，就会执行run方法。

6、停止正在运行的线程的方法？

通过标记位停止
(推荐) 通过interrupted()给线程设置清除标记方式停止

注意：此种方式无法停止阻塞中的线程，比如线程正在执行sleep、wait方法等，会抛出java.lang.InterruptedException: sleep interrupted异常。

通过stop方法停止，jdk过时方法，不推荐使用，有线程安全问题

package com.doudou;

public class TestInterruptedThread implements Runnable {

    @Override
    public void run() {
        // 线程没有设置清除标记,让其执行逻辑
        while (!Thread.currentThread().isInterrupted()) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("运行中");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestInterruptedThread testInterruptedThread = new TestInterruptedThread();
        Thread thread = new Thread(testInterruptedThread);
        thread.start();
        Thread.sleep(5000);
        // 给线程设置清除标记
        thread.interrupt();
    }
}

7、sleep和yield的区别？

状态区别

sleep：会让线程从Running进入Waiting状态（阻塞状态）。
yield：会让当前线程从Running进入Runnable就绪状态，然后调度其他线程。注意：该线程也有机会再次得到CPU的调度，得到时间片继续Running。

调度区别

调用sleep之后，该线程将进入阻塞状态，分不到CPU的时间片
调用yield之后，该线程会让出CPU的使用权，但是任务调度器仍然可能分配给该线程时间片，从宏观上只是该线程被分配CPU的概率变低了

8、sleep、yield为什么是静态方法？

Thread类的sleep和yield方法将在当前正在执行的线程上运行，其他线程上调用这些方法是没有意义的。也就是说只有本线程才能执行休眠操作，如果sleep是成员方法，其他线程可以获得该线程的实例化对象，从而让此线程强制休眠（释放CPU的资源），这样会带来不可预估的后果。
sleep,yield不可以被其他线程调用！只能被自身线程调用，也是就是必须是自愿发生才可以！

9、有三个线程T1、T2、T3，如何保证顺序执行？

确保一个线程启动之后，等待它执行完再进行下一个线程

t1.start();
t1.join();
t2.start();
t2.join();
t3.start();
t3.join();

10、线程有哪些状态？

创建
就绪
运行
阻塞：sleep,suspend，wait等方法都可以导致线程阻塞。
死亡

11、守护线程和用户线程

Java线程分为用户线程和守护线程。
守护线程是程序运行的时候在后台提供一种通用服务的线程。所有用户线程停止，进程会停掉所有守护线程，退出程序。
Java中把线程设置为守护线程的方法：在 start 线程之前调用线程的 setDaemon(true) 方法，否则会抛出IllegalThreadStateException异常，该线程仍默认为用户线程。
守护线程创建的线程也是守护线程，守护线程不应该访问、写入持久化资源，如文件、数据库，因为它会在任何时间被停止，导致资源未释放、数据写入中断等问题。

比如JVM的垃圾回收线程是一个守护线程，当所有线程已经撤离，不再产生垃圾，守护线程自然就没事可干了

12、Java中sleep、wait、yield、join的区别？

sleep()方法

在指定时间内让当前正在执行的线程暂停执行，但不会释放“锁标志”.不推荐使用.
sleep()使当前线程进入阻塞状态，在指定时间内不会执行。

wait()方法

在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。
当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常。
唤醒当前对象锁的等待线程使用notify或notifyAll方法，也必须拥有相同的对象锁，否则也会抛出IllegalMonitorStateException异常。
waite()和notify()必须在synchronized函数或synchronized　block中进行调用。如果在non-synchronized函数或non-synchronized　block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。

yield()方法

暂停当前正在执行的线程对象。
yield()只是使当前线程重新回到Runnable，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
yield()只能使同优先级或更高优先级的线程有执行的机会。
调用yield方法并不会让线程进入阻塞状态，而是让线程重回Runnable状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。

join()方法

等待该线程终止。
等待调用join方法的线程结束，再继续执行。如：t.join();//主要用于等待t线程运行结束，若无此句，main则会执行完毕，导致结果不可预测。
在很多情况下，主线程创建并启动了线程，如果子线程中要进行大量耗时运算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join()方法了。方法join()的作用是等待线程对象销毁。