java线程和线程池，类锁和对象锁、线程通信，线程的状态 wait/notify

emmmmsuperdan

已于 2025-08-01 17:21:07 修改

阅读量6k

点赞数

CC 4.0 BY-SA版权

分类专栏： Java线程文章标签： java jvm 面试

于 2018-03-23 11:26:29 首次发布

本文链接：https://blog.youkuaiyun.com/emmmsuperdan/article/details/79664817

Java线程专栏收录该内容

6 篇文章

订阅专栏

线程创建的几种方法：

继承Thread类创建线程类重写run方法
实现Runnable接口重写run方法，拿到实例来作为Thread的target创建Thread类对象

通过Callable和FutureTask创建线程

线程的状态：

1.新建状态：new Thread（r）;

2.就绪状态：还需和其他线程竞争CPU时间，才能进入运行状态；原因：调用start（）方法，但不一定立即执行run（）方法；

3.运行状态：线程获得了cpu 时间片。原因: 调用run（）方法。

4.阻塞状态：阻塞状态是指线程因为某种原因让出了cpu 时间片，暂时停止运行。原因：① 通过调用Sleep()方法进入睡眠

5.死亡状态：①run方法正常结束导致线程死亡 ②.未捕获异常终止了run方法导致线程猝死；

可调用isAlive查看线程是否死亡，return true是出于运行或者阻塞状态， false是出于死亡状态；死亡线程不可复生;

线程池：

线程池优点：

1.线程是稀缺资源，使用线程池可以重复利用线程，减少创建和销毁线程的次数。

2.可以根据系统的承受能力，动态调整线程池中的线程数量，防止消耗过多内存导致服务器崩溃

线程池的创建：

ThreadFactory : 一般用于自定义线程名称

核心线程和普通线程的区别：核心线程空闲的时候不会被回收，非核心线程会被回收;

如何让核心线程销毁：allowCoreThreadTimeOut(true) ，线程池数量最后将销毁到0个。

常见的阻塞队列(分为有界和无界):

ArrayBlockingQueue
ArrayBlockingQueue是最典型的有界队列，其内部是用数组存储元素的，利用Reentrant实现线程安全

public ArrayBlockingQueue(int capacity) {
this(capacity, false);
}

public ArrayBlockingQueue(int capacity, boolean fair) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = new Object[capacity];
lock = new ReentrantLock(fair);
notEmpty = lock.newCondition();
notFull = lock.newCondition();
}

我们在创建它的时候就需要指定它的容量，之后也不可以在扩容了，在构造函数中我们同样可以指定是否是公平的。如果ArrayBlockingQueue被设置为非公平的，那么就存在插队的可能；如果设置为公平的，那么等待了最长时间的线程会优先被处理，其它线程不允许插队。

LinkedBlockingQueue

其内部使用链表实现的，如果我们不指定它的初始容量，那么它的默认容量就为整形的最大值Integer.MAX_VALUE,由于这个数特别特别的大，所以它也被称为无界队列。

阻塞队列特点:

阻塞队列为空时，如果进行出队操作，会使当前线程阻塞，直到有新元素插入阻塞队列，该线程才被通知继续执行出队操作；
阻塞队列为满时，如果进行入队操作，会使当前线程阻塞，直到有元素出队时，该线程才会被通知继续执行入队操作。

为什么线程池一般要用阻塞队列:

由于阻塞队列的特点，它可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源。
当队列中有任务时才唤醒对应线程从队列中取出消息进行执行，使得在线程不至于一直占用cpu资源。但过多的任务可能会导致OOM，因此最好设定最大容量比如: LinkedBlockingQueue(128)

一个task进入到线程池后的流程(核心线程和最大线程作用流程)：

1. 判断线程池里的核心线程是否都在执行任务，如果不是则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。
2、线程池判断任务队列(一般是阻塞队列)是否已满，如果队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。
3，判断线程池里的非核心线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

线程数量设置: 线程池设置多少合适_线程池大小设置多少合适-优快云博客

IO线程池(线程数是2倍CPU核数): IO 操作中，线程大部分时间处于阻塞状态。为避免阻塞浪费资源，IO 线程池通常配置大量线程。当某个线程因 IO 阻塞时，其他线程仍可处理新任务，实现 “以线程数量换吞吐量”。核心线程数2N, 最大线程数2N

CPU线程池(协程中默认线程池，线程数和CPU核数一样)：复杂运算操作时，线程需持续占用 CPU 运算，几乎不会阻塞。计算密集型任务的瓶颈在 CPU 而非线程数。。若线程数超过 CPU 核心数，反而会因频繁的上下文切换（线程切换需要保存和恢复状态，每次切换约消耗 1-10 微秒）降低性能。核心线程数N, 最大线程数N

如果任务超过了最大线程数的数量,如何解决?

一、合适的阻塞队列：
val executor = ThreadPoolExecutor(
    corePoolSize,
    maxPoolSize,
    60L, TimeUnit.SECONDS,
    LinkedBlockingQueue(128) // 设置合理的队列容量
)



二、分级线程池处理策略：
// 高优先级线程池（小核心数+小队列）
val highPriorityExecutor = ThreadPoolExecutor(2, 4, 60, SECONDS, LinkedBlockingQueue(32))

// 普通优先级线程池
val normalExecutor = ThreadPoolExecutor(4, 8, 60, SECONDS, LinkedBlockingQueue(128))

fun submitTask(task: Runnable, priority: Priority = Priority.NORMAL) {
    when (priority) {
        Priority.HIGH -> {
            if (!highPriorityExecutor.executeWithFallback(task)) {
                // 高优先级队列也满了，降级到普通队列
                normalExecutor.execute(task)
            }
        }
        else -> normalExecutor.execute(task)
    }
}

如何打印线程池中线程的名称:

实现自定义ThreadFactory,并重写newThread方法，对runnable封装成Thread，对Thread setName

public static void main(String[] args) {
        // 创建自定义ThreadFactory
        ThreadFactory namedThreadFactory = new ThreadFactory() {
            private final AtomicInteger counter = new AtomicInteger(1);
            
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("custom-thread-" + counter.getAndIncrement());
                return thread;
            }
        };

        // 使用自定义ThreadFactory创建线程池
        ExecutorService executor = Executors.newFixedThreadPool(3, namedThreadFactory);

        // 提交任务
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " executed by " + Thread.currentThread().getName());
            });
        }

        // 关闭线程池
        executor.shutdown();
    }

饱和策略：

线程池中某个线程抛异常如何处理的?

ThreadPoolExecutor.execute 如果用户任务抛出了异常，在线程池运行的状态下，会重新创建一个worker线程。

这里就可能存在一个风险，即如果用户任务大量的抛出异常，可能会导出线程资源频繁的销毁、创建。因此，需要用户任务应当主动对异常进行处理，而不是消极的抛给线程池。

线程池执行任务: execute/submit

线程池execute方法(传参runnable): 无返回值，不知道执行结果

线程池submit方法(传参future)

ThreadPoolExecutor.submit 提交的用户任务，会包装成一个FutureTask，FutureTask执行用户任务，如果异常，不会对外抛出，仅是记录，但是在调用Future.get时，会抛出异常。

线程池的关闭

//threadPool.shutdown();

//threadPool.shutdownNow()；

（1）原理

可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池，它们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。

（2）区别 shutdownNow首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表； shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。

（3）选择只要调用了这两个关闭方法的其中一个，isShutdown方法就会返回true。当所有的任务都已关闭后,才表示线程池关闭成功，这时调用isTerminaed方法会返回true。至于我们应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown()来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow()来关闭线程池。

同步异步：

线程同步：发送一个指令，需要等待返回结果，才能发出下一个指令，需要等待；

线程异步：发送一个指令，不需要等待，即可直接发出下一个指令；

一般情况下，都采用异步，效率更高；但是比如说银行系统，必须采用同步，这样才能保证数据的共享和安全性；

synchronize关键字：

每个 synchronized 方法都必须获得调用该方法的类实例的锁（或者类锁）方能执行，否则所属线程阻塞；直到synchronize方法结束后，才会释放锁；所有声明synchronize的方法中只有一个在调用；避免了类中的成员变量的访问冲突；

记住：只要锁的是不同的锁，就会导致无法同步；怎样才是不同的锁呢？

4.同步方法块的括号里是类名.class，锁就是当前类的class 对象

1.一个类的类锁就只有一个，所以一个类的锁都是相同的

2.一个类中的对象锁有很多个，一个类的对象锁互不相同；

3.类锁和对象锁互不相同；

对象锁：

对象锁举例：

类锁（下面两种实现方法）：

由于用的是同一个类锁，锁住的东西是相同的，所以有下面的结果

但如果一个锁住的是类，一个锁住的是对象的话，如下：

操作的是不同的锁，所以会有下面的结果：

下面一个例子采用了同步锁，来对实例方法进行同步，即构造两个线程，往其中都加入一个含有同步实例方法的对象

（Android中创建子线程来写耗时逻辑）单线程的暂停和开始可以在线程中放入一个flag，通过这个flag来对线程进行控制。

多线程暂停和开始：

暂停用interrupt（其实也可以用flag控制）不用已淘汰的stop，注意interrupt只是判断线程是否暂停，在线程的run方法中抛出异常（一定要调用一下interrupt方法，才能进行interrupt判断）或者用break但是（在for循环中 break之后for还是会接着执行），所以尽量用interrupt

恢复就是相对暂停来写逻辑，和上述一样

sleep和wait方法的区别是，sleep不会放弃对象的监视器，wait会放弃对象的监视器

线程沉睡和唤醒用wait和notify方法。（都在synchronize中使用，而synchronize一般都是在线程中的某个方法用的，因为为了同步线程，所以是一个Thread对象创建出多个threadA，B...引用来调用这个线程方法）

注意线程的上述方法和Object自带的wait()和notifyAll()方法的区别，wait()和notifyAll()一定要在synchronize同步语句中添加，因为调用这两个方法一定要获得对象锁，synchronize块就是为了获取锁，有synchronize块的线程处于运行状态，没有它的线程则处于阻塞状态；

调用wait时，会将对象锁放弃；之后其他线程均分机会来获取这个锁

如何正确的控制线程的停止和回复：

private class MyThread extends Thread {
    private final Object lock = new Object();
    private volatile boolean pause = false;

    /**
     * 调用这个方法实现暂停线程
     */
    void pauseThread() {
        pause = true;
    }

    /**
     * 调用这个方法实现恢复线程的运行
     */
    void resumeThread() {
        pause = false;
        synchronized (lock) {
            lock.notifyAll();
        }
    }

    /**
     * 注意：这个方法只能在run方法里调用，不然会阻塞主线程，导致页面无响应
     */
    void onPause() {
        synchronized (lock) {
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void run() {
        super.run();
        try {
            int index = 0;
            while (true) {
                // 让线程处于暂停等待状态
                while (pause) {
                    onPause();
                }
                try {
                    System.out.println(index);
                    Thread.sleep(50);
                    ++index;
                } catch (InterruptedException e) {
                    //捕获到异常之后，执行break跳出循环
                    break;
                }
            }
        } catch (NullPointerException e) {
            e.printStackTrace();
        }
    }
}

暂停的话，只需执行：