Java多线程（全知识点）

已于 2022-10-28 19:40:11 修改
阅读量391 收藏 5
点赞数 4
分类专栏： Java基础实验 文章标签： java jvm 开发语言
于 2022-10-26 21:43:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51447496/article/details/127540288
版权

Java多线程

概述：本文为Java多线程的基础知识点的第一部分，主要包括，通过继承Thread来实现进程，线程调度，线程控制，run(),start(),join(),sleep(),setDaemon()方法的使用，获取线程名字currentThread()，线程同步，非静态锁，静态方法的锁，Lock锁，生产者与消费者问题，卖票问题。

简介

在这里插入图片描述
线程：是进程中的单个顺序控制流，是一条执行路径

  • 单线程：一个进程如果只有一条执行路径，则称为单线程程序
  • 多线程：一个进程如果有多条执行路径，则称为多线程程序

举例

  • 记事本属于单线程程序
  • 扫雷属于多线程程序

方式一

方式一：继承Thread类

  • 定义一个类MyThread类
  • 在MyThread类中重写run()方法
  • 创建MyThread类的对象
  • 启动线程

两个问题：

  • 为什么要重写run()方法？
    因为run()是用来封装被线程执行的代码
  • run()方法和start()方法的区别？
    run()：封装线程执行代码，直接调用，相当于普通方法的调用
    start()：启动线程；然后由JVM调用此线程的run()方法

run()

package com.one.container;
public class MyThreadDemo {
    public static class MyThread extends Thread{
        public MyThread(){}
        public MyThread(String name){  // 自定义一个有参的构成方法
            super(name);
        }
        @Override
        public void run() {
            for (int i = 0; i < 100; ++ i){
                System.out.println(getName()+":"+i);
            }
        }
    }
    public static void main(String[] args){
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        my1.setName("高铁");
        my2.setName("飞机");
        my1.run();  // run方法 相当于单线程的
        my2.run();

    }
}
}

运行结果：
在这里插入图片描述

start()

讲解代码：

package com.one.container;
import java.util.Scanner;
import java.util.Arrays;

public class Main {
	// 通过继承Thread类来创造属于自己的MyThread
    public static 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 my1 = new MyThread();
        MyThread my2 = new MyThread();
//        my1.run();  run方法 相当于单线程的
//        my2.run();
		// 然后调用start方法
        my1.start();
        my2.start();
    }
}

运行结果：
在这里插入图片描述

设置和获取线程的名称

Thread.currentThread().getName():获取当当前的线程的名称

代码讲解：

public class MyThreadDemo {
    public static class MyThread extends Thread{
        public MyThread(){}
        public MyThread(String name){  // 自定义一个有参的构成方法
            super(name);
        }
        @Override
        public void run() {
            for (int i = 0; i < 100; ++ i){
                System.out.println(getName()+":"+i);
            }
        }
    }
    public static void main(String[] args){

        // 自定义的有参构造方法 不需要直接调用setName设置线程名称
        MyThread my1 = new MyThread("高铁");
        MyThread my2 = new MyThread("飞机");
        my1.start();
        my2.start();

        // 返回对象前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());
    }
}

运行结果：
在这里插入图片描述

线程调度

线程调度

线程有两种调度模型

  • 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占有的CPU的时间片
  • 抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机一个，优先级高的线程获取的CPU时间片相对多一些

Java使用的抢占式的调度模型

假如计算机只有一个CPU，那么CPU在某一时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令，所以说多线程程序在执行的是有随机性，因为谁抢到CPU的使用权是不一定的

Thread类中设置和获取线程优先级的方法

  • public final int getPriority(): 返回此线程的优先级
  • public final void setPriority(int new Priority): 更改此线程的优先级
    线程默认优先级是5；线程优先级的范围是：1-10
    线程优先级高仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要大家结果
public class MyThreadDemo {
    public static class ThreadPriority extends Thread{
        @Override
        public void run() {
            for (int i = 0; i < 100; i ++){
                System.out.println(getName()+":"+i);
            }
        }
    }
    public static void main(String[] args){
        // 创建进程对象
        ThreadPriority tp1 = new ThreadPriority();
        ThreadPriority tp2 = new ThreadPriority();
        ThreadPriority tp3 = new ThreadPriority();

        // public final int getPriority();  // 返回线程的优先级
        System.out.println(tp1.getPriority());
        System.out.println(tp2.getPriority());
        System.out.println(tp3.getPriority());
        
        // 设置进程名字
        tp1.setName("高铁");
        tp2.setName("飞机");
        tp3.setName("汽车");

        // public final void setPriority(int newPriority); 更改此线程的优先级
        // tp1.setPriority(10000);
//        System.out.println(Thread.MAX_PRIORITY); // 最高优先级
//        System.out.println(Thread.MIN_PRIORITY); // 最小优先级
//        System.out.println(Thread.NORM_PRIORITY); // 正常优先级
        tp1.setPriority(Thread.NORM_PRIORITY);
        tp2.setPriority(Thread.MAX_PRIORITY);
        tp3.setPriority(Thread.MIN_PRIORITY);

        // 启动线程
        tp1.start();
        tp2.start();
        tp3.start();
    }
}

运行结果：
在这里插入图片描述

线程控制

在这里插入图片描述

sleep

学习代码：

public class MyThreadDemo {
    public static class ThreadSleep extends Thread{
        ThreadSleep(){}
        ThreadSleep(String name){
            super(name);
        }
        @Override
        public void run() {
            for (int i = 0; i < 100; i ++){
                System.out.println(getName()+":"+i);
                try{
                    Thread.sleep(1000);  // 休眠1s
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args){
        ThreadSleep ts1 = new ThreadSleep("曹操");
        ThreadSleep ts2 = new ThreadSleep("刘备");
        ThreadSleep ts3 = new ThreadSleep("孙权");

        ts1.start();
        ts2.start();
        ts3.start();
    }
}

运行结果：
在这里插入图片描述

join

学习代码：

public class MyThreadDemo {
    public static class ThreadJoin extends Thread{
        ThreadJoin(){}
        ThreadJoin(String name){
            super(name);
        }
        @Override
        public void run() {
            for (int i = 0; i < 10; i ++){
                System.out.println(getName()+":"+i);
            }
        }
    }
    public static void main(String[] args){
        ThreadJoin tj1 = new ThreadJoin("路飞");
        ThreadJoin tj2 = new ThreadJoin("索隆");
        ThreadJoin tj3 = new ThreadJoin("山治");

        tj1.start();
        try {
            tj1.join();  // 等路飞 这个线程结束了 下面两个线程才会
            // 执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
}

运行结果：
在这里插入图片描述

setDaemon

在这里插入图片描述

学习代码：

public class MyThreadDemo {
    public static class ThreadDaemon extends Thread{
        ThreadDaemon(){}
        ThreadDaemon(String name){
            super(name);
        }
        @Override
        public void run() {
            for (int i = 0; i < 10; i ++){
                System.out.println(getName()+":"+i);
            }
        }
    }
    public static void main(String[] args){
        ThreadDaemon td1 = new ThreadDaemon("善毅");
        ThreadDaemon td2 = new ThreadDaemon("山之助");

        // 设置主线程名字为炭之郎
        Thread.currentThread().setName("炭之郎");

        // 设置守护线程
        td1.setDaemon(true);  // 要写在start的前面
        td2.setDaemon(true);
        // 鬼灭之刃三人组 炭之郎死后 二位小弟也要一同共赴黄泉
        td1.start();
        td2.start();
        for (int i = 0; i < 10; ++ i){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

运行结果：
在这里插入图片描述

在这里插入图片描述

方式二

在这里插入图片描述

学习代码：

public class MyThreadDemo {

    // 通过继承Runnable接口来实现多线程
    public static class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10; ++ i){
                // 获取当前进程的名字
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
    public static void main(String[] args){
        MyRunnable my = new MyRunnable();
        Thread t1 = new Thread(my, "高铁");
        Thread t2 = new Thread(my, "飞机");

        t1.start();
        t2.start();
    }
}

运行结果：
在这里插入图片描述

线程同步

案例卖票

在这里插入图片描述

学习代码：

public class MyThreadDemo {

    public static class SellTicket implements Runnable{
        // 默认有100张票
        private int ticket = 100;
        @Override
        public void run() {
            while (true){
                if (ticket > 0){
                    System.out.println(Thread.currentThread().getName()+"正在出售第:"+ticket+"张票");
                    ticket --;
                }
            }
        }
    }
    public static void main(String[] args){
        SellTicket st = new SellTicket();

        // 定义对象
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }

}

运行结果：
在这里插入图片描述

改进之后的思考

在这里插入图片描述
学习代码：

public class MyThreadDemo {

    public static class SellTicket implements Runnable{
        private int ticket = 100;
        @Override
        public void run() {
            while (true){
                if (ticket > 0){
                    try {  // 卖票的时候 添加休眠
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售第:"+ticket+"张票");
                    ticket --;
                }
            }
        }
    }
    public static void main(String[] args){
        SellTicket st = new SellTicket();

        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：
在这里插入图片描述

出现问题：
在这里插入图片描述
在这里插入图片描述

原因分析：

  1. 出现相同的票
    在这里插入图片描述

  2. 出现负数的票
    在这里插入图片描述

安全问题的解决方案

在这里插入图片描述
在这里插入图片描述

学习代码：

public class MyThreadDemo {

        public static class SellTicket implements Runnable{
            private int ticket = 100;
            private Object obj = new Object();  // 在外面定义这个Object对象
            @Override
            public void run() {
                while (true){
                    synchronized (obj){  // 不要在这里面定义这个对象 不然3个进程会产生3把锁 还是不能解决问题
                        if (ticket > 0){
                            try {  // 卖票的时候 添加休眠
                                Thread.sleep(100);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            System.out.println(Thread.currentThread().getName()+"正在出售第:"+ticket+"张票");
                            ticket --;
                        }
                    }
                }
            }
        }
        public static void main(String[] args){
            SellTicket st = new SellTicket();

            Thread t1 = new Thread(st,"窗口1");
            Thread t2 = new Thread(st,"窗口2");
            Thread t3 = new Thread(st,"窗口3");

            t1.start();
            t2.start();
            t3.start();
        }

    }

运行结果：
在这里插入图片描述

同步方法

在这里插入图片描述

非静态的锁

学习代码：

 public class MyThreadDemo {
        public static class SellTicket implements Runnable{
            private int ticket = 100;
            private int x = 0;
            @Override
            public void run() {
                try {  // 卖票的时候 添加休眠
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                while (true){
                    if (x % 2  == 0){
                        synchronized (this){  // 非静态用的this这个锁
                            if (ticket > 0){
                                try {
                                    Thread.sleep(100);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                                System.out.println(Thread.currentThread().getName()+"正在出售第:"+ticket+"张票");
                                ticket --;
                            }
                        }
                    } else {
                        sellTicket();
                    }
                }
            }
            private synchronized void sellTicket(){
                if (ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售第:"+ticket+"张票");
                    ticket --;
                }
            }
        }
        public static void main(String[] args){
            SellTicket st = new SellTicket();

            Thread t1 = new Thread(st,"窗口1");
            Thread t2 = new Thread(st,"窗口2");
            Thread t3 = new Thread(st,"窗口3");

            t1.start();
            t2.start();
            t3.start();
        }
    }

运行结果：
在这里插入图片描述

静态方法的锁

学习代码：

public class SellTicket implements Runnable{
    private static int ticket = 100;
    private int x = 0;
    @Override
    public void run() {
        try {  // 卖票的时候 添加休眠
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while (true){
            if (x % 2  == 0){
                synchronized (SellTicket.class){  // 静态的用这个锁
                    if (ticket > 0){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第:"+ticket+"张票");
                        ticket --;
                    }
                }
            } else {
                sellTicket();
            }
        }
    }
    private static synchronized void sellTicket(){
        if (ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在出售第:"+ticket+"张票");
            ticket --;
        }
    }
线程安全的类

在这里插入图片描述
在这里插入图片描述

案例：生产者与消费者

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
学习代码：

package Safe;

    public class MyThreadDemo {
        // 生产者类
        public static class Producer implements Runnable{
            private Box b;
            public Producer(Box b) {
                this.b = b;
            }

            @Override
            public void run() {
                for (int i = 1; i <= 5; ++ i){ // 放置牛奶
                    b.put(i);
                }
            }
        }

        // 消费者类
        public static class Customer implements Runnable{
            private Box b;
            public Customer(Box b) {
                this.b = b;
            }

            @Override
            public void run() {  // 获取牛奶
                while(true){
                    b.get();
                }
            }
        }
        // 奶箱类
        public static class Box{
            // 定义一个成员变量 表示第x瓶牛奶
            private int milk;

            // 定义一个成员变量，表示奶箱的状态
            private boolean state = false;

            // 提供存储牛奶和获取牛奶的操作
            // 存储牛奶
            public synchronized void put(int milk){
                // 如果有牛奶，等待消费
                if (state){
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 如果没有牛奶，就生产牛奶
                this.milk = milk;
                System.out.println("送奶工将第"+this.milk+"瓶奶放入奶箱");

                // 生产完毕之后，修改奶箱状态
                state = true;

                // 唤醒其他等待线程
                notifyAll();
            }

            // 获取牛奶
            public synchronized void get(){
                // 如果没有牛奶，等待生产
                if(!state){
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 如果有牛奶，就消费牛奶
                System.out.println("用户拿到第"+this.milk+"瓶奶");

                // 消费完毕之后，修改奶箱状态
                state = false;

                // 唤醒其他等待线程
                notifyAll();
            }
        }
        public static void main(String[] args){
            // 创建奶箱对象，这是共享数据区域
            Box b = new Box();

            // 创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类种要调用存储牛奶的操作
            Producer p = new Producer(b);

            // 创建消费者对象，把牛奶对象作为构造方法参数传递，因为在这个类种要调用获取牛奶的操作
            Customer c = new Customer(b);

            // 创建两个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
            Thread t1 = new Thread(p);
            Thread t2 = new Thread(c);

            // 启动线程
            t1.start();
            t2.start();
        }

    }

运行结果：
在这里插入图片描述

Lock锁

在这里插入图片描述

学习代码：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    public static class SellTicket implements Runnable{
        private int ticket = 100;
        private Lock lock = new ReentrantLock();
        @Override
        public void run() {
            while(true){
                try {
                    lock.lock();
                    if (ticket > 0){
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
                        ticket--;
                    }
                } finally {  // 为了使得这个锁怎么都可以释放 所以要用到finally关键字
                    lock.unlock();     
                }
            }
        }
    }
    public static void main(String[] args){
        SellTicket st = new SellTicket();
        Thread t1 = new Thread(st, "窗口一");
        Thread t2 = new Thread(st, "窗口二");
        Thread t3 = new Thread(st, "窗口三");
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：
在这里插入图片描述

极客李华
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
枚举工具类
qq_43049583的博客
08-04 220
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 285
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 617
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 563
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
JavaSE面向对象进阶
qq_45348840的博客
07-30 530
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
花几千上万学习Java，真没必要！（三十五）
wehpd的博客
07-30 703
集合之Map
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 1015
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 189
④创建artifact。②点击加号创建，选择。
安装ElasticSearch
diffiii
07-31 648
(1).使用WinSCP工具拷贝下载好的安装文件jdk-8u121-linux-x64.gz到建的es文件夹下。(5).修改配置文件elasticsearch-5.2.0/Configs/elasticsearch.yml。plugins—这里存放一些常用的插件，如果有一切额外的插件，可以放在这里使用。(2).切换到elasticsearch根目录，启动elasticsearch。data—这里是ES得当前节点的分片的数据，可以直接拷贝到其他的节点进行使用。1.1.1.6 维护elastic。
java中static关键字的作用
weixin_41020960的博客
08-01 628
这意味着这个变量被类的所有实例共享，而不是每个实例拥有自己的副本。类变量可以通过类名直接访问，而不需要创建类的实例。关键字是 Java 中一个非常重要的特性，它允许开发者在不创建对象的情况下访问类的方法和变量，这在很多场景下非常有用。这类方法可以在没有创建类的实例的情况下被调用，它们只能访问类的静态变量和静态方法。关键字也可以用于静态初始化块，这是一段在类加载时执行的代码块，用于初始化静态变量。: 静态变量是不变的，一旦在静态初始化块或静态方法中被初始化，它们的值就不能被修改。关键字可以声明静态内部类。
面向对象程序设计之sort排序
嫌人闲事
07-31 412
敲过排序算法的都会的，Sort排序与compareTo的改写。
spring原理（第六天）
GD2604279407的博客
08-02 546
今天将会学到Aware 接口及 InitializingBean 接口我们可以先了解他们的作用：1. Aware 接口用于注入一些与容器相关信息, 例如a. BeanNameAware 注入 bean 的名字b. BeanFactoryAware 注入 BeanFactory 容器c. ApplicationContextAware 注入 ApplicationContext 容器2. InitializingBean 接口提供了一种【内置】的初始化手段。
day12 Java基础——自增自减运算符，初识Math类
Qhumaing的博客
07-30 325
int b = a++;//执行完这行代码后，先给b复制，再自增1
高级java每日一道面试题-2024年7月31日-并发篇-你对ThreadLocal了解多少?
qq_43071699的博客
07-31 934
是Java中提供的一个类，用于实现线程局部变量。它允许每个线程访问自己的独立变量副本，而不会影响到其他线程中的变量。为每个使用该变量的线程提供了独立的变量实例，因此，即使是多个线程同时访问同一个变量，它们也是访问自己线程内部的那个副本，从而实现了线程间的数据隔离,干扰和同步开销。
【排序算法】Java实现三大非比较排序：计数排序、桶排序、基数排序
yican2580的博客
07-31 1145
本章中详解了数据结构中的三大非计较排序，分析了其原理和优缺点以及效率，最后用Java代码实现出来。
Spring框架中的@AliasFor注解
一起coding，一起嗨。
08-01 272
Spring框架中的@AliasFor注解
Spring AOP概念及原理
sdgfafg_25的博客
07-31 771
Spring AOP 使用代理模式实现横切关注点的管理，主要通过 JDK 动态代理和 CGLIB 动态代理实现。代理对象是通过 AopProxy创建的，其中的 InvocationHandler和 MethodInterceptor负责执行拦截器链的逻辑。Spring AOP 提供了强大的功能来增强 Bean 的行为，使得切面逻辑与核心业务逻辑分离，提升了代码的模块化和可维护性。切面是包含横切逻辑的类。在日志管理的示例中，我们将创建一个切面类来拦截方法调用并记录日志。
三线程分别打印1、2、3顺序执行10次
花木凋零成兰的博客
08-03 319
线程A,B,C分别打印1,2,3;并顺序执行10次;
Java 应用性能优化
Admans的专栏
08-01 949
Java 编程性能调优。包括数据类型，集合容器，网络通信。多线程性能调优。包括线程安全，同步锁的问题，多线程的性能问题。JVM 性能监控及调优。包括Java对象的创建和回收，内存分配。设计模式调优。使用设计模式来优化架构设计。数据库性能调优。数据库最容易成为整个系统的性能瓶颈，包括一些常用的数据库调优方法。任何系统上线都有有性能问题，我们要做的是压力测试，让问题暴露出来。 性能调优的目的： 1）用压力测试暴露响应延迟问题，然后解决客户请求响应的问题。 2）性能优化可以
Java多线程深度解析：知识点与企业实战
以下是对Java多线程知识点的详细总结： 1. **多线程相关概念** - **程序**：一组指令的集合，静态代码。 - **进程**：程序的一次执行实例，动态的，是操作系统分配资源的基本单位。 - **线程**：进程内的执行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

极客李华

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值