线程学习笔记（一）

最新推荐文章于 2024-07-13 11:25:38 发布
最新推荐文章于 2024-07-13 11:25:38 发布
阅读量378 收藏
点赞数
分类专栏： Java SE/EE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fire_Sky_Ho/article/details/104640724
版权

目录

1.创建多线程的第一种方式：继承Therad，重写Thread的run方法，调用start方法启动

2.也可以不使用继承，创建Thread类的匿名子类的方式

3.Thread常用方法

个别方法问题

4.创建多线程的方式二:实现Runnable接口

5.比较创建线程的两种方式。

6.线程的生命周期

         7.多线程安全问题解决办法-----synchronized：

        1.我们使用实现Runnable来举例

        解决办法： 

        方式一:同步代码块,只能有一人操作，相当于单线程，效率低

        2.使用继承Thread方式，要注意共享的变量设置成静态，这样才是唯一的，每个窗口都是共享这100张票

        方式二:同步方法

8.关于同步方法的总结:

创建多线程的第一种方式：继承Therad，重写Thread的run方法，调用start方法启动

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }

    public static void main(String[] args) {
        //主线程的
        MyThread myThread = new MyThread();
        //还是主线程帮你调用,使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
        //如果调用run（）那么还是在主线程上执行
        myThread.start();
        //如果要在执行一次，那么就得在新建对象执行，不能重复执行start（），不然会报错
        //MyThread myThread1 = new MyThread();
        //myThread1.start();
        //主线程的
        for (int i = 0; i < 100; i++) {
            System.out.println(i + "main");
        }
    }
}

结果:

0main
1main
2main
3main
4main
......
100main

 

也可以不使用继承，创建Thread类的匿名子类的方式

public static void main(String[] args) {

        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(getPriority() + "=" + i);
                    if (i == 20) {
                        yield();
                    }
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                setPriority(10);
                for (int i = 0; i < 100; i++) {
                    System.out.println(getPriority() + "=" + i);
                }
            }
        }.start();
}

上面这个结果:你以为第一个线程到20的时候会让另一个线程运行，实际上不一定，以下是我测试的某次结果，会发现到20都没开始避让。

5=19
5=20
5=21
5=22
10=0
10=1
10=2

 

Thread常用方法

  • start()：使该线程开始执行；Java 虚拟机调用该线程的 run 方法
  • run()：要在新线程种执行的方法
  • currentThread()：静态方法，返回对当前正在执行的线程对象的引用
  • getName()：获取当前线程名字
  • setName()：设置当前线程名字
  • yield()：暂停当前正在执行的线程对象，并执行其他线程
  • join()：阻塞当前调用它的线程，等待join执行完毕，当前线程继续执行
  • sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），阻塞状态
  • setPriority(int newPriority)：更改线程的优先级，线程的优先级用1～10 表示，1的优先级最低，10的优先级最高，默认值是5；高优先级抢占低优先级CPU执行权，只是从概率上来讲，比较高，不一定成功

                                         

个别方法问题：

1.面试官：请问启动线程是start()还是run()方法，能谈谈吗？
应聘者：start()方法
当用start()开始一个线程后，线程就进入就绪状态，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。但是这并不意味着线程就会立即运行。只有当cpu分配时间片时，这个线程获得时间片时，才开始执行run()方法。start()是方法，它调用run()方法.而run()方法是你必须重写的. run()方法中包含的是线程的主体(真正的逻辑)。 

 

2.在上面那个例子，关于yield方法，参考：https://www.cnblogs.com/java-spring/p/8309931.html

Java线程中的Thread.yield( )方法，译为线程让步。顾名思义，就是说当一个线程使用了这个方法之后，它就会把自己CPU执行的时间让掉，让自己或者其它的线程运行，注意是让自己或者其他线程运行，并不是单纯的让给其他线程。
        yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！
      举个例子：一帮朋友在排队上公交车，轮到Yield的时候，他突然说：我不想先上去了，咱们大家来竞赛上公交车。然后所有人就一块冲向公交车，
有可能是其他人先上车了，也有可能是Yield先上车了。
     但是线程是有优先级的，优先级越高的人，就一定能第一个上车吗？这是不一定的，优先级高的人仅仅只是第一个上车的概率大了一点而已，
     最终第一个上车的，也有可能是优先级最低的人。并且所谓的优先级执行，是在大量执行次数中才能体现出来的。

 

3.join方法案例，参考https://blog.csdn.net/u013425438/article/details/80205693?depth_1-

public class JoinTetst {

    public static void main(String[] args) throws InterruptedException {
        ThreadTest a = new ThreadTest();
        ThreadTest b = new ThreadTest();
        System.out.println(Thread.currentThread().getThreadGroup().activeCount());
        System.out.println("主线程开始");
        System.out.println("a开始");
        a.setName("线程a");
        a.start();
        System.out.println(a);
        a.join();
        System.out.println("a结束");
        b.setName("线程b");
        b.start();
        System.out.println("主线程");
    }
}

class ThreadTest extends Thread {

    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + "-" + i);
        }
    }
}
2
主线程开始
a开始
Thread[线程a,5,main]
线程a-1
线程a-2
线程a-3
线程a-4
线程a-5
a结束
主线程
线程b-1
线程b-2
线程b-3
线程b-4
线程b-5

可以看出，t1开始和结束的语句打印，都是在A线程执行前后，说明是把调用join()的当前线程挂起，让t1线程执行完毕之后，再开始主线程继续往下执行。

join源码，哪个线程调用的wait()呢，其实哪个线程调用的join就是那个线程,所以main线程会被挂起。

t1调用的wait，是指t1对象调用的wait，而不是t1线程调用的wait，这个地方是相当于main线程调用了t1对象的wait方法，不要把把t1对象和t1线程搞混了。

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

 

 

创建多线程的方式二:实现Runnable接口

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

public class Test1 {
    public static void main(String[] args) {
        rThead r = new rThead();
        Thread t1 = new Thread(r);
        t1.start();
        //还要在执行一次，在新建就好
        Thread t2 = new Thread(r);
        t2.start();
    }
}

class rThead implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "=" + i);
        }
    }
}

 

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

开发中:优先选择:实现Runnable接 口的方式，原因:

  1. 实现的方式没有类的单继承性的局限性
  2. 实现的方式更适合来处理多个线程有共享数据的情况。

联系: public class Thread impl ements Runnable
相同点:两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

 

线程的生命周期

线程的生命周期包含5个阶段，包括：新建、就绪、运行、阻塞、销毁。

  • 新建：就是刚使用new方法，new出来的线程；

  • 就绪：就是调用的线程的start()方法后，这时候线程处于等待CPU分配资源阶段，谁先抢的CPU资源，谁开始执行;

  • 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run方法定义了线程的操作和功能;

  • 阻塞：在运行状态的时候，可能因为某些原因导致运行状态的线程变成了阻塞状态，比如sleep()、wait()之后线程就处于了阻塞状态，这个时候需要其他机制将处于阻塞状态的线程唤醒，比如调用notify或者notifyAll()方法。唤醒的线程不会立刻执行run方法，它们要再次等待CPU分配资源进入运行状态;

  • 销毁：如果线程正常执行完毕后或线程被提前强制性的终止或出现异常导致结束，那么线程就要被销毁，释放资源;

 

 

多线程安全问题解决办法-----synchronized：

 模拟火车站售票程序，有100张票，开启三个窗口售票，买票前先打印剩余票数，然后在减少票数。

1.我们使用实现Runnable来举例

public class Sell {
    public static void main(String[] args) {
        window window = new window();
        Thread thread1 = new Thread(window);
        Thread thread2 = new Thread(window);
        Thread thread3 = new Thread(window);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class window implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
            while (ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "=" + ticket);
                ticket--;
            }
    }
}

 结果： 打印哪个线程查询剩余票数，然后票数减1

Thread-0=100
....
Thread-2=61
//票数相同
Thread-0=60
Thread-1=60
Thread-2=59
......
Thread-1=5
Thread-0=4
Thread-2=3
Thread-1=2
Thread-0=1
//出现0，-1的票数
Thread-2=0
Thread-1=-1

会发现，还剩-1和0的票数竟然买了，明显不正确，为什么呢？

我们看最后三条打印记录

阻塞：

  1. 因为我们使用了sleep方法，当Thread-0进来被休眠变成阻塞状态
  2. 这时cpu把资源就给了另一个线程Thread-2执行，进到run方法，也被阻塞
  3. cpu又把资源给了Thread-1，进到run方法，也被阻塞

苏醒（休眠完毕）：

  1. 这时Thread-0首先休眠完毕，发现还有1张票，就打印出来，然后减1等于0
  2. 随后Thread-2第二个醒来，发现票数变为0就打印，再减1等于-1
  3. Thread-1也醒来，发现票数变为-1就打印，再减1

其实期间，还会出现票数相等的状况，为什么呢？

  1. 因为两个线程按顺序苏醒了（相差非常小的时间）
  2. Thread-0执行打印语句 Thread-0=60,本该按顺序在执行ticket--
  3. 但是这时CPU却切换到另一个线程Thread-1，导致Thread-0打印出来却还没票数减1
  4. 所以Thread-1线程开始执行打印语句，也打印出 Thread-1=60 票数相同

解决办法： 

当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，b线程才可以开始操作ticket。这种情况即使线程a出现阻塞，也不能被改变。

方式一:同步代码块,只能有一人操作，相当于单线程，效率低

synchronized(同步监视器（锁）){
//需要被同步的代码}
说明:

  1. 操作共享数据的代码，即为需要被同步的代码
  2. 共享数据:多个线程共同操作的变量。比如: ticket就是共享数据。
  3. 同步监视器，俗称:锁。任何一个类的对象，都可以充当锁。
  4. 要求:多个线程必须要共用同一把锁，就是这个对象必须是唯一的

我们只需修改，Window类

1.使用锁对象

class window implements Runnable {
    private int ticket = 100;
    Object object = new Object();

    @Override
    public void run() {
        while (ticket > 0) {
            synchronized (object) {
                //进来还得在判断一次，否则可能其他线程，已经进到while循环里，不判断的话就会继续减，出现1，-0的状况
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "=" + ticket--);
                }
            }
        }
    }
}

2.使用this，因为this指向当前对象，且当前对象只有一个，被new了一次，所以每个线程是使用同一个锁

class window implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (ticket > 0) {
            synchronized (this) {
                //进来还得在判断一次，否则可能其他线程，已经进到while循环里，不判断的话就会继续减，出现1，-0的状况
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "=" + ticket--);
                }
            }
        }
    }
}

执行结果，就是按顺序100到1打印了，注意，synchronized (object)不能包含到while (ticket > 0)，否则就是一直同一个线程（单个窗口）在执行语句（卖票），一直等while循环结束才放弃锁

哪个线程抢到锁，谁就能运行，不管他阻不阻塞，若果sleep参数是300，那么就是每三秒才卖出一张票（每三秒打印出语句）。 

 

2.使用继承Thread方式，要注意共享的变量设置成静态，这样才是唯一的，每个窗口都是共享这100张票

1.锁对象要设置成静态

public class Sell {
    public static void main(String[] args) {
        window w1 = new window();
        window w2 = new window();
        window w3 = new window();
        w1.start();
        w2.start();
        w3.start();
    }
}

class window extends Thread {
    //要设置成静态否则，每次new对象都是新的一个ticket，不共享
    private static int ticket = 100;
    //锁也是要设置成静态，不然每次new对象都是新的一个objcet，锁就不唯一了
    private static Object object = new Object();

    @Override
    public void run() {
        while (ticket > 0) {
            synchronized (object) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "=" + ticket--);
                }
            }
        }
    }
}

2.锁使用当前对象的class，就不用再new一个静态锁对象了，window 改成以下这样

class window extends Thread {
    //要设置成静态否则，每次new对象都是新的一个ticket，不共享
    private static int ticket = 100;

    @Override
    public void run() {
        while (ticket > 0) {
            synchronized (window.class) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "=" + ticket--);
                }
            }
        }
    }
}

方式二:同步方法

1.实现Runnable,把操作共享数据的代码写成一个方法，使用synchronized，不能在run使用synchronized，因为会把while包起来，相当于，一个窗口（线程）一直循环卖票，就不能三个窗口一起卖了。

public class Sell {
    public static void main(String[] args) {
        window window = new window();
        Thread thread1 = new Thread(window);
        Thread thread2 = new Thread(window);
        Thread thread3 = new Thread(window);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class window implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (ticket > 0) {
            buy();
        }
    }

    public synchronized void buy() {
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "=" + ticket--);
        }
    }
}

2.继承Thread，synchronized使用方式

public class Sell {
    public static void main(String[] args) {
        window w1 = new window();
        window w2 = new window();
        window w3 = new window();
        w1.start();
        w2.start();
        w3.start();
    }
}

class window extends Thread {
    //要设置成静态否则，每次new对象都是新的一个ticket，不共享
    private static int ticket = 100;

    @Override
    public void run() {
        while (ticket > 0) {
            buy();
        }
    }

    public synchronized void buy() {//同步监视器（锁）,w1,w2,w3
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "=" + ticket--);
        }
    }
}

如果也像Runnable那样处理，结果会发现还是出现问题，为啥呢？

因为每次都是new一个window对象，同步代码块synchronized 的锁是本身，每个人都有自己的锁，肯定不行，所以要设置成静态方法，共享一个方法。

......
Thread-0=3
Thread-1=2
Thread-0=1
Thread-2=0
Thread-1=-1

改成如下，加个static就行，这时的锁对象就是window.class，那就都是同一个了。

    public static synchronized void buy() {//同步监视器window.class
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "=" + ticket--);
        }
    }

 

关于同步方法的总结:

  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
  2. 非静态的同步方法，同步监视器是: this
  3. 静态的同步方法，同步监视器是:当前类本身，即类.class
Fire_Sky_Ho
关注
专栏目录
多线程学习笔记
03-18
多线程学习笔记 iOS开发中，多线程是一种常见的技术手段，用于优化应用程序的性能，提升用户体验。多线程的核心是让程序能够并发地执行多个任务，合理地利用设备的计算能力，尤其是在拥有多个核心的处理器上。 ...
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
记面试题。。。
Fire_Sky_Ho的博客
02-27 6418
去除字符串中的转义符\n 输入：一个带转义字符’\ n’的字符串 要求：删除转义字符’\ n’和它前面的字符，如果遇到多个连续的’\n’，则删除相同数量的转义字符和前面的字符 输出：最终的结果字符串 举例：输入”abc\n\nd\n\nnghi”，期望输出”nghi” String s = "abc123梅丽娜W:**LDM<\n\nd\n\nngh\ni"; ...........................
桥接模式案例（代码）讲解
Fire_Sky_Ho的博客
01-17 1028
参考一小点：https://www.cnblogs.com/WindSun/p/10260547.html 图一 ...
Java 多线程学习笔记
最新发布
2301_76962889的博客
07-13 1880
*进程：**是操作系统进行资源分配和调度的基本单位，是程序的一次执行过程。**例如：**当你打开一个应用程序，如浏览器、音乐播放器等，操作系统就会为其创建一个进程。**线程：**是进程的一个执行单元，是 CPU 调度和分派的基本单位，一个进程可以包含多个线程。**例如：**在浏览器进程中，可以有多个线程同时运行，例如一个线程负责页面渲染，另一个线程负责网络请求。提高 CPU 利用率，充分利用多核处理器**例如：**下载软件使用多线程可以同时下载多个文件片段，充分利用带宽，提高下载速度。
多线程基础学习笔记
旋风小陀螺
03-12 1506
多线程基础学习笔记
C++多线程学习笔记（一）
m0_63932570的博客
05-04 2135
今天是五月三号，五一放假五天，博主也就给自己放了三天假，去游山玩水，吃美食。今天是第四天了，也该慢慢找回学习的状态啦。所以今天博主也是改变自己最近懒惰的状态，来开始自己学习多线程的基础知识。多线程这部分内容对于java，c++爱好者应该不陌生，经常听到或看到的吧。建议在学完c++基础语言知识后的同学们，还是值得学一下这部分内容的（其实也不算很多内容）。下面我们正式开始来看看吧 1.理解多线程。 多线程并发指的是在同一个进程中执行多个线程。C++11提供了语言层面上的多线程，包含在头文件<threa
线程学习笔记
qq_42286362的博客
01-12 1644
一、线程创建 1、继承线程 Thread 类： ·class TestThread extends Thread 2、实现 Runnable 接口 ·class TestThread implements Runnable ·然后 new Thread(new Thread()).start ·这里实际上是new TestThread() 这个实现 Runnable 接口的类，然后把这个类传入Thread ·源码中，内部保存 TestThread ，然后默认的Thread run 方法执行 TestThre
C#多线程学习笔记
wangyunman的博客
08-23 789
C#多线程 1、多线程使用一般方法 Thread t = new Thread(new ThreadStart(Method)); Method为无参函数，若要传递参数，可以将Method的参数设置为object类型。 2、多线程处理List 最近碰到了多线程处理List的问题，开始的想法是开启5个线程，每个线程轮流获取List中的字符串，但是处理完一个字符串就有一个问题，线程无法重用，线程重用可...
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3449
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
java多线程学习笔记
weach的博客
12-19 911
java多线程
JVM学习笔记一（线程私有的内存区域）
01-20
虚拟机栈在线程运行时，每执行一个方法，都会对应生成一个栈帧，放入栈中。每个时刻正在运行的方法是虚拟机栈顶部的栈帧，方法的执行就是一个出栈与入栈的操作。虚拟机栈的大小默认为1M，可以使用参数-Xss来进行调整...
多线程学习笔记.docx
06-16
多线程是指在一个应用程序中存在多个并发执行的线程，它们共享同一内存空间，这样可以提高程序的执行效率。 在Java中，有三种创建线程的方式： 1. **继承Thread类**：创建一个新的类，该类继承自Thread类，然后...
python线程教程,python线程学习笔记.doc
10-01
这样，一次只有一个线程能够执行销售操作，保证了票的数量不会因并发访问而出错。 需要注意的是，互斥锁的使用会带来一些性能影响，因为它可能导致线程阻塞等待。因此，使用锁时应谨慎，尽量减少锁的持有时间，避免...
for循环给list赋值是，要注意list要初始化且放过在for外面
Fire_Sky_Ho的博客
05-03 5931
public List<Category> findAll() { Jedis jedis = JedisUtil.getJedis(); Set<Tuple> cSet = jedis.zrangeWithScores("category", 0, -1); List<Category> clist = nul...
java.lang.IllegalStateException: Cannot call sendRedirect() after the response has been committed
Fire_Sky_Ho的博客
03-30 4166
public class loginServlet extends HttpServlet { protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { request.setCharacter...
单元测试junit+mock
Fire_Sky_Ho的博客
02-09 3023
单元测试（unit testing），是指对软件中的最小可测试单元进行检查和验证。至于“单元”的大小或范围，并没有一个明确的标准，“单元”可以是一个方法、类、功能模块或者子系统。，如果单从概念上来讲两者是有区别的，不过我们通常所说的“单元测试”和“白盒测试”都认为是和代码有关系的，所以在某些语境下也通常认为这两者是同一个东西。还有一种理解方式，。
微信加解密流程，证书作用讲解，官方SDK使用教程
Fire_Sky_Ho的博客
11-23 2892
API证书，是指由商户申请的，用来证实商户身份的证书。API证书由证书授权机构Certificate Authority（简称CA）颁发。证书中包含商户的商户号、公司名称、公钥等信息。微信支付平台证书是指由微信支付 负责申请的，包含微信支付平台标识、公钥信息的证书。商户可以使用平台证书中的公钥进行验签。
多线程学习笔记：概念与初步实践
"关于多线程学习总结" 在计算机科学中，多线程是并发执行的编程模型，允许程序在同一时间处理多个任务。这种技术尤其在需要优化资源利用和提高响应速度的应用中至关重要。多线程使得程序员能够在一个进程中创建多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值