多线程的基本使用

最新推荐文章于 2025-11-27 09:46:56 发布
原创 最新推荐文章于 2025-11-27 09:46:56 发布 · 563 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java
本文详细介绍了Java中的多线程概念，包括程序、进程和线程的区别，线程的创建（继承Thread、实现Runnable、Callable接口和使用线程池）以及线程的生命周期。此外，还探讨了线程同步的三种方式（同步代码块、同步方法和使用锁）以及线程通信、死锁问题和守护线程的应用。

一、概念

1.程序、进程、线程

程序

计算机程序是一组计算机能识别和执行的指令，运行于电子计算机上，满足人们某种需求的信息化工具。程序是一个指令序列。

进程

是系统进行资源分配和调度的基本单位，是操作系统结构的基础。进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。 

线程

是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。

一个进程中有多个线程，没条线程做不同的事情，并且共享其中的资源；

2.并发与并行

并发，在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行。（窗口抢票）

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

二、线程的创建和使用

方式一：继承Thread类创建多线程

1.基本使用

步骤：

  1. 继承Thread类 
  2. 重写Thread类的run方法---->将此线程执行的操作放到run方法中 
  3. 创建Thread类的子类的对象
  4. 通过此对象调用start()方法 
public class ThreadDome01 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }

    public static void main(String[] args) {
        ThreadDome01 t1 = new ThreadDome01();
        //1.导致此线程开始执行; 2.Java虚拟机调用此线程的run方法。
        t1.start();
        //问题1：我们不能直接调用run()方法启动线程
        //问题2：不能让已经start()的线程再次调用start方法

        //这个操作通用是在main线程中执行
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println("主:"+i);
            }
        }

    }
}

 2.Thread常用的方法

  1. strat()：启动当前线程，调用当前线程的run();

  2. run()：通常需要重写Thread类中的此方法，将创建的线程要执行的的操作声明在此方法中;

  3. currentThread()：静态方法，返回当前线程;

  4. getName（）：获取当前线程的名字;

  5. setName()：设置当前线程的名字;

  6. yield()：线程礼让(释放当前CPU的执行权);

  7. join():插队(线程A阻塞，执行线程B，直到B线程执行完成);

  8. stop()：强制结束（过时了）;

  9. sleep(long millitime)：休眠，让线程暂时停一会;

3.优先级的调度

MIN_PRIORITY = 1;

NORM_PRIORITY = 5; 默认;

MAX_PRIORITY = 10;

2.获取和设置 getPriority() setPriority();

优先级高只是说抢占CPU的执行权可能性要高，而不是绝对的高

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

1.基本使用

步骤：

  1. 创建一个实现了Runnable接口的类；
  2. 实现类去实现Runnable中的抽象方法 run()；
  3. 创建实现类的对象；
  4. 将此对象作为参数传递到类的构造器中，创建Thread类的对象；
  5. 通过Thread类的对象调用start()；
class MyThead implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}
public class CreateRunable {
    public static void main(String[] args) {
        MyThead m  = new MyThead();
        //通过Thread类的对象调用start()，启动线程
        Thread t1 = new Thread(m);
        Thread t2 = new Thread(m);
        t1.setName("线程一");
        t2.setName("线程二");
        t1.start();
        t2.start();
    }
}

两种方式的对比

class WindowsFall implements Runnable{
    private  int ticket = 100;
    @Override
    public void run() {
        while (true){
            if (ticket>0){
                System.out.println(Thread.currentThread().getName() + "卖了第" + ticket + "张票");
                ticket--;
            }else {
                break;
            }
        }
    }
}

public class exeWindowTest2 {
    public static void main(String[] args) {
        WindowsFall w = new WindowsFall();
        Thread t1 = new Thread(w);
        t1.setName("窗口1：");
        Thread t2 = new Thread(w);
        t2.setName("窗口2：");
        Thread t3 = new Thread(w);
        t3.setName("窗口3：");
        t1.start();;
        t2.start();
        t3.start();
    }
}

 实现Runnbale接口来写的卖票例子，如果使用的是继承Thread方式来写的话就必须是private static int ticket = 100;

问题一：为什么继承Thread类的多线程要加static？

1.使用继承Thread类的方式实现多线程，在使用时肯定是要实例化多个Thread类的，而且执行代码写了在Thread类的run方法中，所以就相当于多个线程的是单独的，所以我要加static关键字才能使其资源共享；

2.使用实现Runnable接口的方式实现多线程，只需要实例化一个Thread类就可以，而执行代码是在Runnable的run方法中；我在使用时，是把多个继承Runnable方法的run()都塞到一个Thread实例中，所以资源共享；

问题二：为什么把实现Runnable接口的实现类传入Thread()，就能通过start()方法调用？

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

    private Runnable target;


    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

上面是Thread类的部分源码，意思是如果有实现Runnable接口的类且实例化了对象，那么target就不是空的，就会执行target.run（）方法，而 target.run（）方法就是我们实现Runnable接口的类重写的run方法；

方式三：实现Callable接口

步骤：

  1. 创建一个实现Callable的实现类，需要执行的操作放在类中
  2. 创建实现了Callable接口的实现类对象，
  3. 实例化FutureTask类的对象，把 2 的对象作为参数给 3
  4. 把 3 作为参数传递给 new Thread()
  5. 调用start()
  6. 可通过get()方法获取第二步中返回值
public class testcall implements Callable<Boolean> {
    private String url; //网络图片的地址
    private String name;    //不好村的文件名
    public testcall(String url,String name){
        this.url=url;
        this.name=name;
    }

    @Override
    public Boolean call() throws IOException {
        //实现方法
        WebDownload webDownload = new WebDownload();
        webDownload.DownLoad(url,name);
        System.out.println("下载了名为："+name+"的文件");
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        testcall ti = new testcall("url","1.png");
        testcall t2 = new testcall("url","2.png");
        testcall t3 = new testcall("url","3.png");

        //创建执行服务
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> ri = executorService.submit(ti);
        Future<Boolean> r2 = executorService.submit(ti);
        Future<Boolean> r3 = executorService.submit(ti);
        //获取结果
        boolean res1 = ri.get();
        boolean res2 = ri.get();
        boolean res3 = ri.get();
        //关闭服务
        executorService.shutdown();
    }
}


//下载图片的类与方法
class WebDownload{
    public void DownLoad(String url,String name) throws IOException {
        FileUtils.copyURLToFile(new URL(url),new File(name));
    }

class NumThread implements Callable{
    @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) {
        NumThread numThread = new NumThread();
        FutureTask futureTask = new FutureTask(numThread);
        new Thread(futureTask).start();
        try {
            //get()返回值即为futureTask构造器参数Callable实现类重写的call()返回值
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

这个方式可以的好处是：1.可以提供返回值；2.支持泛型；3.可以抛出异常从而被外面的类所捕获；

方式四：使用线程池的方式

步骤：

  1. 提供指定线程数的线程池
  2. （可以提供一下特定的设置）
  3. 执行指定的线程操作
  4. 关闭线程池
class NmThread implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <=100 ; i++) {
            System.out.println(i);
        }
    }
}

public class MyThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //设置属性
        ThreadPoolExecutor executorService1 = (ThreadPoolExecutor) executorService;

        //2.执行指定的线程操作
        executorService.execute(new NmThread()); //适合使用Runnable
        //executorService.submit(); //适合使用Callable
        //3.关闭线程池
        executorService.shutdown();
    }
}

好处：

  1. 提高响应速度（减少了创建新线程的时间）
  2. 降低了资源的消耗，（重复利用线程池中的线程，不需要每次都创建，便于集中管理）

 常用的参数配置：

Executors工具类，线程池的工厂类，用于创建并返回不同类型的线程池
Executors.newCachedThreadPool()创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n)创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n)创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行
  1. corePoolSize：核心线程数
  2. queueCapacity：任务队列容量（阻塞队列）
  3. maxPoolSize：最大线程数
  4. keepAliveTime：线程空闲时间
  5. allowCoreThreadTimeout：允许核心线程超时
  6. rejectedExecutionHandler：任务拒绝处理器

三、线程的生命周期

五种状态：

  • 新建：一个Thread类或者子类被实例化时，就会处于新建状态；
  • 就绪：当被调用了start()方法后并不是直接就会运行，而是处于就绪状态，等待CPU分配；
  • 运行：获得CPU分配的资源后开始运行；
  • 阻塞：在一些特殊情况下，线程会让出自己的执行权，停止自己的运行状态从而进入阻塞状态；
  • 死亡：完成工作或者调用了stop()等方法；

四、线程的同步

在多个线程操作共同资源的时候会发生线程的安全问题，出现的原因是，当A线程在操作一个资源的时候，B线程随后也来操作了这个资源，这样的话就会导致线程安全问题；在实际情况中应该是看到有人在使用一个资源，那我就去使用别的资源，但是程序是死的，所以就会有这样的问题；那么解决的办法就是使用线程同步；

三种线程同步方式

1.同步代码块

 private static int ticket=100;
    private static Object obj = new String();
    @Override
    public void run() {
        while (true){
            synchronized (obj){
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName() + "卖了第：" + ticket + "张票");
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }

在有操作共同资源的代码段上用 synchronized 包裹起来， 里面在参数是同步监视器，且多个线程只能共用一个，也就是锁；

同步监视器：锁（获得执行权的线程获得锁，任何一个对象都可以充当锁，当时要求多个线程要共用一把锁）

相当于武林盟主的令牌，谁有这个令牌谁就有执行的权力；

2.同步方法

class WindowsFall implements Runnable{
    private  int ticket = 100;
    @Override
    public void run() {
        while (ticket>0){
            maipiao();
        }
    }

    private synchronized void  mp(){
        if (ticket>0){
            System.out.println(Thread.currentThread().getName() + "卖了第" + ticket + "张票");
            ticket--;
        }
    }
}

在有操作共同资源的代码段中抽离出来作为一个方法，同时加上 synchronized 关键字； 

 3.使用锁

class Windows implements Runnable{
    private int ticket =100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            //调用lock方法
            lock.lock();
           try{
               if(ticket>0){
                   System.out.println(Thread.currentThread().getName() + "卖了第：" + ticket + "张票");
                   ticket--;
               }else {
                   break;
               }
           }finally {
               //3.解锁
               lock.unlock();
           }
        }
    }
}

总结：

synchronized 与 Lcok 都是用来解决线程安全问题的方式；

synchronized机制在执行完相应的同步代码后，自动的释放同步监视器 lock需要手动的启动同步lock()，同时结束时也需要手动的实现unlock()

使用顺序：lock   同步代码块   同步方法

五、线程的通信

线程通信

基本使用

    @Override
    public void run() {
        while (true){
            synchronized (this){
                //唤醒所以阻塞在状态
                notifyAll();
                if (numable<100){
                    System.out.println(Thread.currentThread().getName() + ":" + numable);
                    numable++;
                    try {
                        //进入阻塞状态
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }else{
                    break;
                }
            }
        }
    }

 A线程进来-->notifyAll()唤醒其他线程，但是A线程进来的时候就拿到锁了，所以 其他线程是就绪状态，等到A线程wait()进入阻塞时会释放锁，然后其他线程中的一个线程拿到锁 如此循环

  1. wait()执行此方法进入阻塞状态，释放同步监视器
  2. notify()，执行此方法，唤醒一个wait()的线程，如果有多个就唤醒优先级高的
  3. notifyall()，唤醒所以的线程；

说明:

  1. 这个三个方法必须在同步代码块中 调用者必须是同步代码块或者同步方法中的同步监视器，否则出现异常
  2. 这三个方法是在Object类中的；

sleep 与 wait()的异同

相同：

执行了的话，都可以使用当前线程进入阻塞状态

不同：

  • 声明的位置不同，Thread类中的sleep()，Object()中的wait()
  • 调用要求不同，sleep()可以在任何需要的场景下使用，而wait()必须使用在同步代码块中
  • 关于是否释放同步监视器，如果两个方法都使用在同步代码块或者同步方法中，sleep（）不会释放同步监视器，而wait()会释放

死锁问题 

死锁是什么？

多个线程各自占有一些共享资源，并且互相等待其他线程占用的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止的情形，某一个同步块同时拥有”两个以上对象的锁“时就可能会发生“死锁”的问题。

死锁避免方法

产生死锁的四个必要条件：

  • 互斥条件：一个资源每次只能被一个进程使用。

  • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

  • 不剥夺条件：进程已获得资源，在未使用完之前，不能强行剥夺。

  • 循环等待条件：若干进程之间形成一种头尾相连的循环等待资源关系。

以上条件我们只需要破解其中任意一个或者多个条件就能避免死锁的发生。

解决方式一是使用同步代码块时里面不能包含其他的同步代码块（也就是说不能独占其他线程所需资源的锁）

public static void main(String[] args) {
        StringBuilder s1 = new StringBuilder();
        StringBuilder s2 = new StringBuilder();

        new Thread(){
            @Override
            public void run() {
                synchronized (s1){
                    s1.append('a');
                    s2.append(1);

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

                    synchronized (s2){
                        s1.append('b');
                        s2.append(2);
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
                    s1.append('c');
                    s2.append(3);

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s1){
                        s1.append('d');
                        s2.append(4);
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }

这里是会发生死锁的，因为第一个线程执行后一直拿着 "S2" 这个锁，而第二个线程执行后一直拿着 "S1"这个锁，也就是说都互相拿着对方的锁不放；所以就是一直僵持着；那么这个例子的解决办法就是把包含在同步代码块的同步代码块移出来，让两个同步代码块同级别；

六、守护线程

  • 线程分为用户线程和守护线程

  • 虚拟机必须确保用户线程执行完毕

  • 虚拟机不用等待守护线程执行完毕

  • 如：后台记录操作日志，监控内存，垃圾回收等待...

守护线程就是当你有一条A线程在运行，另一条线程B会一直陪着A线程运行，知道A线程处于死亡状态后B线程才停止，这就是守护线程

package xiangThread;

//测试守护线程
public class TestDaemon {
    public static void main(String[] args) {
        YongHu yh = new YongHu();
        God god = new God();

        Thread thread = new Thread(god);
        thread.setDaemon(true); //默认flase表示用户线程，正常线程都是用户线程
        thread.start();

        new Thread(yh).start();
    }
}

//你（用户线程）
class YongHu implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 36500; i++) {
            if (i>=36500){
                System.out.println("你离开了这个世界！");
            }
            System.out.println("这是第---"+i+"天");
        }
    }
}

//上帝（守护线程）
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝一直守护着你");
        }
    }
}

HQJLforever
关注
多线程的使用
小yu别错过的博客
08-18 614
本文主要浅Java基础中的多线程提示：以下是本篇文章正文内容，下面案例可供参考> 独立运行的应用程序叫进程​ 什么是应用程序，就是咱们打开各个软件，比如 谷歌浏览器，360，qq音乐等这些软件，他们都是独立的一个运行起来的软件，叫应用应用程序，​ 代码里面写过Demo1 Demo2这些类，也可以叫一个应用程序，也可以叫进程​ 进程需要通过系统的分配，获取系统中的cpu，内存，显卡，网络等。​ 独立性 ：qq和谷歌浏览器没有关系的，他们之间是独立的。
多线程的原理、实践、应用
0bug0warning的博客
10-28 1408
1 多线程的介绍 1.1 操作系统的演进过程 批处理操作系统(单道和多道)： 计算机能够自动地、成批地处理一个或多个用户的作业。不过单道批处理系统在进行I/O操作的时候，CPU资源是没有被利用的，为了能够更高效的利用cpu资源，多道批处理系统诞生了。 单道批处理操作系统工作图示： 多道(两道)批处理操作系统工作图示： 分时操作系统 批处理系统对于用户需要的计算机系统来说缺少交互性，工作之间的独立性。以及能在预期时间内完成用户需要的任务。分时操作系统产生了，它支持多用户交互式操作系...
JavaSe学习笔记09（线程）
weixin_42845320的博客
12-04 692
JavaSe学习笔记 day05Thread中的常用方法创建线程的方式方式一：Thread创建多线程的方式二：实现Runnable接口创建线程的方式三：实现Callable接口。 --- JDK 5.0新增创建线程的方式四：使用线程池线程安全问题关于售票问题的思考同步机制，解决线程安全死锁线程通信 Thread中的常用方法 start():启动当前线程；调用当前线程的run() run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中 currentThread():静态
多线程使用
qq_41482600的博客
08-02 1365
多线程方法
项目中多线程的多种使用方式
weixin_44942286的博客
11-29 1855
Override// 配置核心线程池数量// 配置最大线程池数量/// 线程池所使用的缓冲队列// 等待时间 （默认为0，此时立即停止），并没等待xx秒后强制停止// 空闲线程存活时间// 等待任务在关机时完成--表明等待所有线程执行完// 线程池名称前缀// 线程池拒绝策略：调用者执行// 线程池初始化logger.info("线程池初始化......");
Java 多线程基本使用
xiangxiongfly
05-31 669
文章目录Java 多线程基本使用进程与线程区别多线程的创建继承Thread类实现Runnable接口实现Callable接口run()与start()的区别基本使用currentThread()join()sleep()yieldwait() & notify & notifyAll()wait与sleep区别守护线程优雅中断线程interrupt()自定义变量线程同步问题不加锁synchronizedvolatileLock线程安全的集合Collectionsjava.util.concu
多线程基本使用
qq_44926774的博客
08-27 792
多线程基本使用 创建一个线程 1.继承Thread类，Thead类实现了Runnable接口 2.实现Runnable接口 二者需要重写run（）方法，编写在线程中运行的业务逻辑，该方法没有入参和返回值。 public abstract void run() 启动线程 1.如果是通过继承Thread类创建的线程，直接调用Thead类的start（）方法进行启动 2.如果是实现Runnable接口，需要通过构造函数创建线程，再调用start（）方法进行启动 public synchronized void
C++多线程基本使用方式
ANEW1001的博客
07-26 2313
关于C++多线程的基本使用方式
多线程基本概念和使用
qq_43774853的博客
05-24 354
多线程 在我们一般而言的多线程，其实是继续单核Cpu的。也就是说，其实没有真正的***并发*** 。多线程，其实是线程交替占用cpu。 也就是宏观并发，微观串行的。打个比方：5个人站一排同时投篮，我们看着，他们是并发投篮的，但是把速度放慢，就可以看到，其实投篮还是有先后顺序的。 main方法 main方法，其实就是我们的主线程，也就是线程的入口，其他的线程都要路过他，如果main挂了其他线程也就跟到挂了。如果在main方法中，输入下面的代码，就可以输出main线程的名字（main）: //拿到当前线
C#多线程基本使用和探讨
dawfwafaew的博客
10-08 1369
线程池是一种高效的并发处理方式，适合于大多数轻量级的后台任务。在现代 C# 编程中，建议使用Task和进行异步操作，因为它们能简化代码，并且使用底层的线程池来管理线程。如果需要精确控制线程的执行，通常建议使用手动管理的Thread等。
多线程之基本使用
weixin_49214500的博客
09-08 1447
多线程的基本使用
【常见协议与服务】HTTP1.1、HTTP2、HTTP3：性能到底差在哪
最新发布
feizuiku0116的博客
11-27 1425
摘要： HTTP协议的演进（HTTP/1.1→HTTP/2→HTTP/3）本质是解决性能瓶颈的过程。HTTP/1.1存在串行请求、队头阻塞等问题；HTTP/2通过多路复用、二进制帧和头部压缩显著提升性能；HTTP/3基于QUIC协议改用UDP传输，实现0-RTT握手和彻底消除队头阻塞。实验显示，HTTP/3在高延迟环境中优势明显。实际开发中需注意：HTTP/2下无需过度合并资源，高延迟业务应优先升级HTTP/3。性能优化的核心在于减少RTT延迟而非单纯增加带宽。（149字）
怎么使用多线程？
小草香香的博客
05-29 3706
实现多线程的方式有很多种，今天我们就来说下目前最好用的多线程的实现方式，使用ExecutorService。为什么说它好用，是因为new Thread的弊端有很多。下面有张表格可以对比下： new Thread的弊端 ExecutorService a:每次new Thread新建对象性能差； a：可以重用存在的线程，减少对象创建、消亡的开销，性能佳 b:线程缺乏统一管理，...
多线程--项目中哪些地方用到了多线程
zx733988的博客
03-04 2641
场景原理技术实现异步任务处理通过多线程异步执行任务，避免阻塞主线程。@Async批量数据处理将数据分片，利用多线程并行处理。定时任务定时执行任务，如数据清理、缓存刷新。@Scheduled高并发请求处理使用线程池处理高并发请求，提高系统吞吐量。、消息队列并行计算利用多线程并行处理计算密集型任务。Stream API。
多线程的运用
weixin_47260194的博客
06-13 831
多线程是一种并发编程的方式，它允许程序在同一时间执行多个线程。线程是程序执行的最小单位，多个线程可以共享进程的资源（如内存、文件句柄等），但每个线程有自己的程序计数器、堆栈和局部变量。多线程的主要目的是提高程序的效率和响应速度。例如，在一个GUI应用程序中，如果你使用单线程来处理所有任务，界面可能会在执行耗时操作时被冻结。而使用多线程可以在执行耗时操作的同时保持界面的响应。多线程编程是Java开发中的一项重要技能，通过合理使用多线程，我们可以显著提升应用程序的性能和用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值