多线程自嗨

最新推荐文章于 2026-08-20 15:06:23 发布

原创最新推荐文章于 2026-08-20 15:06:23 发布 · 149 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

自备面试复习 java：多线程(由重到轻精简版)

基础

重要基本概念

程序：一段静态的代码。

进程：正在运行的一个程序，进程作为资源分配的单位。

线程：线程作为调度和执行的最小单位，每个线程拥有独立的运行栈和程序计时器。

并发：比如一个CPU（假设它是单核心）同时执行多个任务，但是，实际上不是完全“同时”的。实际上它是通过时间片轮转，在很短的时间内，对多个程序分别执行，之所以像是“同时”，是因为时间太短，肉眼观察不出来而已。

并行：比如多个CPU（假设它是单核心）同时执行多个任务，如果每个CPU只需要执行一个任务，此时，相当于是多个任务是真的同一时间在进行，故叫做并行。

多线程：若一个进程同一时间并行多个线程，就是支持多线程的。多线程就是进程有多个线程，每个线程有各自的任务，多线程可能是并行也可能是并发的。

注：像是现在的CPU一般都是多个核心，每个核心实际上就是一个独立完整的计算单元，所以，比如两个核心同时执行一个进程的两个线程那么此时，就是并行的，所以该进程是支持多线程的。

多线程常用方法

Thread类重要方法：
1.start()：启动当前线程；调用当前线程的run()
2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3.sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是堵塞状态。
4.join():在线程a中调用线程b的join()，此时线程a就进入堵塞状态，直到线程b完全执行完以后，线程a才结束堵塞状态。
          
Thread类其他常用方法：
1.currentThread():静态方法，返回执行当前代码的线程
2.getName():获取当前线程的名字
3.setName():设置当前线程的名字
4.yield():释放当前cpu的执行权
5.stop():已过时。当执行此方法时，强调结束当前线程。
6.isAlive():判断当前线程是否存活
7.setDaemon(true):设置该线程为一个守护线程（补充）

线程优先级：
1.MAX_PRIORITY：10
2.MIN _PRIORITY：1
3.NORM_PRIORITY：5 -->默认优先级
相关方法：（Thread的方法）
getPriority():获取线程的优先级
setPriority(int p):设置线程的优先级

线程通讯方法：（Object的方法）
wait
notify
notifyAll

多线程的创建方式

jdk5之前的两种创建方式

继承Thread类（注：Thread实际上是Runnable的实现类）

步骤：

1.创建一个继承于Thread类的子类
2.重写Thread类的run（） --> 将此线程执行的操作声明在run（）中
3.创建Thread类的子类的对象
4.通过此类对象调用start（）

实现Runnable接口

步骤：

1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
5.通过Thread类的对象调用start()

比较创建线程的两种方式：

开发中：优先选择实现Runnable接口的方式
原因：
1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个线程有共享数据的情况（即不需要将数据全局化）。

jdk5新增的线程创建方式

实现Callable接口

1.创建一个实现Callable的实现类
2.实现call方法，将此线程需要执行的操作声明在call()中
3.创建Callable接口实现类的对象
4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
5.将FutureTask的对象作为参数传递到Thread构造器中，创建Thread对象，并调用start()
6.获取Callable中call方法的返回值
get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?

call()可以有返回值的。
call()可以抛出异常，被外面的操作捕获，获取异常的信息
Callable是支持泛型的。

使用线程池

1.提供指定线程数量的线程池
2.设置线程池的属性
3.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象

好处：

1.提高响应速度（减少了创建新线程的时间）

2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）

3.便于线程管理

corePoolSize：核心池的大小

maximumPoolSize：最大线程数

keepAliveTime：线程没有任务时最多保持多长时间后会终止

线程的生命周期

线程的五种生命状态：新建、就绪、运行、阻塞、死亡。

注：Thread源码中State有新建、运行、堵塞、等待、超时等待、死亡（终止）6种。

在这里插入图片描述

线程的同步

方式一：同步代码块

synchronized(同步监视器){
      //需要被同步的代码
}
说明：
  1.操作共享数据的代码，即为需要被同步的代码 ---> 不能包含代码多了，也不能包含代码少了。
  2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
  3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
    要求：多个线程必须要共用同一把锁。

  补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的。
public synchronized void show (String name){ 
		…
}
说明：
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2.非静态的同步方法，同步监视器是：this
  静态的同步方法，同步监视器是：当前类本身

同步方式的优缺点：

1.同步的方式，解决了线程的安全问题。 ---好处
2.操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 ---局限性

方式三：Lock锁—jdk5新增

1.创建ReentrantLock()对象，假设叫lock
2. lock.lock()加锁
3. finally => lock.unlock() 解锁

Synchronized 和 Lock 区别：（狂神说JUC视频摘抄）

Synchronized 内置的Java关键字，Lock 是一个Java类
Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁
Synchronized 会自动释放锁，lock 必须要手动释放锁！如果不释放锁，死锁
Synchronized 线程1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下去；
Synchronized 可重入锁，不可以中断的，非公平；Lock，可重入锁，可以判断锁，非公平（可以自己设置）；
Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码！

单例模式懒汉式线程安全优化

class Bank {

    private Bank() {
    }

    private static Bank instance = null;

    public static Bank getInstance() {
        if (instance == null) {
            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    }

}

死锁

定义：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

2.说明：

出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于堵塞状态，无法继续

我们使用同步时，要避免出现死锁。

举例：

public class ThreadTest {
    public static void main(String[] args) {

        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

        new Thread(){
            @Override
            public void run() {
                synchronized (s1){

                    s1.append("a");
                    s2.append("1");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){

                    s1.append("c");
                    s2.append("3");

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();

    }
}

线程的通讯

线程的通讯需要使用的方法：
wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify():一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait则唤醒优先级最高的那个线程
notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。

说明：
1.wait(),notify(),notifyAll()三个方法必须声明在同步代码块或同步方法中。
2.wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则报错。
3.wait(),notify(),notifyAll()三个方法是定义在java.lang.Object类中的。

面试题：sleep() 和 wait()的异同?

1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。

2.不同点：

(1)两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()

(2)调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中

(3)关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁、wait()会释放锁

补充：wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则报错。