Java多线程详解

最新推荐文章于 2024-04-28 10:00:51 发布
最新推荐文章于 2024-04-28 10:00:51 发布
阅读量202 收藏
点赞数
分类专栏： Java Java基础 文章标签： 多线程 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a549654065/article/details/97617821
版权

一、基本概念

程序(program)

是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。


进程(process)

进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
如：运行中的QQ，运行中的MP3播放器


程序是静态的，进程是动态的

进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程(thread)

进程可进一步细化为线程，是一个程序内部的一条执行路径。
若一个进程同一时间并行执行多个线程，就是支持多线程的
线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开
销小
一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以 访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资 源可能就会带来安全的隐患。


举一个简单的例子：

我们打开电脑上的360安全卫士，这个时候启动了一个进程（可以在任务管理器里查看），里面有很多功能：电脑体检、电脑杀毒、清理垃圾等，每一项就相当于一个线程，我们可以每一项同步地启动起来，这个时候，我们的360安全卫士就相当于是多线程的。


二、深入理解线程

进程可以细化为多个线程。

每个线程，拥有自己独立的结构：栈（虚拟机栈）、程序计数器（Program Counter Register）

多个线程，共享同一个进程中的结构：方法区、堆。

[外链图片转存失败(img-WRgTBtB6-1564310247749)(pic/1.jpg)]


三、并行和并发

1.单核CPU和多核CPU的理解

单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。

例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以 把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。

如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。


2.并行和并发

并行：多个CPU同时执行多个任务，也就是同一时刻，有多条指令在多个处理器上同时执行。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务，也就是同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得宏观上有多个进程执行的效果。比如：秒杀、多个人做同一件事


四、创建线程的四种方法

方式一：继承Thread类的方式：

    1. 创建一个继承于Thread类的子类
    1. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
    1. 创建Thread类的子类的对象
    1. 通过此对象调用start()：①启动当前线程 ② 调用当前线程的run()

示例：

public class MyThread extends Thread {
	
	private int i;
	
	public void run() {
		for (; i < 10; i++) {
			// 当线程类继承Thread类时，直接使用this获取当前线程
			// Thread对象的getName()返回当前线程的名字
			// 因此可以直接调用getName()方法返回当前线程的名字
			System.out.println(getName() + " " + i);
		}
	}
	
	public static void main(String[] args) {
		MyThread my1 = new MyThread();
		MyThread my2 = new MyThread();
		my1.start();
		my2.start();
	}
}

输出：

Thread-0 0
Thread-0 1
Thread-1 0
Thread-1 1
Thread-1 2
Thread-0 2
Thread-0 3
Thread-0 4
Thread-1 3
Thread-0 5
Thread-1 4
Thread-1 5
Thread-0 6
Thread-1 6
Thread-0 7
Thread-1 7
Thread-0 8
Thread-1 8
Thread-0 9
Thread-1 9

方式二：实现Runnable接口的方式：

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

示例：

public class MyThread2 implements Runnable{

	private int i;
	
	@Override
	public void run() {
		for (; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + " " + i);
		}
	}
	
	public static void main(String[] args) {
		MyThread2 mt = new MyThread2();
		new Thread(mt,"新线程1==========").start();
		new Thread(mt,"新线程2----------").start();
	}

}

输出：

新线程1========== 0
新线程2---------- 0
新线程1========== 1
新线程2---------- 2
新线程1========== 3
新线程2---------- 4
新线程1========== 5
新线程1========== 7
新线程2---------- 6
新线程1========== 8
新线程2---------- 9

注意：一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常"IllegalThreadStateException"。


方式三：实现Callable接口：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 创建线程的方式三：实现Callable接口。 --- JDK 5.0新增
 *
 *
 * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
 * 1. call()可以有返回值的。
 * 2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
 * 3. Callable是支持泛型的
 *
 */
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

使用线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 创建线程的方式四：使用线程池
 *
 * 好处：
 * 1.提高响应速度（减少了创建新线程的时间）
 * 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
 * 3.便于线程管理
 *      corePoolSize：核心池的大小
 *      maximumPoolSize：最大线程数
 *      keepAliveTime：线程没有任务时最多保持多长时间后会终止
 */
class NumberThread implements Runnable{

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

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

五、线程的生命周期

线程的生命周期经历通常要经历五个状态

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建 状态

就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源

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

阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行， 进入阻塞状态

死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束


六、守护线程

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

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


七、线程同步

线程安全问题：

  • 多个线程在操作共享的数据。
  • 操作共享数据的线程代码有多条。

有个经典的例子：银行取钱

假如我卡上有3000元，我去银行取2000元，银行需要判断你卡里有没有够2000元，如果够的话再给你钱，这个时候，如果你的同学A也有你的账号，在银行判断你卡里够不够2000元的时候，A也去银行取钱取2000元，这时候A看到的银行余额仍是3000元，那这样一来不就总计拿到了4000元了吗？好爽！

当然，银行是不会出现这样的纰漏的！

那么这个线程安全的问题仍然存在，该怎么解决呢？

解决线程安全的问题是使线程同步 ，我们有3种方法：

  1. 同步代码块
  2. 同步方法
  3. Lock

同步代码块

Java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块。

同步代码块的语法格式如下：

synchronized(obj){
 	// 此处的代码就是同步代码块   
}

括号里的obj就是同步监视器。同步监视器的目的是阻止两个线程对同一个共享资源进行并发访问。

上面代码的含义就是：线程开始执行同步代码块之前，必须先获得对同步监视器的锁定。


同步方法

与同步代码块对应，Java的多线程安全支持还提供了同步方法，同步方法就是使用synchronized关键字来修饰某个方法，这个方法称为同步方法。同步方法的同步监视器是this，也就是调用该方法的对象。

同步方法的语法格式如下：

修饰符 synchronized 方法返回值 methodName(){
    
}

Lock

通过显示定义同步锁对象来实现同步，比较常用的是ReentrantLock（可重入锁）。

private final ReentrantLock lock = new ReentrantLock();
public void m(){
    lock.lock();
    try{
        // 需要保证线程安全的代码
    }
    // 使用finally来保证释放锁
    finally{
        lock.unlock();
    }
}

八、线程通信

线程通信

这里我直接用一个例子演示一下线程通信

/**
 * 线程通信的例子：使用两个线程打印 1-100。线程1, 线程2 交替打印
 *
 * 涉及到的三个方法：
 * wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
 * notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
 * notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
 *
 * 说明：
 * 1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
 * 2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
 *    否则，会出现IllegalMonitorStateException异常
 * 3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
 *
 */
class Number implements Runnable{
    private int number = 1;
    private Object obj = new Object();9
    @Override
    public void run() {

        while(true){

            synchronized (obj) {

                obj.notify();

                if(number <= 100){

                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;

                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }else{
                    break;
                }
            }

        }

    }
}


public class CommunicationTest {
    public static void main(String[] args) {
    	Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("线程1");
        t2.setName("线程2");

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

如果还不理解，我们再来研究一个经典的生产者/消费者问题


/**
 * 线程通信的应用：经典例题：生产者/消费者问题
 *
 * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，
 * 店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员
 * 会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品
 * 了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
 *
 * 分析：
 * 1. 是否是多线程问题？是，生产者线程，消费者线程
 * 2. 是否有共享数据？是，店员（或产品）
 * 3. 如何解决线程的安全问题？同步机制,有三种方法
 * 4. 是否涉及线程的通信？是
 *
 */
class Clerk{

    private int productCount = 0;
    //生产产品
    public synchronized void produceProduct() {

        if(productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName() + ":开始生产第" + productCount + "个产品");

            notify();

        }else{
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    //消费产品
    public synchronized void consumeProduct() {
        if(productCount > 0){
            System.out.println(Thread.currentThread().getName() + ":开始消费第" + productCount + "个产品");
            productCount--;

            notify();
        }else{
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

class Producer extends Thread{//生产者

    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ":开始生产产品.....");

        while(true){

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.produceProduct();
        }

    }
}

class Consumer extends Thread{//消费者
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName() + ":开始消费产品.....");

        while(true){

            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.consumeProduct();
        }
    }
}

public class ProductTest {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        p1.setName("生产者1");

        Consumer c1 = new Consumer(clerk);
        c1.setName("消费者1");
        Consumer c2 = new Consumer(clerk);
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();

    }
}

九、死锁

当两个线程相互等待对方释放同步监视器时就会发生死锁。

下面看个经典实例：


class A {
	public synchronized void foo(B b) {
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了A实例的foo方法"); // ①
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用B实例的last方法"); // ③
		b.last();
	}

	public synchronized void last() {
		System.out.println("进入了A类的last方法内部");
	}
}

class B {
	public synchronized void bar(A a) {
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了B实例的bar方法"); // ②
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用A实例的last方法"); // ④
		a.last();
	}

	public synchronized void last() {
		System.out.println("进入了B类的last方法内部");
	}
}

public class DeadLock implements Runnable {
	A a = new A();
	B b = new B();

	public void init() {
		Thread.currentThread().setName("主线程");
		// 调用a对象的foo方法
		a.foo(b);
		System.out.println("进入了主线程之后");
	}

	public void run() {
		Thread.currentThread().setName("副线程");
		// 调用b对象的bar方法
		b.bar(a);
		System.out.println("进入了副线程之后");
	}

	public static void main(String[] args) {
		DeadLock dl = new DeadLock();
		new Thread(dl).start();
		dl.init();
	}
}

输出：

当前线程名: 主线程 进入了A实例的foo方法
当前线程名: 副线程 进入了B实例的bar方法
当前线程名: 主线程 企图调用B实例的last方法
当前线程名: 副线程 企图调用A实例的last方法

可以看到程序既无法向下执行，也不会抛出任何异常，就一直僵持着。

程序中两个线程执行，副线程的线程执行体是DeadLock类的run方法，主线程的线程执行体是DeadLock的main()方法。其中run()方法中让B对象调用bar()方法，init()方法让A对象调用foo()方法。

健康搬砖人
关注
专栏目录
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
热门推荐
吴名氏的博客
06-09 9万+
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
单核CPU如何执行多线程
dotNET跨平台
01-11 1282
概述在多处理器系统中，多个线程在不同的内核上同时执行。例如，如果有两个线程和两个内核，则每个线程将在单个内核上运行。在单处理器系统中，多个线程执行一个接一个的执行，或者等到一个线程完成或被操作系统抢占，这取决于线程的优先级和操作系统策略。但是正在运行的线程给人一种错觉，认为它们可以同时运行，相对于用户空间应用程序所需的应用程序响应时间。时间比较(示例)：如果两个线程各自花费10us执行，那么在2处...
多线程原理和使用
最新发布
dx19980715的博客
04-28 918
进程是:一个应用程序（1个进程是一个软件）。线程是：一个进程中的执行场景/执行单元。
单核CPU使用多线程能否提高效率?
Dug_Zhang的博客
10-14 4126
首先在回答这个问题前要明白几个概念: ①:什么是线程上下文切换 ②:什么是CPU时间片 明白这两个概念后,我们再说答案(能/不能) 一，如果是CPU密集型作业,------不能 假设一段耗时总共为10s的代码(不涉及io操作),使用单线程执行,只需要10s的时间,当使用多线程执行时,就会涉及到线程的上下文切换,这时耗时肯定会超过10s的,所以这种情况下不能提高效率。 二，如果是IO密集型的作业,----能 同理,一段代码(线程使用CPU执行2s的运...
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
java 多线程详解
03-20
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提升系统效率。在Java中，实现多线程主要有两种方式：继承Thread类和实现Runnable接口。这篇博文详细介绍了这两种方法以及它们之间的差异。 1....
Java中多线程
weixin_39735358的博客
10-23 237
java多线程
在单核CPU下，有必要存在多线程吗？
搏·梦的博客
03-01 9068
我们使用一个例子来说明问题，在单核CPU的情况下，存在4个需要执行任务，有如下两种情况运行方式： 使用多线程执行这些任务，会发生线程上下文切换。 一个一个任务按顺序执行完成。 上述两种情况，到底那个执行效率会快呢？ 分析：第一种情况明显发生很多次线程的上下文切换，我们知道线程的上下文切换是很消耗性能的，而第二种情况发生的则是一个任务完成再执行下一个任务，基本没线程切换，那么讲道理，难道是第二种情况下更加快了，那么就抛出个问题在单核CPU下，有必要存在多线程吗？ 我们需要清楚的认识到：多线程..
Java高级编程之多线程
weixin_44508223的博客
06-16 260
Java编程之多线程 补充： Eclipse每一个workspce都有一个.metaspace，包含该工作空间的一些配置。 而IntelliJIDEA则有一个统一的config文件夹 Eclipse中的workspace相当于IDEA中的project Eclipse中的project相当于IDEA中的Module 关于idea安装： 从官网下载.exe文件，然后配置 ...
Java面试题：单核CPU支持多线程吗？
韩云昊的菜园
08-16 1388
答案：支持，CPU通过给每个线程分配CPU时间片（时间单元）来实现这个机制。由于CPU频率很高，故时间单元非常短，用户不易察觉。
单核CPU处理多线程
qq_35896136的博客
04-29 4842
1.(单核CPU)同一时间,cpu只能处理1个线程,只有1个线程在执行 2.多线程同时执行:是CPU快速的在多个线程之间的切换 3.cpu调度线程的时间足够快,就造成了多线程的“同时”执行 4.如果线程数非常多,cpu会在n个线程之间切换,消耗大量的cpu资源 5.每个线程被调度的次数会降低,线程的执行效率降低 ...
基本功：线程上下文切换
weixin_44458365的博客
09-25 843
由于现在大多计算机都是多核CPU，多线程往往会比单线程更快，更能够提高并发，但提高并发并不意味着启动更多的线程来执行。更多的线程意味着线程创建销毁开销加大、上下文非常频繁，你的程序反而不能支持更高的TPS。可以看另一篇《Java从线程安全到synchronized和Lock探索》 时间片 多任务系统往往需要同时执行多道作业。作业数往往大于机器的CPU数，然而一颗CPU同时只能执行一项任务，如何...
单核cpu多线程有必要吗？
luzhensmart的专栏
05-13 7192
通常一个任务不光 cpu 上要花时间， io 上也要花时间（例如去数据库查数据，去抓网页，读写文件等）。 一个进程在等 io 的时候， cpu 是闲置的，另一个进程正好可以利用 cpu 进行计算。 多几个进程一起跑，可以把 io 和 cpu 都跑满了。 现在一般都是虚拟资源，资源有弹缩机制，所以一般该跑多线程的时候就可以跑多线程。 单核cpu多线程有必要吗？ 问题分析# 现代计算机一般都是多...
单核多线程与多核多线程
qq_27185561的博客
09-29 1万+
单核多线程与多核多线程 或许有些同学对于单核多线程和多核多线程有点误区，因为会听到一些同学问为什么单核能处理多线程，总结了一些干货，下面会通俗说明下。 线程和进程是什么 线程是CPU调度和分配的基本单位（可以理解为CPU只能看到线程） 进程是操作系统进行资源分配（包括cpu、内存、磁盘IO等）的最小单位 单核多线程 单核多线程指的是单核CPU轮流执行多个线程，通过给每个线程分配CPU时间片来实...
单核CPU,多线程与性能
weixin_30877493的博客
11-23 563
问题概述 单核CPU的计算机上,多线程能够提高程序运行的性能吗?这个问题看起来简单,实际很复杂,设计到多方面的因素.首先我们要把概念搞清楚,那就是什么是性能?一般来说,我们把运行一个任务所花的时间来评价性能,所花的时间可以是在CPU上,也可能是在I/O操作上,运行任务的程序,也可能同时在运行另外若干的任务(吞吐量).这里我们把概念给缩小一下: ...
Java多线程详解：优势与应用场景
"Java多线程详解：为什么需要多线程及其实现方式" Java多线程是编程中一个至关重要的概念，它使得程序能够同时处理多个任务，从而提高效率和响应速度。多线程在现代软件开发中扮演着不可或缺的角色，尤其是在需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值