多线程基础

已于 2023-08-06 16:30:29 修改
阅读量103 收藏
点赞数
分类专栏： 多线程 文章标签： java
于 2023-07-16 19:42:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53737485/article/details/131754029
版权
例：

        把程序理解成一个餐厅，那么服务员就是线程，如果一个餐厅只有一个服务员，那么从客人进餐厅开始，所有的工作都是一个服务员来执行，比如，从客人进来之后的接待，点餐，炒菜，端菜，搽桌子，洗碗等等相关工作都是一个服务员来完成。如果中间任何时候有其他客人，那么这个客人就会在餐厅外面等待，这样显然是不符合我们的逻辑的。所以就有了多线程的概念。

1.概述

        几乎所有操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序就是一个进程。当一个程序运行时，内部可能包含了多个顺序执行流，每个顺序执行流就是一个线程。

2.线程和进程

        几乎所有的操作系统都支持进程的概念，所有运行中的任务通常对应一个进程(Process)。当一个程序进入内存运行时，即变成成一个进程。进程是出于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。

        一般而言，进程包含了如下三个特征

  1. 独立性：进程是系统中独立存在的实体，它可以拥有自己独立的资源，每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。
  2. 动态性：进程与程序的却别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念。进程具有自己的生命周期和各种不同的状态，这些概念在程序中多是不具备的。
  3. 并发性：多个进程可以在单个处理器上并发执行，多个进程之间是不会相互影响的。

注意：并发性(concurrency)和并行性(parallel)是两个概念，并行指在统一时刻，有多条指令在多个处理器上同时执行；并发指在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。

3.多线程的优势

        线程在程序中是独立的，并发的执行流，与分割的进程相比，进程中线程之间的隔离程度要小。它们共享内存，文件句柄和其他每个进程应有的状态。因为线程的划分尺度小于进程，使得多线程程序的并发性高。进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

        总结起来，使用多线程变成具有如下几个有点，

  1. 进程之间不能共享内存，但是线程之间共享内存非常容易，
  2. 系统创建进程时需要为该进程重新分配系统资源，但创建线程则代价要小得多，因此使用了多线程来实现多任务并发比多进程得效率高
  3. Java语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了Java的多线程变成。
3.线程的创建和启动

        Java使用Thread来代表线程，所有的线程对象都必须是Thread类或其子类，每个线程的作用是完成一定的任务，实际上就是执行一段程序流(一段顺序执行的代码)。Java使用线程执行体来代表这段程序流。

3.1继承Thread类创建线程类

        继承Thread类，重写run()方法，该fun()方法的方法体就代表了线程需要完成的任务。因此把run()方法称为线程执行体，然后在调用它的start()方法来启动线程。

package com.yuangc.demo;

import java.util.concurrent.TimeUnit;

public class TestThread {

    public static void main(String[] args) throws InterruptedException {
        ThreadHolder holder = new ThreadHolder();
        System.err.println("执行run方法,线程名称:" + Thread.currentThread().getName());
        holder.start();
//        TimeUnit.SECONDS.sleep(3);
        System.err.println("结束run方法,线程名称:" + Thread.currentThread().getName());
    }
    /**
     * 输出的结果
     * 执行run方法,线程名称:main
     * 结束run方法,线程名称:main
     * 通过继承Thread类创建线程,线程名称:Thread-0
     */
}

class ThreadHolder extends Thread {

    @Override
    public void run() {
        System.err.println("通过继承Thread类创建线程,线程名称:" + Thread.currentThread().getName());
    }
}

是不是跟我们以前的代码输出不一样呢，就是因为我们在执行holder.start()的时候是启用了异步去执行的。

这里的输出结果不一定就是这样的，因为CPU的执行速度太快了所以会这样，线程的执行是抢占式的，谁拿到了CPU的资源谁去执行。如果把TimeUnit.SECONDS.sleep(3);放开的话，那么就会按照我们以前同步的顺序执行

3.2实现Runnable接口创建线程类

        定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程知兴替

        创建Runnable实现类的实体，并以此示例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象

SecondThread st = new SecondThread();
new Thread(st, "demo task");     // 也可以指定线程名称

Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体，而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

public class TestRunnable {

    public static void main(String[] args) {
        RunnableHolder holder = new RunnableHolder();
        System.err.println("执行run方法,线程名称:" + Thread.currentThread().getName());
        new Thread(holder, "demo runnable task").start();
//        TimeUnit.SECONDS.sleep(3);
        System.err.println("结束run方法,线程名称:" + Thread.currentThread().getName());
    }
}

/**
 * 输出结构
 * 执行run方法,线程名称:main
 * 结束run方法,线程名称:main
 * 通过实现Runnbale接口创建线程,线程名称:demo runnable task
 */
class RunnableHolder implements Runnable {

    @Override
    public void run() {
        System.err.println("通过实现Runnbale接口创建线程,线程名称:" + Thread.currentThread().getName());
    }
}

通过实现Runnable接口创建线程，本质上和继承Thread区别不是太大，我们在new Thread()的时候，其实就是传递的一个线程执行体过去，

public Thread(Runnable target, String name) {
    init(null, target, name, 0);
}
3.3实现Callable和future创建线程

        前面已经指出，通过实现Runnable接口创建多线程时，Thread类的作用就是把run()方法包装成线程执行体。那么是否可以直接把任意方法都包装成线程执行体呢，答案肯定是不行的。但是C#可以，所以也许是受此启发，从Java5开始，Java就提供了一个Callable接口，该接口怎么看都想是Runnable接口的增强版，Callable接口提供了一个call()方法作为线程的执行体，单call()比run()方法功能更强。

1.call()方法可以有返回值

2.call()方法可以声明抛出异常

        因此完全可以提供一个Callable对象作为作为Thread的target。而该线程的线程执行体就是该Callable对象的call()方法，问题是Callable接口是Java5新增的接口，而且他不是Runnalbe接口的子接口，所以Callable对象不能直接作为Thread的target。而且call()方法还有返回值，同时call()方法并不是直接调用，它是作为线程执行体被调用的。那么如何获取call()方法的返回值呢，

Java5提供了Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现了Future接口，并实现了Runnable接口，所以Future可以作为Thread类的target。在Future接口定义了如下几个公共方法来控制它关联的Callable任务。

// 试图取消该Future里关联的Callable任务。
boolean cancel(boolean mayInterruptIfRunning); 

// 返回Callable任务里call()方法的返回值，调用该方法将导致程序阻塞，必须等到子线程结束后才会得到返回值
V get();

// 返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间，如果经过指定时间后Callable依然没有返回值，将会抛出TimeoutException异常。
V get(long timeout, TimeUnit unit);

// 如果在Callable任务正常完成前被取消，则返回True
boolean isCancelled();

// 如果Callable任务已完成，则返回True
boolean isDone();

Callable接口有泛型限制，Callable接口里的泛型形参类型与call()方法返回值类型相同。而且Callable接口是函数式接口，因此也可以使用函数式接口。

public class TestCallable {

    public static void main(String[] args) {
        CallableHolder holder = new CallableHolder();
        System.err.println("执行run方法,线程名称:" + Thread.currentThread().getName());
        FutureTask<String> futureTask = new FutureTask<>(holder);
        new Thread(futureTask, "demo callable task").start();
        try {
            String value = futureTask.get();
//            String s1 = futureTask.get(10, TimeUnit.SECONDS);
            System.err.println("获取到的返回值" + value);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        System.err.println("结束run方法,线程名称:" + Thread.currentThread().getName());
    }
}

/**
 * 输出结果
 * 执行run方法,线程名称:main
 * 通过实现Callable接口创建线程,线程名称:demo callable task
 * 获取到的返回值callable
 * 结束run方法,线程名称:main
 */
class CallableHolder implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.err.println("通过实现Callable接口创建线程,线程名称:" + Thread.currentThread().getName());
        return "callable";
    }
}

其实使用Callable接口和Runnable接口没有太大的区别，只不过Callable有返回值还可以声明的抛出异常。

4.创建线程的三种方式对比

        通过继承Thread类或实现Runnable接口，Callable接口都可以实现多线程，不过实现Runnable接口与实现Callable接口的方式基本相同，只是Callable接口里定义的方法有返回值，可以声明抛出异常而已。因此可以将实现Runnable接口和实现Callable接口归为一种方式。这种方式与继承Thread方式之间的主要差别如下

1.线程类只是实现了Runnable接口或Callable接口，还可以继承其他类

2.在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU，代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

3.劣势是，变成稍稍的复杂，如果需要访问当前线程，则必须使用Thread.currentThread()方法。

4.劣势是，因为线程类已经继承了Thread类，所以不能再继承其他父类。

5.优势是，编写简单，如果需要访问当前线程则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

鉴于上面分析，因此一般推荐采用实现Runnable接口或者Callable接口的方式来创建多线程。

5.线程的生命周期

        当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态，在线程的生命周期中，它要经过新建(New)  就绪(Ready)  运行(Run)  阻塞(Blocked)和死亡(Dead)5中状态。尤其是当线程启动以后，它不可能一直霸占着CPU独自运行，所以CPU需要在多线程之间切换，于是线程状态也会多次在运行和就绪之间切换。

5.1新建和就绪

         当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时它和其他的Java对象没有任何区别，仅仅由Java虚拟机为其分配内存，并初始化其成员变量的值。此时的线程对象没有表现出任何线程的动态特征，程序也不会执行线程的线程执行体。

        当线程对象调用了start()方法后，该线程处于就绪状态，Java虚拟机会为其创建方法调用栈和程序计数器，处于这个状态中的线程线程并没有开始运行，只是表示该线程可以运行了。至于该线程何时开始运行，取决于JVM里线程调度器的调度。

启动线程使用start()方法，而不是run()方法！永远不要调用线程对象的run()方法！调用start()方法来启动线程，系统会把run()方法当成线程执行体来处理，但是如果直接调用线程对象的run()方法，则run()方法立即就会被执行，而且在run()方法返回之前其他线程无法并发执行——也就是说，如果直接调用线程对象的run()方法，系统把线程对象当成一个普通对象，而run()方法也是一个普通方法，而不是线程执行体。

public class TestNewReady {

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            CommonUtils.printThreadLog(Thread.currentThread().getName());
            if (i == 20) {
                new InvokeRun().run();
                new InvokeRun().run();
            }
        }
    }
}

class InvokeRun extends Thread {

    @Override
    public void run() {

        for (int i = 0; i < 100; i++) {
            CommonUtils.printThreadLog(Thread.currentThread().getName() + i);
        }
    }
}

上面程序创建线程对象后直接调用了线程对象的run()方法，程序运行的结果是整个程序只有一个线程(同步)；主线程。

所以如果是异步，启动线程的正确方法是调用Thread类中的start()方法，而不是直接调用run()方法，否则就变成单线程程序了。

注意：只能对处于新建状态的线程调用start()方法，否则将引发异

调用线程对象的start()方法之后，该线程立即进入就绪状态——就绪状态相当于“等待执行”，但该线程并未真正进入运行状态。

如果希望调用子线程的start()方法后子线程立即执行，主线程可以使用Thread.sleep(1)来主线程睡眠1毫秒——1毫秒就够了。因为CPU不会空闲，它会去执行另一个处于就绪状态的线程，这样子线程就可以立即执行了。

5.2运行和阻塞

        如果处于就绪状态的线程获得了CPU执行权，开始执行run()方法中的线程执行体，则该线程处于运行状态，如果计算机只有一个CPU，那么在任何时刻只有一个线程处于运行状态。当前，在一个多处理器的机器上，将会有多个线程并行(注意是并行：parallel)执行；当线程数大于处理器数时，依然会存在多个线程在同一个CPU上轮换的现象。

        当一个线程开始运行后，它不可能一直处于运行状态(除非它的线程执行体足够短，瞬间就执行结束了)，线程在运行过程中需要被中断，目的是使其他线程获得执行的机会，线程调度的细节取决于底层平台所采用的策略，对于采用抢占式策略的系统而言，系统会给每个可执行的线程一个小时间短来处理任务；当该时间段用完后，系统就会剥夺该线程所占用的资源，让其他线程获得执行的机会。在选择下一个线程时，系统会考虑线程的优先级

所有现代的桌面和服务器操作系统基本都采用抢占式调度的策略，但一些小型设备如手机则可能采用协作式调度策略，在这样的系统中，只有当一个线程调用了它的sleep()或yield()方法后才会放弃所占用的资源——也就是必须由该线程主动放弃所占用的资源。

当发生如下情况时，线程将会进入阻塞状态。

  • 线程调用了sleep()方法主动放弃所占用的处理器资源
  • 线程调用了一个阻塞式IO方法，在该方法返回之前，该线程被阻塞
  • 线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有
  • 线程在等待某个通知(notify)
  • 程序调用了线程的suspend()方法将该线程挂起。但这个方法容易导致死锁，所以应该尽量避免使用该方法

当前正在执行的线程被阻塞之后，其他线程就可以获得执行的机会，被阻塞的线程会在合适的时候重新进入就绪状态，注意是就绪状态而不是运行状态，也就是说，被阻塞的线程则色解除后，必须重新等待线程调度器再次调度它。

针对上面几种情况，当发生如下特定的情况时可以解除上面的阻塞，让线程重新进入就绪状态。

  • 调用sleep()方法的线程经过了指定时间
  • 线程调用的阻塞式IO方法已经返回
  • 线程成功的获得了试图取得的同步监视器
  • 线程正在等待某个通知，其他线程发出了一个通知
  • 处于挂起状态的线程被调用了resume()恢复方法
5.3死亡

        线程会以如下三种方法结束，结束后线程就处于死亡状态。

  1. run()或call()方法执行完成，线程正常结束
  2. 线程抛出一个未捕获的Exception或Error
  3. 直接调用该线程的stop()方法来结束该线程——该方法容易导致死锁，通常不推荐使用

当主线程结束时，其他线程不受任何影响，并不会随之结束。一旦子线程启动起来后，它就拥有和主线程相同的地位，他不会受到主线程的影响。

        检查线程是否已经死亡，可以调用线程的isAlive()方法，当线程处于就绪  运行  阻塞三种状态时返回true，当线程处于新建  死亡两种状态时，该方法将返回false。

不要试图对一个已经死亡的线程调用start()方法使它重新启动，死亡就是死亡，该线程将不可再次作为线程执行。

5.4生命周期图

6.线程控制

        Java的线程支持提供了一些便捷的工具方法，通过这些便捷的工具方法可以很好地控制线程的执行。

6.1Join线程

        Thread提供了让一个线程等待另一个线程完成的方法——join()方法。当在某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到被join()方法加入的join()线程执行完为止。

        join()方法通常由使用线程的程序调用，以将大问题划分成许多小问题，每个小问题分配一个线程。当所有的小问题都得到处理后，在调用主线程来进一步操作。

public class TestJoin {

    public static void main(String[] args) throws InterruptedException {
        new JoinHolder("新线程").start();
        for (int i = 0; i < 100; i++) {
            if (i == 20) {
                JoinHolder joinHolder = new JoinHolder("被Join的线程");
                joinHolder.start();
                // main线程调用了joinHolder线程的join()方法，main线程必须要等到joinHolder线程执行结束才会向下执行
                joinHolder.join();
            }
            CommonUtils.printThreadLog(Thread.currentThread().getName() + i);
        }
    }
}

class JoinHolder extends Thread {

    public JoinHolder(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            CommonUtils.printThreadLog(this.getName());
        }
    }
}

上面代码一共有三个线程，主方法开始时就启动了名为"新线程"的子线程，该子线程将会和main线程并发执行。当主线程的循环变量 i 等于20时，启动了名为 "被Join的线程"的线程，该线程不会和main线程并发执行，main线程必须等该线程执行结束后才可以向下执行。在名为"被Join的线程"的线程执行时，实际上只有2个线程在并发执行，而主线程(main)处于等待状态。

join()方法有三个重载方法

  1. join()  等待被join的线程执行完成
  2. join(long millis)  等待被join的线程的时间最长为millis毫秒，如果在millis毫秒内被join的线程还没有执行完成，则不在等待
  3. join(long millis, int nanos)  等待被join的线程的时间最长为millis毫秒加nanos微毫秒

通常很少使用第三种形式，原因有两个，程序时间的精度无需精确到毫微秒；计算机硬件  操作系统本身也无法精确到毫微秒。

6.2后台线程

        有一种线程，它是在后台运行的，它的任务是为其他的线程提供服务，这种线程被称为"后台线程(Daemon Thread)"，又称为"守护线程"或"精灵线程"。JVM的垃圾回收线程就是典型的后台线程。

        后台线程有个特征，如果所有的前台线程都死亡，后台线程会自动死亡。

        调用Thread对象的setDaemon(true)方法可将线程设置成后台线程。下面程序将执行线程设置成后台线程，可以看到当所有的前台线程都死亡时，后台线程随之自动死亡。

public class TestDaemonThread {

    public static void main(String[] args) {
        DaemonThreadHolder daemonThreadHolder = new DaemonThreadHolder();
        daemonThreadHolder.setDaemon(true);
        daemonThreadHolder.start();

        for (int i = 0; i < 10; i++) {
            CommonUtils.printThreadLog(Thread.currentThread().getName() + i);
        }
    }
}

/**
 * 输出结果
 * <p>
 * 1691308451914 | 12 | Thread-0 | Thread-00
 * 1691308451914 | 1 | main | main0
 * 1691308451914 | 1 | main | main1
 * 1691308451914 | 1 | main | main2
 * 1691308451914 | 12 | Thread-0 | Thread-01
 * 1691308451914 | 1 | main | main3
 * 1691308451914 | 12 | Thread-0 | Thread-02
 * 1691308451914 | 1 | main | main4
 * 1691308451914 | 12 | Thread-0 | Thread-03
 * 1691308451914 | 1 | main | main5
 * 1691308451914 | 12 | Thread-0 | Thread-04
 * 1691308451914 | 1 | main | main6
 * 1691308451914 | 1 | main | main7
 * 1691308451914 | 1 | main | main8
 * 1691308451914 | 12 | Thread-0 | Thread-05
 * 1691308451914 | 1 | main | main9
 * 1691308451914 | 12 | Thread-0 | Thread-06
 * 1691308451914 | 12 | Thread-0 | Thread-07
 * 1691308451914 | 12 | Thread-0 | Thread-08
 * 1691308451914 | 12 | Thread-0 | Thread-09
 * 1691308451914 | 12 | Thread-0 | Thread-010
 * 1691308451914 | 12 | Thread-0 | Thread-011
 * 1691308451914 | 12 | Thread-0 | Thread-012
 * 1691308451914 | 12 | Thread-0 | Thread-013
 * 1691308451914 | 12 | Thread-0 | Thread-014
 * 1691308451914 | 12 | Thread-0 | Thread-015
 * 1691308451914 | 12 | Thread-0 | Thread-016
 * 1691308451914 | 12 | Thread-0 | Thread-017
 */
class DaemonThreadHolder extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            CommonUtils.printThreadLog(Thread.currentThread().getName() + i);
        }
    }
}

上面程序可以看到，当我们main线程执行完之后 Thread-0只执行17次，我们设置的要执行100，因为设置了它为后台线程，当主线程结束了，那么后台线程也就自动结束。

前台线程死亡后，JVM会通知后台线程死亡，但从它接收指令到做出响应，需要一定的时间。而且要将某个线程设置为后台线程，必须在该线程启动之前设置，也就是说，setDaemon(true)必须在start()方法之前调用，否则会引发异常。

6.3线程睡眠

        如果需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread类的静态sleep()方法来实现，sleep()方法有两种重载的形式。

  1. static void sleep(long millis)：让当前正在执行的线程暂停millis毫秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响。
  2. static void sleep(long millis, int nanos)：让当前正在执行的线程暂停millis毫秒加nanos毫微秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准确度的影响

与前面类似，程序很少调用第二种形式的sleep()方法。

        当前线程调用sleep()方法进入阻塞状态后，在其睡眠时间段内，该线程不会获得执行的机会，即使系统中没有其他可执行的线程，处于sleep()中的线程也不会执行，因此sleep()方法常用来暂停程序的执行。

        此外，Thread还提供了一个和sleep()类似的yield()静态方法，它也可以让当前正在执行的线程暂停，但它不会阻塞该线程，它只是将该线程转入就绪状态。yield()只是让当前线程暂停一下，让系统的线程调度器重新调度一次，完全可能的情况是；当某个线程调用了yield()方法暂停之后，线程调度器又将其调度出来重新执行。

实际上，当某个线程调用了yield()方法暂停之后，只有优先级与当前线程相同，或者优先级比当前线程更高的处于就绪状态的线程才会获得执行的机会。

sleep()方法和yield()方法区别

  1. sleep()方法暂停当前线程后，会给其他线程执行机会，不会理会其他线程的优先级；但yield()方法只会给优先级相同，或优先级更高的线程执行机会。
  2. sleep()方法会将线程转入阻塞状态，直到经过阻塞时间才会转入就绪状态，而yield()不会将线程转入阻塞状态，它只是强制当前线程进入就绪状。因此完全有可能某个线程被yield()方法暂停之后，立即再次获得处理器执行权被执行。
  3. sleep()方法声明抛出了异常，所以调用sleep()方法时要么捕捉该异常，要么显式声明抛出该异常；而yield()方法则没有声明抛出任何异常
  4. sleep()方法比yield()方法有更好的可移植性，通常不建议使用yield()方法来控制并发线程的执行。
6.4线程的优先级

        每个线程执行时都具有一定的优先级，优先级高的线程获得较多的执行机会，而优先级低的线程则获得较少的执行机会。

        每个线程默认的优先级都与创建它的父线程的优先级相同，在默认的情况下，main线程具有普通的优先级，由main线程创建的子线程也具有普通的优先级。

        Thread类提供了setPriority(int newPriority)  getPriority()方法来设置和返回执行线程的优先级，其中setPriority()方法的参数可以是一个整数，范围是1~10之间，也可以使用Thread类的如下三个静态变量

  1. MAX_PRIORITY：其值是10
  2. MIN_PRIORITY：其值是1
  3. NORM_PRIORITY：其值是5

虽然Java提供了10个优先级级别，但这些优先级级别需要操作系统的支持。遗憾的是，不同操作系统上的优先级并不相同，而且也不能很好的和Java的10个优先级对应，例如Windows 2000 仅提供了7个优先级。因此应该尽量避免直接为线程指定优先级，而应该使用MAX_PRIORITY  MIN_PRIORITY  NORM_PRIORITY三个静态常量来设置优先级，这样才可以保证程序具有最好的可移植性

洛逸风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++ 多线程基础及 C++11 多线程库总结
生命在于折腾！
10-22 3596
1. 多线程基础 1.1 进程与线程 根本区别： 进程是操作系统资源分配的基本单位，线程是任务调度和执行的基本单位 开销方面： 每个进程都有自己独立的代码和数据空间，程序之间的切换开销较大。 线程可以看作是轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器，线程之间切换开销小。 所处环境： 一个操作系统能同时运行多个进程（程序）。 在一个进程中，可以有多个线程同时执行。 内存分配方面： 系统在运行的时候会为每个进程分配不同的内存空间。 对线程而言，系统不会为
Java多线程基础知识
gldzzznb的博客
04-10 3350
这是我再次学习多线程知识的一个总结，对于刚刚接触的学习者是比较友好易懂的，便于快速的理解和掌握。
多线程基础与基于多线程的简单聊天室
06-24
本压缩包“多线程基础与基于多线程的简单聊天室”提供了对多线程技术的实践理解和二次开发的基础。以下是关于这个主题的详细知识点： 1. **多线程的概念**：多线程是指在一个程序中同时执行多个不同的线程，每个...
多线程基础部分.md，学习代码
06-21
我们将围绕标题“多线程基础部分”展开，结合描述和标签，重点关注Java中的多线程、软件设计以及并发编程的相关概念。 首先，让我们理解什么是多线程。在计算机科学中，线程是程序执行的基本单位，一个进程可以包含...
Java多线程干货系列（1）Java多线程基础编程开发技术
11-22
Java多线程是Java编程中的重要...以上内容仅涵盖了Java多线程基础编程的一部分知识点，实际开发中还需要关注更多的并发控制策略、性能优化和调试技巧。对于深入理解Java多线程，还需要学习和实践更多相关的高级特性。
java多线程基础知识
01-25
Java多线程基础知识 Java多线程基础知识是Java编程语言中的一项重要技术，用于提高程序的执行效率和响应速度。在这里，我们将详细介绍Java多线程基础知识的相关概念和技术。 一、程序、进程和线程 程序（Program...
spring事务详细讲解-深入浅出
小电玩
09-08 412
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1423
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1345
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 347
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
自定义Stater
m0_63624484的博客
09-07 691
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
央顺科技官方博客
09-05 553
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
MyBatis面试
Tony_yitao的博客
09-09 549
MyBatis面试
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 309
步骤很详细，直接上教程……
SpringBoot总结
2302_77073236的博客
09-06 232
都做成图了，方便理解和掌握全局关系。
多线程基础与应用详解
"多线程基础ppt - 适合初学者的多线程入门教材，由闫益伟于2012.03.20编撰，作为STP项目组的培训资料" 在深入探讨多线程之前，我们首先要理解一些基本概念。程序是一系列按照特定顺序排列的计算机指令，它们被编写...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值