JAVA中的多线程技术

最新推荐文章于 2022-07-10 09:44:19 发布
最新推荐文章于 2022-07-10 09:44:19 发布
阅读量147 收藏
点赞数
文章标签： java 多线程 线程池 线程安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/supreme_up/article/details/113055687
版权

文章目录

前言

多线程是JAVA中很重要的一个技术，最近在学习多线程，谨以此博客作为学习笔记，也算做一个分享，如果文中有看不懂的东西，文末会对一些概念进行解释。

提示：以下是本篇文章正文内容，下面案例可供参考

一、什么是多线程？

提到线程，就不得不提到进程的概念；
进程是计算机系统进行资源分配和调度的基本单位，通俗点来说，一个进程就是一个应用程序，可以将一个进程比喻成一个公司；
线程是进程中的一条执行路径，对应于公司中的“打工人”；
进程是线程的容器。每个进程都有一块独立的内存空间，而线程作为进程的进一步划分，则是多个线程共用同一块内存空间。多个线程之间可以随意切换，并发执行。当公司有了任务时，就会分配给这些打工人（线程），由他们分别完成，进而完成公司的总任务；
一个进程中，最少有一个线程在执行，否则进程也将消亡，没有员工的公司，应该不能称之为公司吧。

二、线程的调度

线程的调度方式分为分时调度和抢占式调度，JAVA中使用的是抢占式调度。

1.分时调度

分时调度又称为轮转调度。实际上，进程也有调度方式，但不是本节的重点，当进程取得CPU的使用权后，给定一个时间片，每个线程一次只能执行一个时间片的时间，称之为分时调度，分时调度的好处是每个线程都会执行相同的时间，某种意义上讲，算是公平的。

2.抢占式调度

抢占式调度是根据某种算法，给每个线程一个优先级，每当上一个线程执行完，或还未执行完时（具体情况要看获取优先级的是何种算法），就执行当前优先级最高的线程。

三、线程的创建

线程的创建有三种方式，下面逐个进行介绍。

1.通过声明为Thread的子类并重写run()方法的方式来创建一个新线程，代码如下：

public class Demo1 {
    public static void main(String[] args) {
        // 实例化MyThread类
        MyThread myThread  = new MyThread();
        // 启动这个线程
        myThread.start();
    }

    static class MyThread extends Thread{
        @Override
        public void run() {
            // 这里是本线程要执行的任务
            System.out.println("通过声明为Thread的子类的方式创建线程");
        }
    }
}

2.通过实现Runnable接口并实现run()方法的方式来创建新线程，代码如下：

public class Demo2
{
    public static void main(String[] args) {
        // 实例化一个MyRunnable对象
        MyRunnable myRunnable = new MyRunnable();
        // 创建一个线程并传入线程需要执行的任务
        Thread thread = new Thread(myRunnable);
        // 启动新线程thread
        thread.start();
    }

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            // 这里是线程需要执行的任务
            System.out.println("通过实现Runnable接口的方法创建一个线程");
        }
    }
}

3.通过实现Callable接口并重写call()方法的方式来创建一个新线程，代码如下：

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

public class Demo3 {
    public static void main(String[] args) {
        // 实例化MyCallable对象
        MyCallable myCallable = new MyCallable();
        // 创建FutureTask对象，并传入MyCallable对象
        FutureTask<String> task = new FutureTask<>(myCallable);
        // 创建一个线程并传入task来启动线程
        Thread thread = new Thread(task);
        // 启动线程
        thread.start();
        // MyCallable会返回一个字符串，可以通过task来获取
        /* 这里可能出现异常的原因是task的get()方法会等待MyCallable中必要计算的完成
           ，在等待过程中可能会出现计算被取消、等待被中断或计算发生异常等原因导致出现异常
         */
        try {
            System.out.println(task.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    static class MyCallable implements Callable<String>{

        @Override
        public String call() throws Exception {
            // 这里是线程需要执行的任务
            System.out.println("通过实现Callable接口的方式创建要给新线程");
            return "创建成功";
        }
    }
}

ps: 需要注意的是，这种方法虽然能返回执行结果，但在获取执行结果的时候，即在调用FutureTask.get()方法时，会阻塞主进程。

四、线程安全问题

多线程在带来高效率的同时，也有带来了一些问题。例如：线程在调度时，是按照抢占的方式来获取时间片的，这就导致一个线程在验证某些条件后，还未执行其他部分，就可能被另一个线程抢到了时间片，而这个线程则修改了这些条件，当那个线程再次抢到时间片的时候，并不对条件进行再次验证便执行了其他操作，这就导致了错误。

用个实例来说：桌上有一本书，两个人都要去拿，第一个人看了一眼，桌上是有书的，便伸手去拿，而第二个人在此同时，也看了一眼，书还在，也伸手去拿，而且速度很快，直接拿到了书。此时，桌上已经空了，而第一个人并没有再去检查桌上有没有书，依然伸手去拿，当然拿不到了。这就出现了异常。

解决线程安全的问题也很简单，那就是让他们互斥访问，即给桌子盖个盖子，只留一个口，这样，第一个人手进去时，口子就被挡住了，第二个人就无法伸手，这样一来，线程安全问题就解决了，这个盖子，其实就是一把“锁”。

1.同步代码块

同步代码块的方式就是给需要上锁的那部分代码“上锁”，让调用它的线程互斥访问，或者说排队访问。

public class Demo4 {
    public static void main(String[] args) {
        // 实例化任务
        MyThread myThread  = new MyThread();
        // 创建并启动多个线程，观察是否是互斥访问的
        new Thread(myThread).start();
        new Thread(myThread).start();
        new Thread(myThread).start();
    }

    static class MyThread implements Runnable{
        int num = 2;
        private Object o = new Object();
        @Override
        public void run() {
            // 给部分代码上锁
            /*synchronized(o){
                if (num>0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "值为：" + --num);
                }
            }*/
            if (num>0) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "值为：" + --num);
            }
        }
    }
}

上锁前
上锁前
上锁后
在这里插入图片描述
可以发现，上锁后，不会再发生num值为负数的情况了，即线程是安全的。

2.同步方法

其实同步方法和同步代码块是差不多的，只不过同步代码块是只锁部分代码，而同步方法是将整个方法上锁。

public class Demo5 {
    public static void main(String[] args) {
        // 实例化任务
        MyThread myThread  = new MyThread();
        // 创建并启动多个线程，观察是否是互斥访问的
        new Thread(myThread).start();
        new Thread(myThread).start();
        new Thread(myThread).start();
    }

    static class MyThread implements Runnable{
        int num = 6;
        @Override
        public void run() {
            while(true) {
                if (get()<0) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "：" + num);
            }


        }

        // 给方法get上锁
        public synchronized int get() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            --num;
            return num;
        }
    }
}

上锁前
在这里插入图片描述
上锁后
在这里插入图片描述
可以看到，也没有出现负数，证明线程安全

3.显式锁Lock

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

public class Demo6 {
    public static void main(String[] args) {
        // 实例化任务
        MyThread myThread  = new MyThread();
        // 创建并启动多个线程，观察是否是互斥访问的
        new Thread(myThread).start();
        new Thread(myThread).start();
        new Thread(myThread).start();
    }

    static class MyThread implements Runnable{
        int num = 4;
        // 创建锁对象
        Lock lock  = new ReentrantLock();
        @Override
        public void run() {
            while (true) {
                // 延迟一秒后再检测锁状态，便于体现出是多个线程在运行
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 检查锁状态，如果没锁，则将之上锁，执行下面带码；反之，则阻塞
                lock.lock();
                try {
                    if (num<=0) {
                        break;
                    }
                    System.out.println(Thread.currentThread().getName() + "：" + --num);
                    // 延迟两秒后再释放锁，增大出现异常的概率
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }finally {
                    // 释放锁
                    lock.unlock();
                }
            }
        }
    }
}

上锁前
在这里插入图片描述
上锁后
在这里插入图片描述
可以看到，上锁后是线程安全的。

既然第三种方法提出了显式锁的概念，那就再赘述一下：同步代码块和同步方法都属于隐式锁，是jvm层面上的锁，而Lock是调用API，由程序员手动上锁和释放锁。

锁又分为公平锁和非公平锁，公平是指当锁释放后，下一个执行的线程是由被阻塞后线程的排队情况决定的；而非公平是指锁释放后，依然是抢占方式，谁抢到，谁就执行。前两种方式都是非公平锁，Lock是可选择的，默认是非公平锁，如果在创建锁对象时指定了锁为公平锁，那这个锁就变成了公平锁。

// 指定锁为公平锁
Lock lock  = new ReentrantLock(true);

五、线程死锁

线程死锁的出现其实时需要特殊条件的，即几个线程之间有一条循环等待链。
假如有两个线程a和b，a线程需要b线程执行的结果，而b线程需要a线程的执行结果，a在等待b执行结束返回结果，而b也在等待a执行结束返回结果，b没有得到a返回的结果就不会结束并返回结果给a，a得不到b返回的结果就不会结束并返回结果给b，这样就陷入了一个死循环，称之为死锁。
在这里插入图片描述

六、线程间的通信

线程间的通信并不是线程间能够传递值，而是一个线程告诉其他线程“我”执行结束了。
线程间的通信时通过等待操作wait()和notify()或notifiAll()来实现的。

使线程等待：

Thread thread = new Thread(myThread);
        thread.start();
        try {
            // 使线程等待
            thread.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

唤醒线程：

Thread thread = new Thread(myThread);
        thread.start();
        try {
        	// 使线程等待
            thread.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 唤醒线程
        thread.notify();

七、进程的六种状态

NEW
尚未启动的线程处于此状态。
RUNNABLE
在Java虚拟机中执行的线程处于此状态。
BLOCKED
被阻塞等待监视器锁定的线程处于此状态。
WAITING
无限期等待另一个线程执行特定操作的线程处于此状态。
TIMED_WAITING
正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。
TERMINATED
已退出的线程处于此状态。

八、线程池

1.概述

一个线程，从创建到运行结束再到销毁所消耗的时间，在很多时候，这些时间大部分都消耗在了创建和销毁上，而我们最关注的执行部分却可能只消耗了一小部分时间。但在某些时候，我们不得不频繁的使用多线程，但每次执行的任务却很小，这就会造成资源的浪费，所以出现了线程池的概念。
线程池就是存储线程的容器，线程池中的线程是可以重复使用的，当需要执行任务时，就将任务分配给一个线程，这样一来，就省去了频繁创建新线程所消耗的时间。

2.JAVA中的四种线程池

(1) 缓存线程池

缓存线程池会在添加任务时检测是否有空闲线程，如果有，则给空闲线程分配任务；如果没有，则创建一个新线程放到线程池中并处理这个任务

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

public class Demo7 {
    public static void main(String[] args) {
        // 创建缓存线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        // 添加任务到线程池中
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });

        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });

        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
    }
}

这里我添加了三个任务进去，可以看到，三个任务是由三个线程来处理的，即没有空闲线程时会新创建线程来处理任务。
在这里插入图片描述

（2）定长线程池

定长线程池是指线程池里面的线程最大数量是固定的；
如果没有空闲线程，但是线程池未满，而又有任务时，会创建线程添加到线程池，然后处理这个任务；
如果没有空闲线程，线程池也满了的情况下有了新任务，则会进入等待状态，直到有空闲线程。

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

public class Demo8 {
    public static void main(String[] args) {
        // 创建定长线程池，长度未为2
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        // 添加三个任务到线程池
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });

        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });

        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
    }
}

可以看到，三个任务，只由两个线程处理，并没有创建出第三个新线程
在这里插入图片描述
（3）单线程线程池

单线程线程池效果和定长线程池限定线程池长度为1时一样，如果添加任务时没有空闲线程则等待，直到线程池中的线程空闲。

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

public class Demo9 {
    public static void main(String[] args) {
        // 创建单线程线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        // 添加三个任务到线程池中
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });

        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });

        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
    }
}

可以看到，三个任务都由一个线程处理。
在这里插入图片描述
（4）周期性任务定长线程池

周期性任务定长线程池和定长线程池相似，都是线程最大数量被限制，但周期性任务定长线程池会在一定时间延迟后执行，并会在每隔一段时间便执行一次。

参数介绍:
command：Runnable类型的任务
initialDelay：延迟多长时间后触发（即开始执行），单位和后面的一样period：执行间隔
unit：前面两个延迟时间的单位

import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo10 {
    public static void main(String[] args) {
        // 创建周期性任务定长线程池
        ScheduledExecutorService service = new ScheduledThreadPoolExecutor(2);
        // 添加任务到线程池
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+ "：周期执行任务1");
            }
        }, 3, 2,TimeUnit.SECONDS);

        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+ "：周期执行任务2");
            }
        }, 3, 2,TimeUnit.SECONDS);

        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+ "：周期执行任务3");
            }
        }, 3, 2,TimeUnit.SECONDS);
    }
}

在这里插入图片描述
可以看到，这三个任务是周期执行的，且只有两个线程在处理任务。

九、杂谈一些概念或操作

1.线程休眠

在某些时候，我们需要“故意”消耗一些时间，这时候就可以通过Thread类的静态方法sleep来实现，如：

				try {
					// sleep()方法中的参数为休眠时间，单位为毫秒
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

2.线程中断

有时候我们需要在线程还未执行完时将线程提前结束，这时可以采用给线程打上中断标记的方法，告知线程需要提前结束，线程会在某些情况下检查自身是否被打上了中断标记，如休眠和等待时。如果发现了被打上了中断标记，则抛出中断异常，程序员可以捕获，然后进行结束操作。例如：

public class Demo2{
    public static void main(String[] args) {
        // 实例化一个MyRunnable对象
        MyRunnable myRunnable = new MyRunnable();
        // 创建一个线程并传入线程需要执行的任务
        Thread thread = new Thread(myRunnable);
        // 启动新线程thread
        thread.start();
        // 打上中断标记
        thread.interrupt();
    }

    static class MyRunnable implements Runnable{

        @Override
        public void run() {
            // 这里是线程需要执行的任务
            System.out.println("通过实现Runnable接口的方法创建一个线程");
            // 让进程休眠一秒并捕获异常
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // 当线程抛出中断异常并被我们捕获后，可以在这里执行结束操作
                e.printStackTrace();
            }
        }
    }
}

3.守护线程

线程分为守护线程和用户线程，除守护线程外的所有线程都是用户线程。守护线程依赖于用户线程存在，即进程中如果所有的用户线程都销毁了，那么所有的守护线程也会销毁。

如下操作可将一个线程设置为守护线程：

		// setDaemon()方法中的boolean类型的参数意义是是否设置为守护线程，如果是true，则将这个线程设置为守护线程
        thread.setDaemon(true);

总结

目前所学到的有关多线程的知识就这么多，后续如果有更深入的理解的话再进行补充。

Supreme_up
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java多线程技术（全）
SnakeMonster
09-28 201
多线程知识多线程技术概述1.线程与进程2.线程调度3.同步与异步4.并发与并行*一、继承Thread二、Runnable三、 Thread类 常用的方法四、设置和获取线程名称五、线程休眠sleep六、线程阻塞七、线程的中断八、守护线程setDaemon(true)九、线程不安全问题十、线程安全1-同步代码块十一、线程安全2-同步方法十二、线程安全3-显示锁Lock十三、公平锁与非公平锁十四、线程死锁十五、多线程通信问题十六、线程的六种状态十七、Callable 是java中第三种线程实现的方法十八、L
java多线程
liuzhe_2008的专栏
10-25 599
线程编程一直是学员们比较头痛和心虚的地方，因为线程执行顺序的不可预知性和调试时候的困难，让不少人在面对多线程的情况下选择了逃避，采用单线程的方式，其实只要我们对线程有了明确的认识，再加上java内置的对多线程的天然支持，多线程编程不再是一道难以逾越的鸿沟。 进程、线程、并发执行 首先我们先来认识一下进程、线程、并发执行的概念： 　 一般来说，当运行一个应用程序的时候，就启动了一个进程，当然有
Java中多线程技术
晓风残月xj
11-01 1232
最近由于工作的原因开始决定系统学习一下Java的多线程机制。Java语言的一大特点就是内在支持多线程，这和很多语言需要通过外部开发包来实现多线程有本质区别。每个程序都有一个主线程，当程序启动时自动执行。关于多线程的一些概念性东西，见这篇博文：多线程初步。
Java之多线程技术
qq_64131064的博客
07-10 314
进程（Process）和线程（Thread）是现代操作系统不可避免的运行模型。操作系统可以运行多个线程，而每个进程又可以创建一个或多个线程。这里注意，每个进程内至少有一个主线程（main）和gc进程（垃圾处理）。线程是多个同时进行的。线程类Thread是在java.lang包中定义的，这里需要注意两点， （1）编写并指定线程需要执行的方法 （2）启动线程线程类Thread包含了实现上述功能的两个方法， （1）run（）：包含线程运行时所执行的代码 （2）start（）：用于启动线程用户的线程类必须基础Thr
Java自学基础 多线程
real_rookie的博客
11-05 899
Java多线程前言一、基本概念：程序、进程、线程使用多线程的优点何时需要多线程二、线程的创建和使用线程的创建和启动Thread类API中创建线程的两种方式继承方式和实现方式的联系与区别Thread类的有关方法线程的优先级三、线程的生命周期四、线程的同步Synchronized的使用方法同步机制中的锁同步的范围释放锁的操作不会释放锁的操作单例设计模式之懒汉式(线程安全)线程的死锁问题Lock(锁)synchronized 与 Lock 的对比总结 前言 一、基本概念：程序、进程、线程 程序(progra
Java中的多线程
GuessHat的博客
07-11 129
Java中的多线程 多线程的最主要的目的：是为了提高程序的执行效率（不是执行速度），提高CPU的利用率，如果两个方法之间不存在因果调用关系，那么可以考虑在一个方法执行时开辟另一个线程执行另一个方法，而不用等第一个方法执行完之后再执行第二个方法 计算机通常会有多个核心，一个核心在同一个时间点（很小的计量单位）只能有一个程序在运行。CPU会在高速的情况下，不断的进行切换。线程是一个进程内的独立的执行单元（一个进程至少包含一个线程）。 多线程的实现方案 创建新执行线程有两种方法。但最终都是使用start()方法来
JAVA中多线程技术的实现.pdf
10-26
以上知识点只是Java多线程技术中的一部分。实际上，实现多线程程序的编写和调试是相对复杂的，需要对线程生命周期、线程同步、线程通信等多个方面的知识有深刻的理解。由于Java语言的并发模型以线程为基础，因此掌握...
java使用多线程读取超大文件
08-25
Java使用多线程读取超大文件是指在java语言中使用多线程技术来读取超大文件，以提高读取速度和效率。下面是该技术的详细介绍和实现方法。 多线程读取超大文件的必要性 在读取超大文件时，使用单线程读取会出现读取...
利用Java多线程技术导入数据到Elasticsearch的方法步骤
08-25
通过上述内容，我们可以看到，将Java多线程技术应用于从MySQL到Elasticsearch的数据导入中，不仅可以提高数据导入的效率，还可以优化系统资源的使用。合理地设计和实现生产者-消费者模型、调整线程池的参数以及利用...
JAVA多线程编程技术PDF
08-28
这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点。 首先，多线程的核心概念包括线程的创建与启动。在Java中，可以通过实现Runnable接口或继承Thread类来创建线程。创建后...
Java多线程编程核心技术_完整版_java_
09-30
Java多线程编程是Java开发中的...以上内容只是《Java多线程编程核心技术》教程中的一部分核心知识点，实际学习中还需要结合具体示例和实践来深入理解和掌握。通过学习，开发者可以编写出高效、稳定的多线程Java程序。
Java 多线程技术
LeonZhang的博客
01-07 867
多线程 文章目录多线程1 概述1.1 线程与进程1.1.1 进程1.1.2 线程1.2 线程调度1.2.1 分时调度1.2.2 抢占式调度1.3 同步与异步1.4 并发与并行2 在Java中启用多线程2.1 继承Tread类2.2 实现Runnable接口2.3 继承Thread与实现Runnable对比2.4 实现Callable接口2.4.1 使用方式2.4.2 `Callable`获取返回值2.4.3 `Future`类的其它方法2.4.4 比较Callable与Runnable2.4.2.1 接口定
java多线程技术_Java多线程技术
weixin_30111277的博客
02-16 119
多线程编程一直是学员们比较头痛和心虚的地方，因为线程执行顺序的不可预知性和调试时候的困难，让不少人在面对多线程的情况下选择了逃避，采用单线程的方式，其实只要我们对线程有了明确的认识，再加上java内置的对多线程的天然支持，多线程编程不再是一道难以逾越的鸿沟。进程、线程、并发执行首先我们先来认识一下进程、线程、并发执行的概念：一般来说，当运行一个应用程序的时候，就启动了一个进程，当然有些会启动多个进...
java多线程技术体系
贾红平
05-28 2402
下图是JAVA多线程的CORE技术体系整合
Java多线程技术介绍
Cosmoshur的博客
08-06 262
首先，了解两个概念：进程与线程 进程就好比是在一块儿内存里运行的程序，这个程序拥有独立的栈和堆，而线程就是进程里的一条条执行路径，他们拥有各自的栈，共享进程里的堆。一个进程至少要包含一个线程。 在Java中，使用的线程调度方法为抢占式调度：就是字面意思，所有的线程去抢执行的机会，优先级高的线程抢到执行机会的概率就大，反之就小。 其次，还要知道并发和并行的概念：并发，就是两个及以上的事件（线程）在同一时间段内执行，并行则是这些事件（线程）在同一时间点执行。举个简单例子就是，你在一周内完成了一次长跑，做完
Java多线程技术
小Y在线编码
06-01 179
一、多线程技术 1、与多线程有关概念 进程：一个软件安装在硬盘上，运行在内存中。而负责运行这个软件的那个内存空间就是一个进程（主进程，子进程）。进程是用来管理当前正在运行的那个软件。 线程：它是软件中具体执行某个功能（代码）的独立空间，进程之间默认是不会影响的。 多线程：一个软件中，多个线程同时运行。 多线程运行机制： 为什么使用多线程：可以保证在一个软件中同时有多个功能在运行。提高软件运行效率。 单线程程序：软件中只有一个线程负责功能执行，只要这个功能没有结束，无法启动别的功能。 单核、
Java线程与多线程技术详解
总结，Java线程和多线程技术是Java开发中的重要组成部分，理解和掌握这些概念、特性和实践技巧对于编写高效、安全的并发程序至关重要。通过合理利用多线程，开发者可以构建出更加灵活、响应迅速的应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值