Java 多线程知识的简单总结

Java实用注解篇:@Transactional 事务失效的场景深度解析 在使用明明加了事务注解,但事务却没有生效,数据库操作仍然被提交了!这是因为事务机制的触发有一些前提条件,只要触碰到事务失效的“雷区”,就会让事务变成“摆设”。接下来,我们来详细剖析几种常见的事务失效场景以及解决方案! 阅读详情

Java 提供了多线程编程的内置支持,让我们可以轻松开发多线程应用。

Java 中我们最为熟悉的线程就是 main 线程——主线程。

一个进程可以并发多个线程,每条线程并行执行不同的任务。线程是进程的基本单位,是一个单一顺序的控制流,一个进程一直运行,直到所有的“非守护线程”都结束运行后才能结束。Java 中常见的守护线程有:垃圾回收线程、

这里简要述说以下并发和并行的区别。

并发:同一时间段内有多个任务在运行

并行:同一时间点上有多个任务同时在运行

多线程可以帮助我们高效地执行任务,合理利用 CPU 资源,充分地发挥多核 CPU 的性能。但是多线程也并不总是能够让程序高效运行的,多线程切换带来的开销、线程死锁、线程异常等等问题,都会使得多线程开发较单线程开发更麻烦。因此,有必要学习 Java 多线程的相关知识,从而提高开发效率。

1 创建多线程

根据官方文档 Thread (Java Platform SE 8 ) (oracle.com) 中 java.lang.Thread 的说明,可以看到线程的创建方式主要有两种:

There are two ways to create a new thread of execution. One is to declare a class to be a subclass of Thread. This subclass should override the run method of class Thread. An instance of the subclass can then be allocated and started.

The other way to create a thread is to declare a class that implements the Runnable interface. That class then implements the run method. An instance of the class can then be allocated, passed as an argument when creating Thread, and started.

可以看到,有两种创建线程的方式:

  • 声明一个类继承 Thread 类,这个子类需要重写 run 方法,随后创建这个子类的实例,这个实例就可以创建并启动一个线程执行任务;
  • 声明一个类实现接口 Runnable 并实现 run 方法。这个类的实例作为参数分配给一个 Thread 实例,随后使用 Thread 实例创建并启动线程即可

除此之外的创建线程的方法,诸如使用 Callable 和 FutureTask、线程池等等,无非是在此基础上的扩展,查看源码可以看到 FutureTask 也实现了 Runnable 接口。

使用继承 Thread 类的方法创建线程的代码:

/**
 * 使用继承 Thread 类的方法创建线程
 */
public class CreateOne {
    public static void main(String[] args) {
        Thread t = new MySubThread();
        t.start();
    }
}

class MySubThread extends Thread {
    @Override
    public void run() {
        // currentThread() 是 Thread 的静态方法,可以获取正在执行当前代码的线程实例
        System.out.println(Thread.currentThread().getName() + "执行任务");
    }
}

// ================================== 运行结果
Thread-0执行任务

使用实现 Runnable 接口的方法创建线程的代码:

/**
 * 使用实现 Runnable 接口的方法创建线程
 */
public class CreateTwo {
    public static void main(String[] args) {
        RunnableImpl r = new RunnableImpl();
        Thread t = new Thread(r);
        t.start();
    }
}

class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "执行任务");
    }
}

// ================================== 运行结果
Thread-0执行任务

1.1 孰优孰劣

创建线程虽然有两种方法,但是在实际开发中,使用实现接口 Runnable 的方法更好,原因如下:

  1. 查看 Thread 的 run 方法,可以看到:
// Thread 实例的成员变量 target 是一个 Runnable 实例,可以通过 Thread 的构造方法传入
private Runnable target;

// 如果有传入 Runnable 实例,那么就执行它的 run 方法
// 如果重写,就完全执行我们自己的逻辑
public void run() {
    if (target != null) {
        target.run();
    }
}

  1. 查看上面的源码,我们可以知道,Thread 类并不是定义执行任务的主体,而是 Runnable 定义执行任务内容,Thread 调用执行,从而实现线程与任务的解耦。
  2. 由于线程与任务解耦,我们可以复用线程,而不是当需要执行任务就去创建线程、执行完毕就销毁线程,这样带来的系统开销太大。这也是线程池的基本思想。
  3. 此外,Java 只只支持单继承,如果继承 Thread 使用多线程,那么后续需要通过继承的方式扩展功能,那会相当麻烦。

2 start 和 run 方法

从上面可以得知,有两种创建线程的方式,我们通过 Thread 类或 Runnable 接口的 run 方法定义任务,通过 Thread 的 start 方法创建并启动线程。

❗❗ 我们不能通过 run 方法启动并创建一个线程,它只是一个普通方法,如果直接调用这个方法,其实只是调用这个方法的线程在执行任务罢了。

// 将上面的代码修改一下,查看执行结果
public class CreateOne {
    public static void main(String[] args) {
        Thread t = new MySubThread();
        t.run();
        //t.start();
    }
}

// ===================== 执行结果
main执行任务

查看 start 方法的源码:

// 线程状态,为 0 表示还未启动
private volatile int threadStatus = 0;

// ❗❗ 同步方法,确保创建、启动线程是线程安全的
public synchronized void start() {
    // 如果线程状态不为 0,那么抛出异常——💡即线程已经创建了
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    // 将当前线程添加到线程组
    group.add(this);

    boolean started = false;
    try {
        // 这是一个本地方法
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
        }
    }
}

// 由本地方法实现,只需要知道,该方法调用后会创建一个线程,并且会执行 run 方法
private native void start0();

由上面的源码可以得知:

  1. 创建并启动一个线程是线程安全的
  2. start() 方法不能反复调用,否则会抛出异常

3 怎么停止线程

线程并不是无休止地执行下去的,通常情况下,线程停止的条件有:

  1. run 方法执行结束
  2. 线程发生异常,但是没有捕获处理

除此之外,我们还需要自定义某些情况下需要通知线程停止,例如:

  1. 用户主动取消任务
  2. 任务执行时间超时、出错
  3. 出现故障,服务需要快速停止
  4. ...

💡 为什么不能直接简单粗暴的停止线程呢?通过通知线程停止任务,我们可以更优雅地停止线程,让线程保存问题现场、记录日志、发送警报、友好提示等等,令线程在合适的代码位置停止线程,从而避免一些数据丢失等情况。

令线程停止的方法是让线程捕获中断异常或检测中断标志位,从而优雅地停止线程,这是推荐的做法。而不推荐的做法有,使用被标记为过时的方法:stop,resume,suspend,这些方法可能会造成死锁、线程不安全等情况,由于已经过时了,所以不做过多介绍。

3.1 通知线程中断

我们要使用通知的方式停止目标线程,通过以下方法,希望能够帮助你掌握中断线程的方法:

/**
 * 中断线程
 */
public class InterruptThread {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            long i = 0;
            // isInterrupted() 检测当前线程是否处于中断状态
            while (i < Long.MAX_VALUE && !Thread.currentThread().isInterrupted()) {
                i++;
            }
            System.out.println(i);
        });

        t.start();
        // 主线程睡眠 1 秒,通知线程中断
        Thread.sleep(1000);
        t.interrupt();
    }
}
// 运行结果
1436125519

这是中断线程的方法之一,还有其他方法,当线程处于阻塞状态时,线程并不能运行到检测线程状态的代码位置,然后正确响应中断,这个时候,我们需要通过捕获异常的方式停止线程:

/**
 * 通过捕获中断异常停止线程
 */
public class InterruptThreadByException {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            long i = 0;
            while (i < Long.MAX_VALUE) {
                i++;
                try {
                    // 线程大部分时间处于阻塞状态,sleep 方法会抛出中断异常 InterruptedException
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // 捕获到中断异常,代表线程被通知中断,做出相应处理再停止线程
                    System.out.println("线程收到中断通知   " + i);
                    // 如果 try-catch 在 while 代码块之外,可以不用 return 也可以结束代码
                    // 在 while 代码块之内,如果没有 return / break,那么还是会进入下一次循环,并不能正确停止
                    return;
                }
            }
        });
        t.start();
        Thread.sleep(1000);
        t.interrupt();
    }
}
// 运行结果
线程收到中断通知   10

以上,就是停止线程的正确做法,此外,捕获中断异常后,会清除线程的中断状态,在实际开发中需要特别注意。例如,修改上面的代码:

public class InterruptThreadByException {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            long i = 0;
            while (i < Long.MAX_VALUE) {
                i++;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    System.out.println("线程收到中断通知   " + i);
                    // ❗❗ 添加这行代码,捕获到中断异常后,检测中断状态,中断状态为 false
                    System.out.println(Thread.currentThread().isInterrupted());
                    return;
                }
            }
        });
        t.start();
        Thread.sleep(1000);
        t.interrupt();
    }
}

所以,在线程中,如果调用了其他方法,如果该方法有异常发生,那么:

  1. 将异常抛出,而不是在子方法内部捕获处理,由 run 方法统一处理异常
  2. 捕获异常,并重新通知当前线程中断,Thread.currentThread().interrupt()

例如:

public class SubMethodException {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new ExceptionRunnableA());
        Thread t2 = new Thread(new ExceptionRunnableB());
        t1.start();
        t2.start();
        Thread.sleep(1000);
        t1.interrupt();
        t2.interrupt();
    }
}

class ExceptionRunnableA implements Runnable {
    @Override
    public void run() {
        try {
            while (true) {
                method();
            }
        } catch (InterruptedException e) {
            System.out.println("run 方法内部捕获中断异常");
        }
    }

    public void method() throws InterruptedException {
        Thread.sleep(100000L);
    }
}

class ExceptionRunnableB implements Runnable {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            method();
        }
    }

    public void method()  {
        try {
            Thread.sleep(100000L);
        } catch (InterruptedException e) {
            System.out.println("子方法内部捕获中断异常");
            // 如果不重新设置中断,线程将不能正确响应中断
            Thread.currentThread().interrupt();
        }
    }
}

综上,总结出令线程正确停止的方法为:

  1. 使用 interrupt() 方法通知目标线程停止,标记目标线程的中断状态为 true
  2. 目标线程通过 isInterrupted() 不时地检测线程的中断状态,根据情况决定是否停止线程
  3. 如果线程使用了阻塞方法例如 sleep(),那么需要捕获中断异常并处理中断通知,捕获了中断异常会重置中断标记位
  4. 如果 run() 方法调用了其他子方法,那么子方法:
    1. 将异常抛出,传递到顶层 run 方法,由 run 方法统一处理
    2. 将异常捕获,同时重新通知当前线程中断

下面再说说关于中断的几个相关方法和一些会抛出中断异常的方法,使用的时候需要特别注意。

3.2 线程中断的相关方法

  1. interrupt() 实例方法,通知目标线程中断。
  2. static interrupted() 静态方法,获取当前线程是否处于中断状态,会重置中断状态,即如果中断状态为 true,那么调用后中断状态为 false。方法内部通过 Thread.currentThread() 获取执行线程实例。
  3. isInterrupted() 实例方法,获取线程的中断状态,不会清除中断状态。

3.3 阻塞并能响应中断的方法

  • Object.wait()

  • Thread.sleep()

  • Thread.join()

  • BlockingQueue.take() / put()

  • Lock.lockInterruptibly()

  • CountDownLatch.await()

  • CyclicBarrier.await()

  • Exchanger.exchange()

4 线程的生命周期

线程的生命周期状态由六部分组成:

状态说明
NEW线程刚创建,还没有调用 start 方法,线程尚未启动
RUNNABLE线程已经调用了 start 方法,已经准备好运行,正在等待 CPU 分配资源;或者正在运行
BLOCKED进入 synchronized 代码块,但是没有拿到对象锁,进入阻塞状态
WAITINGsynchronized 代码块中,同步锁对象调用了 wait 方法,或者线程被调用了 join 方法等,进入等待状态,需要被唤醒
TIMED WAITING计时等待状态,等待一段时间自动苏醒,或者等待过程中被唤醒
TERMINATED线程执行结束,正常结束或者发生未捕获的异常

可以用一张图总结线程的生命周期,以及各个过程之间是如何转换的:

5 Thread 和 Object 中的线程方法

现在,我们已经知道了线程的创建、启动、停止以及线程的生命周期了,那么,再来看看线程相关的方法有哪些。

首先,看看 Thread 中的一些方法:

方法说明
sleep()让线程等待一段时间,不会释放锁
join()当前线程等待目标线程运行结束
yield()放弃已经获得的 CPU 资源,线程依旧是 RUNNABLE 状态
currentThread()获取当前的线程实例
start()启动线程
run()线程任务主体
interrupt()通知线程中断,设置中断标志为 true
isInterrupted()检查线程是否处于中断状态
interrupted()返回线程中断状态,会重置线程中断状态
stop()/suspend()/resume()过时的停止线程方法

再看看 Object 中的相关方法:

方法说明
wait()线程获取对象锁,进入等待状态,必须配合同步代码块使用;
要么被唤醒,要么计时等待时间结束
notify()随机唤醒一个线程,被唤醒线程尝试获取同步锁
notifyAll()唤醒所有线程,所有线程都会尝试获取同步锁

运行以下代码,查看 wait() 和 sleep() 是否会释放同步锁

/**
* 证明 sleep 不会释放锁,wait 会释放锁
*/
public class SleepAndWait {

    private static Object lock = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + "获得同步锁,调用 wait() 方法");
                try {
                    lock.wait(2000);
                    System.out.println(Thread.currentThread().getName() + "重新获得同步锁");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + "获得同步锁,唤醒另一个线程,调用 sleep()");
                lock.notify();
                try {
                    // 如果 sleep() 会释放锁,那么在此期间,上面的线程将会继续运行,即 sleep 不会释放同步锁
                    Thread.sleep(2000);
                    // 如果执行 wait 方法,那么上面的线程将会继续执行,证明 wait 方法会释放锁
                    //lock.wait(2000);
                    System.out.println(Thread.currentThread().getName() + "sleep 结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
    }
}

上面的代码已经证明了 sleep() 不会释放同步锁,此外,sleep() 也不会释放 Lock 的锁,运行以下代码查看结果:

/**
 * sleep 不会释放 Lock 锁
 */
public class SleepDontReleaseLock implements Runnable {
    private static Lock lock = new ReentrantLock();

    @Override
    public void run() {
        // 调用 lock 方法,线程会尝试持有该锁对象,如果已经被其他线程锁住,那么当前线程会进入阻塞状态
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "获得 lock 锁");
            // 如果 sleep 会释放 Lock 锁,那么另一个线程会马上打印上面的语句
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + "释放 lock 锁");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 当前线程释放锁,让其他线程可以占有锁
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        SleepDontReleaseLock task = new SleepDontReleaseLock();
        new Thread(task).start();
        new Thread(task).start();
    }
}

5.1 wait 和 sleep 的异同

接下来总结 Object.wait() 和 Thread.sleep() 方法的异同点。

相同点:

  1. 都会使线程进入阻塞状态
  2. 都可以响应中断

不同点:

  1. wait() 是 Object 的实例方法,sleep() 是 Thread 的静态方法
  2. sleep() 需要指定时间
  3. wait() 会释放锁,sleep() 不会释放锁,包括同步锁和 Lock 锁
  4. wait() 必须配合 synchronized 使用

6 线程的相关属性

现在我们已经对 Java 中的多线程有一定的了解了,我们再看看 Java 中线程 Thread 的一些相关属性,即它的成员变量。

属性说明
线程 ID唯一标识线程,无法修改,从 1 递增,主线程 main ID 为 1
用户创建的线程 ID 并不是从 2 开始,虚拟机进程启动后还会创建其他线程,例如垃圾回收线程
名称 name默认为 Thread-自增ID
可以通过 Thread.setName() 自定义线程名,方便区分线程、排查问题
是否是守护线程 daemonfalse 代表不为守护线程,一般会继承父线程的类型

为目标线程提供服务,非守护线程运行结束后,会随着虚拟机一起停止
通常不使用守护线程,用户线程一旦结束,守护线程也会结束 |
| 优先级 priority | 优先级从小到大为 0-10, 默认为 5
通常不改变优先级,因为:
1. 不同操作系统的优先级定义不同
2. 优先级会被操作系统修改
3. 低优先级的线程可能一致无法获取资源而无法运行 |

运行以下代码,了解线程的相关属性

public class ThreadFields {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            // 自定义线程的 ID 并不是从 2 开始
            System.out.println("线程 " + Thread.currentThread().getName()
                               + " 的线程 ID " + Thread.currentThread().getId());
            while (true) {
                // 守护线程一直运行,但是 用户线程即这里的主线程结束后,也会随着虚拟机一起停止
            }
        });
        // 自定义线程名字
        t.setName("自定义线程");
        // 将其设置为守护线程
        t.setDaemon(true);
        // 设置优先级 Thread.MIN_PRIORITY = 1     Thread.MAX_PRIORITY = 10
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();
        // 主线程的 ID 为 1
        System.out.println("线程 " + Thread.currentThread().getName() + " 的线程 ID " + Thread.currentThread().getId());
        Thread.sleep(3000);
    }
}

7 全局异常处理

在子线程中,如果发生了异常我们能够及时捕获并处理,那么对程序运行并不会有什么恶劣影响。

但是,如果发生了一些未捕获的异常,在多线程情况下,这些异常打印出来的堆栈信息,很容易淹没在庞大的日志中,我们可能很难察觉到,并且不好排查问题。

如果对这些异常都做捕获处理,那么就会造成代码的冗余,编写起来也不方便。

因此,我们可以编写一个全局异常处理器来处理子线程中抛出的异常,统一地处理,解耦代码。

7.1 源码查看

在讲解如何处理子线程的异常问题前,我们先看看 JVM 默认情况下,是如何处理未捕获的异常的。

查看 Thread 的源码:

public class Thread implements Runnable {
    【1】当发生未捕获的异常时,JVM 会调用该方法,并传递异常信息给异常处理器
        可以在这里打下断点,在线程中抛出异常不捕获,IDEA 会跳转到这里
    // 向处理程序发送未捕获的异常。此方法仅由JVM调用。
    private void dispatchUncaughtException(Throwable e) {
        【2】查看第 9 行代码,可以看到如果没有指定异常处理器,默认是线程组作为异常处理器
        【3】调用这个异常处理器的处理方法,处理异常,查看第 15 行
        getUncaughtExceptionHandler().uncaughtException(this, e);
    }

    public UncaughtExceptionHandler getUncaughtExceptionHandler() {
        return uncaughtExceptionHandler != null ?
            uncaughtExceptionHandler : group;
    }

    【4】UncaughtExceptionHandler 是 Thread 的内部接口,线程组也是该接口的实现,
        只有一个方法处理异常,接下来查看第 25 行,看看 Group 是如何实现的
    @FunctionalInterface
    public interface UncaughtExceptionHandler {
        void uncaughtException(Thread t, Throwable e);
    }
}

public class ThreadGroup implements Thread.UncaughtExceptionHandler {
    【5】默认异常处理器的实现
    public void uncaughtException(Thread t, Throwable e) {
        // 如果有父线程组,交给它处理
        if (parent != null) {
            parent.uncaughtException(t, e);
        } else {
            // 获取默认的异常处理器,如果没有指定,那么为 null
            Thread.UncaughtExceptionHandler ueh =
                Thread.getDefaultUncaughtExceptionHandler();
            if (ueh != null) {
                ueh.uncaughtException(t, e);
            } 
            // 没有指定异常处理器,打印堆栈信息
            else if (!(e instanceof ThreadDeath)) {
                System.err.print("Exception in thread \""
                                 + t.getName() + "\" ");
                e.printStackTrace(System.err);
            }
        }
    }
}

7.2 自定义全局异常处理器

通过上面的源码讲解,已经可以知道 JVM 是如何处理未捕获的异常的了,即只打印堆栈信息。那么,要如何自定义异常处理器呢?

具体方法为:

  1. 实现接口 Thread.UncaughtExceptionHandler 并实现方法 uncaughtException()
  2. 为创建的线程指定异常处理器

示例代码:

public class MyExceptionHandler implements Thread.UncaughtExceptionHandler{
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("发生了未捕获的异常,进行日志处理、报警处理、友好提示、数据备份等等......");
        e.printStackTrace();
    }

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            throw new RuntimeException();
        });
        t.setUncaughtExceptionHandler(new MyExceptionHandler());
        t.start();
    }
}

8 多线程带来的问题

合理地利用多线程能够带来性能上的提升,但是如果因为一些疏漏,多线程反而会成为程序员的噩梦。

例如,多线程开发,我们需要考虑线程安全问题、性能问题。

首先,讲讲线程安全问题。

什么是线程安全?所谓线程安全,即

在多线程情况下,如果访问某个对象,不需要额外处理,例如加锁、令线程阻塞、额外的线程调度等,调用这个对象都能获得正确的结果,那么这个对象就是线程安全的

因此,在编写多线程程序时,就需要考虑某个数据是否是线程安全的,如果这个对象满足:

  1. 被多个线程共享
  2. 操作具有时序要求,先读后写
  3. 这个对象的类有他人编写,并且没有声明是线程安全的

那么我们就需要考虑使用同步锁、Lock、并发工具类(java.util.concurrent)来保证这个对象是在多线程下是安全的。

再看看多线程带来的性能问题。

多个线程的调度需要上下文切换,这需要耗费 CPU 资源。

所谓上下文,即处理器中寄存器、程序计数器内的信息。

上下文切换,即 CPU 挂起一个线程,将其上下文保存到内存中,从内存中获取另一个运行线程的上下文,恢复到寄存器中,根据程序计数器中的指令恢复线程运行。

一个线程被挂起,另一个线程恢复运行,这个时候,被挂起的线程的数据缓存对于运行线程来说是无效的,减缓了线程的运行速度,新的线程需要重新缓存数据提升运行速度。

通常情况下,密集的 IO 操作、抢锁操作都会带来密集的上下文切换。

以上,是上下文切换带来的性能问题,Java 的内存模型也会带来性能问题,为了保证数据的可见性,JVM 会强制令数据缓存失效,保证数据是实时最新的,这也牺牲了缓存带来的性能提升。

9 总结

这里总结下上面的内容。

  1. 创建线程有两种方式,继承 Thread 和实现 Runnable
  2. start 方法才能正确创建和启动线程,run 方法只是一个普通方法
  3. start 方法不能反复调用,反复调用会抛出异常
  4. 正确停止线程的方法是通过 interrupt() 通知线程
    1. 线程不时地检查中断状态并判断是否停止线程,使用方法 isInterrupt()
    2. 如果线程阻塞,捕获中断异常,判断是否停止线程
    3. 线程调用的子方法最好将异常抛出,由 run 方法统一捕获处理
    4. 线程调用的子方法如果捕获异常,需要重新通知线程中断
  5. 线程的生命周期为
    1. NEW
    2. RUNNABLE
    3. BLOCKED
    4. WAITING
    5. TIMED WAITING
    6. TERMINATED
  6. wait()/notify()/notifyAll() 必须配合同步锁使用
  7. wait() 会释放锁,sleep() 不会释放锁,包括同步锁和 Lock 锁
  8. 线程的一些属性
    1. 线程ID,无法修改
    2. 线程名 name,可以自定义
    3. 守护线程 daemon,线程类型会继承自父线程,通常不指定线程为守护线程
    4. 优先级 priority,通常使用默认优先级,不改变优先级
  9. 可以自定义全局异常处理器,处理非主线程中的未捕获的异常,如备份数据、日志处理、报警等等
  10. 多线程开发会带来线程安全问题、性能问题,开发过程需要特别注意

 

低成本实现webhook接收端[python] Webook本质上也是API,只不过是反向调用,即前端不主动发送请求,完全由后端推送。简单来说,Webhook是一个接受HTTP POST或是GET,PUT,DELETE的URL,一个实现了Webhook的API提供商就是在当事件发生的时候会向配置的URL发送信息,与请求-响应式不同,使用Webhook可以实时接收到变化。Ps:Webhook可能会发出大量的请求,确保接受的URL不被泄露或者应用能及时处理这些请求。 阅读详情

相关推荐

Kriging代理模型理论相关推导

代理模型,Kriging,加点准则

森屹的博客 1万+

Java【多线程基础3】导致线程不安全的 4 种原因及解决方式

本篇带你了解Java多线程中线程不安全的原因和解决方案!! 代码示例+解析

yzhcjl_的博客 2247

VMware虚拟机调用NVIDIA显卡全攻略:从3D加速到直通与vGPU

显卡虚拟化技术是虚拟化领域的关键组成部分,它通过在虚拟机中模拟或直接分配物理GPU资源,实现了图形渲染与通用计算的加速。其核心原理在于通过Hypervisor层对GPU指令进行拦截、转换或直接映射,从而平衡资源隔离与性能损耗。这项技术的核心价值在于提升资源利用率、实现计算环境隔离,并支持AI训练、3D渲染、科学计算等高性能负载的灵活部署。在应用场景上,轻量级图形界面加速、CUDA学习验证适合使用虚拟3D加速;而追求极致性能的机器学习训练、专业渲染则需依赖PCIe直通技术;对于企业级GPU资源池化与多租户共享

weixin_32308101的博客 1071

多线程:一个线程在运行时发生异常会怎么样?

Java中Throwable分为Exception和Error: 出现Error的情况下,程序会停止运行。Exception分为RuntimeException和非运行时异常。非运行时异常必须处理,比如thread中sleep()时,必须处理InterruptedException异常,才能通过编译。 而RuntimeException可以处理也可以不处理,因为编译并不能检测该类异常,比如...

五山口老法师 5933

RedPitaya火龙果板基础操作

火龙果板基础操作一级目录二级目录三级目录 一级目录 二级目录 三级目录

qq_41523340的博客 9733

rv1126平台spi屏调试

st7789v2 i2c调试

zuoanyouzhuan_的博客 2039

一个线程如果出现了运行时异常会怎么样

如果这个异常没有被捕获的话,这个线程就停止执行了。 另外重要的一点是:如果这个线程持有某个某个对象的监视器,那么这个对象监视器会被立即释放

Java 1200

AD创建属于自己的元件库(详细)

我今天开始学习AD2022,但是我想自己创建属于自己的元件库,但是奈何找了好多教程就是随便几句话就把我打发走了,弄了一天都没搞定(也许是我比较菜),所以现在乱懂了,自己写一个属于我们自己小白的教程,希望有用吧哈哈我比较偷懒,直接使用嘉立创上画好的元件导入,和我们自己创建自己画的步骤其实都一样。

qq_33591173的博客 2万+

基于Java的多线程知识初级贯通,简单易懂

多线程

qq_52775534的博客 171

SAP-ABAP:SAP ABAP 深度解析:BAPI 从入门到精通 —— 原理、实战与自定义开发全指南

SAP ABAP BAPI 深度解析摘要 本文全面介绍了 SAP ABAP 中的 BAPI(业务应用程序编程接口)技术,涵盖以下核心内容: BAPI 定义与特点:BAPI 是 SAP 为业务对象提供的标准化编程接口,具有面向对象、封装业务逻辑、标准化错误处理和版本兼容性等特点。 BAPI 与 RFC 关系:所有 BAPI 都是 RFC,但需额外满足业务对象注册、标准化参数和错误处理等要求。 BAPI 核心作用:包括业务逻辑封装、系统集成、标准化错误处理、版本兼容和审计合规。 实战演示:通过创建销售订单的完整

baidu_35680696的博客 1034

博途S7-1500T 使用工艺对象驱动液压轴(含SimaHydTO库)

利用工艺对象控制液压轴位置含PLC控制和仿真程序文档资料下载地址如下:液压比例伺服阀的相关应用知识请参看下面的博客文章:液压位置闭环控制(比例伺服阀应用)_RXXW_Dor的博客-优快云博客。

RXXW_Dor的博客 2901

简单易懂:Java中多线程的基础知识(一)

本文内容将会告诉大家什么是Java中的线程以及多线程的概念。在此之前我们要先了解进程和线程的区别是什么? 一:线程 原 理 进程:每个进程都有独立的代码和数据空间,进程是资源分配的最小单位,每个独立的程序占有一个进程。(也可以说是程序在一个数据集成上运行的过程) 线程:表示程序的执行流程,是CPU调度执行的基本单位,同一类线程共享代码和数据空间,进程是线程...

qq_46291038的博客 247

【地图模块算法】二维全局地图的开源方案及对比--gmapping、hector、karto、cartographer

系列文章目录 提示:这里可以添加系列文章的所有文章的目录,目录需要自己手动添加 TODO:写完再整理 文章目录系列文章目录前言一、gmapping算法建图【基于Raoo-Blackwellized粒子滤波(RBPF)算法】1.gmapping理论(1)gmapping的工作原理(2)gmapping的算法流程(3)gmapping论文理论2.gmappingROS工程框架解析(1)gmapping的功能包架构(2)gmapping订阅和发布的话题(3)gmapping算法建图参数(4)gmapping源码

qq_35635374的博客 3438

Java多线程基础知识以及IDEA入门简单快捷键

Java多线程基础知识,列举了IDEA开发过程中常用的一些快捷键

qq_49674227的博客 436

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

Java 多线程的一些知识 和简单代码实现

程序     存在磁盘中的引用 进程     运行在内存中的程序 线程 概念     轻量级的进程         同一进程下,可有许多的线程,这些线程共享堆内存和方法区         同一进程下,不同线程有不同的栈内存和程序计数器 作用     提高进程的执行效率 线程安全     synchronized  锁机制         锁对象         锁方法 ...

如果能思维清晰,从上往下,不断深入,就好了~~~ 310

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

JAVA知识 简单记录-多线程

研究文章: http://www.cnblogs.com/dolphin0520/p/3920373.html http://blog.youkuaiyun.com/escaflone/article/details/10418651 一、内存模型概念: 程序在运行过程中,会将运算需要的数据从主存复制一份到CPU的高速缓存当中,那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其

lyylkj12的专栏 345

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

简单说说Java知识点 -- 多线程

  一)多线程执行代码是如何实现的   假设有三个线程A、B、C,CPU通过给这三个线程分配时间片,时间片就是每个线程的执行时间,时间片是由CPU通过算法循环分配的。当A执行完一个时间片后切换到C去执行,C也执行完一个时间片后再切换到B或A去执行,并不能保证会切换到哪个线程去执行,但会保证已生成的每个线程都得到执行,而在切换线程时会保存上一个线程执行任务的状态,以便切换回去时继续执行。   二...

weixin_30639719的博客 84

Java多线程入门

线程是程序执行流的最小单元,是 CPU 调度和分派的基本单位。一个进程可以包含多个线程。往底层一点说,线程是CPU和内存之间提取代码的一个通道本文介绍了 Java 多线程的基础知识,包括线程和多线程的概念、创建线程的方式以及线程同步等内容。通过学习这些基础知识,你可以开始编写简单的多线程程序。在实际开发中,多线程编程还涉及到更多的高级知识,如线程池、并发集合等,需要进一步深入学习。

2401_86909484的博客 872

java做的简单的时钟

应用图形用户界面和多线程的知识,编写一个带界面的时钟程序,应用多线程实现时钟的走动,要求简单的数字时钟即可。 import java.awt.BorderLayout; import java.awt.Container; import java.util.Calendar; import java.util.GregorianCalendar; import javax.swing.JFrame; import javax.swing.JLabel; public class Clock { public

weixin_46142447的博客 904

《互联网大厂 Java 面试:核心知识、框架与中间件大考验》

面试接近尾声,面试官看着王铁牛说:“今天的面试就到这里了。:Dubbo 可以将服务提供者的服务信息注册到注册中心(如 Zookeeper、Nacos 等),服务消费者可以从注册中心获取服务提供者的地址信息,从而实现服务的调用。:Dubbo 提供了多种负载均衡算法,如随机、轮询、最少活跃调用数等,可以根据不同的场景选择合适的负载均衡算法,将请求均匀地分发到多个服务提供者上。在互联网大厂的一间安静的面试室内,严肃的面试官正对面坐着略显紧张的程序员王铁牛,一场关于 Java 核心知识的面试即将拉开帷幕。

hjc_1732的博客 774

Java多线程:基础与实践

多线程是Java编程中的一个重要概念,它允许程序同时执行多个任务。在Java中,每个线程都是一个独立的执行路径,可以共享进程的资源,如内存空间和文件句柄。多线程编程可以提高程序的执行效率,特别是在处理大量并发任务时。

qq_40014433的博客 526

Java中的多线程编程

http://www.cnblogs.com/baoguo/articles/826534.html  Java中的多线程编程主要内容初识Java多线程线程的生命周期Java多线程程序设计方法多线程应用示例线程的优先级、同步* 初识多线程一个简单的多线程的示例class ManyThread extends

icecityman的专栏 451

java基础知识

java基础知识   如果对您有帮助 ,请多多支持.多少都是您的心意与支持,一分也是爱,再次感谢!!!  支付宝赞赏:     Java基本概念     Java 语言的优点?   简单、高效 Java 语言与 C++ 类似,如果用户了解 C++ 和面向对象的概念,就可以很快编写出 Java 程序;此外,Java 又不同于诸如 C++ 语言提供的各种各样的方法,它只提供了基...

从放弃到开始 793

java多线程编程详细总结

一、多线程的优缺点 多线程的优点: 1)资源利用率更好2)程序设计在某些情况下更简单3)程序响应更快 多线程的代价: 1)设计更复杂虽然有一些多线程应用程序比单线程的应用程序要简单,但其他的一般都更复杂。在多线程访问共享数据的时候,这部分代码需要特别的注意。线程之间的交互往往非常复杂。不正确的线程同步产生的错误非常难以被发现,并且重现以修复。 2)上下文切换的开销当CPU从执行一个线程切...

weixin_30432179的博客 95

【Java】技术知识简概

程序员对技术知识的熟练程度,决定了编程能力。本文内容主要是对Java语言知识做的一个简单整理概括。

m0_68255241的博客 959
上一篇: 【JavaSE】面向对象——属性和方法
下一篇: 微服务注册中心简介
Java技术那些事儿
博客等级 码龄5年 2306粉丝 2584原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值