【Java SE】多线程

最新推荐文章于 2022-11-12 21:28:11 发布
最新推荐文章于 2022-11-12 21:28:11 发布
阅读量1.4k 收藏 2
点赞数 1
分类专栏： Java SE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42915286/article/details/89072084
版权

——————————————————————————————

笔记

————————————

  • 线程睡眠/阻塞：用TimeUnit.SECONDS.sleep()取代Thread.sleep()
import java.util.concurrent.TimeUnit;

try {
    //Thread.sleep(10*1000); 等价于
    TimeUnit.SECONDS.sleep(10);
} catch (InterruptedException e) {
    e.printStackTrace();
}

为什么说他好呢？因为他更灵活：
在这里插入图片描述

TimeUnit.SECONDS.sleep();
TimeUnit.MINUTES.sleep();
TimeUnit.HOURS.sleep();
TimeUnit.DAYS.sleep();

————————————
————————————
————————————
————————————
————————————
——————————————————————————————

通俗地说：
进程：比如IDEA或者QQ的运行，是程序（任务）的执行过程，持有资源（共享内存、共享文件）和线程；
（说明是动态性的，单个文件并不是进程，只有点击文件使程序运行后才发生进程）
（进程是资源、线程的载体，脱离了线程谈进程无意义）

线程：比如QQ中的“文字聊天”“收发文件”，所有这些人物都可以理解为线程；

线程的交互：互斥与同步；比方说进程是班级，线程是学生，学生沟通就是线程，学生之间有时需要合作（同步）才能达到目的，有时需要竞争（互斥）才能达到目的；

——————————————————————————————

  • 程序、进程、线程的区别是什么？分别举例说明 （初中级面试）

程序是进程的超集，进程是线程的超集；（一个程序可以有多个进程，一个进程可以有多个线程）

  • 程序 Program：是一个指令的集合。程序不能独立执行，只有被加载到内存中，系统为他分配资源后才能执行；
  • 进程 Process：如上，一个执行中的程序叫做进程；
    进程是系统分配资源的独立单位，每个进程在系统内顺序执行的特定地址；
    程序是进程的静态文本描述，进程是程序在系统内顺序执行的动态活动；
  • 线程 Thread：是进程的“单一的连续控制流程”；
    线程是CPU调度和分配的基本单位，是比进程更小的，能独立运行的基本单位，也被称作轻量级的进程；
    能独立运行，但不能独立存在；
    线程不能独立存在，必须依附于某个进程；一个进程可以包括多个并行的线程，一个线程肯定属于一个进程；
    Java允许并发执行多个线程；

例如：一个车间是一个程序，一个正在进行生产任务的车间是一个进程，车间内每个从事不同工作的工人是一个线程；

——————————————————————————————
Java对线程的支持体现在：
Thread类 和 Runnable接口 之上，他们都继承于java.lang包；
他们之间共通的方法是run()，此方法为我们提供了线程执行的代码；
在这里插入图片描述

  • Thread.activeCount() 返回活动线程的【当前线程】的线程组中的【数量】
    注意！若实际只运行了1个线程时，其他IDE中此方法返回的是1；
    但IDEA中使用此方法返回的是2，因为IDEA中多了个Monitor Ctrl-Break监控线程，使用IDEA时注特别注意！！！！！！！！

————————————————————————

多线程

提问：实现多线程的方式？

1.继承Thread类创建线程；
2.实现Runnable接口创建线程；
（答出1、2点就够了；下面是两种特殊的方式，不用死记硬背，不重要）
3.实现Callable接口，通过FutureTask包装器来创建Thread线程；（少用）
4.使用ExecutorService、Callable、Future实现由返回结果的线程；（线程池）（少用）

注：两者获取线程名称的方式有区别
Thread类用：getName()
Runnable接口用：Thread.currentThread().getName()

1.继承Thread类创建线程；
（写两个线程）

public class Test1 extends Thread{
    public void run(){
        System.out.println("Test1.run()");
    }

    public static void main(String[] args) {
        Test1 t1 = new Test1();
        Test1 t2 = new Test1();
        t1.start();
        t2.start();
    }
}
————————————
输出：
Test1.run()
Test1.run()

也可以简写：

public class Test1 extends Thread{
    public void run(){
        System.out.println("Test1.run()");
    }

    public static void main(String[] args) {
        new Test1().start();
        new Test1().start();
    }
}

2.实现Runnable接口创建线程；
（写两个线程）
易错点！！！要先实例化Test类，再把实例对象放在Thread的实例语句中，不要写反！！！

public class Test2 implements Runnable {
    public void run(){
        System.out.println("Test2.run()");
    }

    public static void main(String[] args) {
        Test2 t1 = new Test2();
        Test2 t2 = new Test2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();
    }
}
————————————
输出：
Test2.run()
Test2.run()

3.实现Callable接口，通过FutureTask包装器来创建Thread线程；

public class Test3<Object> implements Callable<Object> {

    public Object call(){
        System.out.println(Thread.currentThread().getName()+"————我是通过Callable接口通过FutureTask包装器来实现的线程。");
        return null;
    }
}

public class Test2 {
    // 通过Callable和FutureTask创建线程
    /*
    * a.创建Callable接口的实现类，并实现Call方法
    * b.创建Callable实现类的实现，使用FutureTask类包装Callable对象，该FutureTask对象封装了Callable对象的Call方法的返回值
    * c.使用FutureTask对象作为Thread对象的target创建并启动线程
    * d.调用FutureTask对象的get()来获取子线程执行结束后的返回值
    */

    public static void main(String[] args) {
        Callable<Object> oneCallable = new Test3<>();
        FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);
        Thread t = new Thread(oneTask);
        System.out.println(Thread.currentThread().getName());
        t.start();
    }
}
————————————
输出：
main
Thread-0————我是通过Callable接口通过FutureTask包装器来实现的线程。

4.使用ExecutorService、Callable、Future实现由返回结果的线程；（线程池）（少用）

public class Test4 {

    // 使用`ExecutorService`、`Callable`、`Future`实现由返回结果的线程（线程池）

    private static int POOL_NUM = 10; // 线程池数量

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for(int i = 0; i < POOL_NUM ; i++){
            RunnableThread thread = new RunnableThread();
            executorService.execute(thread);
        }
        executorService.shutdown();
    }
}

class RunnableThread implements  Runnable{

    @Override
    public void run() {
        System.out.println("通过线程池方法创建的线程： "+Thread.currentThread().getName());
    }
}
————————————
输出：
通过线程池方法创建的线程： pool-1-thread-1
通过线程池方法创建的线程： pool-1-thread-2
通过线程池方法创建的线程： pool-1-thread-3
通过线程池方法创建的线程： pool-1-thread-4
通过线程池方法创建的线程： pool-1-thread-5
通过线程池方法创建的线程： pool-1-thread-1
通过线程池方法创建的线程： pool-1-thread-2
通过线程池方法创建的线程： pool-1-thread-3
通过线程池方法创建的线程： pool-1-thread-4
通过线程池方法创建的线程： pool-1-thread-4

附：实际中常用方法：

new Thread(new Runnable(){
...
}).start();

new Thread(){...public void run()...}.start();

（本质上，实现多线程唯一的方式是实现Thread类的run()方法；）
——————————————————————————————

  • 两种Thread创建方法的区别？（extends Thread 和 implements Runnable）

extends Thread：
（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。
（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。（因为Java的单继承）

implements Runnable：
（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源（指同一个Runnable对象）的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

总结：

  1. Runnable方式可以避免Thread方式因为Java单继承特性带来的缺陷；
  2. Runnable代码可以被多个线程（Thread实例）共享，适合于多个线程处理同一资源的情况；
    （建议：多采用Runnable这种方式创建线程）

实现Runnable接口，只创建了一个类的实例，而且被多个线程共享了。因此Counter递增。而继承Thread类， 你必须为每一个线程创建不同的实例。因此每个类的实例分配了不同的内存空间，每一个有不同的Counter，它们的值相同。这意味着没有增加因为没有一个对象的引用是相同的。

什么时候用Runnable接口呢？
当你想要在一组线程中访问相同的资源时，使用Runnable接口。在这种情况下要避免使用Thread类，因为多对象的创建会占用更多的内存，会导致大的性能花费。

PS:Thread类内部实现了Runnable接口

最后，哪种方式最好用呢？
显而易见，当然是实现Runnable接口更好。
https://www.cnblogs.com/JohnTsai/p/3979482.html
———————————————
为了实践这些差别，下列模拟一个情境：
火车站有3个卖票窗口，他们一起售出3张火车票，然后输出查看这些窗口分别卖出几张票；
（注意！安全的买票程序中run方法需要加入同步 Synchronized！！！）
（注意！安全的买票程序中run方法需要加入同步 Synchronized！！！）
（注意！安全的买票程序中run方法需要加入同步 Synchronized！！！）
（注意！安全的买票程序中run方法需要加入同步 Synchronized！！！）
（注意！安全的买票程序中run方法需要加入同步 Synchronized！！！）
extends Thread因为单线程，所以写不写无所谓；

用Thread：

/*
* 情境：5张火车票，由3个售票窗口（3个线程）卖出
* extends Thread
*
* 卖票逻辑：当票数>0时，就可以一直卖下去；<0时则售罄
*/

class MyThread extends Thread{
    private int ticketCount = 5; // 5张火车票
    private String name; // 窗口名，即线程名

    public MyThread(String name){
        this.name = name;
    }

    @Override
    public void run() {
        while(ticketCount > 0){
                ticketCount -- ; // 若还有票，则卖掉一张
                System.out.println(name + " 卖了一张票，剩余票数为："+ticketCount);
        }
    }
}

// 考虑接下来的线程实例名 如何和之前定义的 String name 挂上钩？
// 因为MyThread类中定义了构造器，加入了参数String name；所以在Test1类中，要把name写进线程创建参数中

public class Test1{
    public static void main(String[] args) {
        MyThread mt1 = new MyThread("窗口1");
        MyThread mt2 = new MyThread("窗口2");
        MyThread mt3 = new MyThread("窗口3");
        mt1.start();
        mt2.start();
        mt3.start();
    }
}
———————————————
输出：
窗口3 卖了一张票，剩余票数为：4
窗口2 卖了一张票，剩余票数为：4
窗口1 卖了一张票，剩余票数为：4
窗口3 卖了一张票，剩余票数为：3
窗口1 卖了一张票，剩余票数为：3
窗口2 卖了一张票，剩余票数为：3
窗口1 卖了一张票，剩余票数为：2
窗口3 卖了一张票，剩余票数为：2
窗口2 卖了一张票，剩余票数为：2
窗口3 卖了一张票，剩余票数为：1
窗口1 卖了一张票，剩余票数为：1
窗口2 卖了一张票，剩余票数为：1
窗口3 卖了一张票，剩余票数为：0
窗口1 卖了一张票，剩余票数为：0
窗口2 卖了一张票，剩余票数为：0

居然卖出了15张票，很显然这不合理；

———————————————
用Runnable：

/*
 * 情境：5张火车票，由3个售票窗口（3个线程）卖出
 * implements Runnable
 *
 * 卖票逻辑：当票数>0时，就可以一直卖下去；<0时则售罄
 */

class MyThread2 implements Runnable{

    private int ticketCount = 5;

    // implements Runnable 不用定义String name，因为Thread类中有构造方法可以直接添加名字

    @Override
    public synchronized void run(){
        while(ticketCount > 0){
            ticketCount -- ;
            System.out.println(Thread.currentThread().getName() + "卖了一张票，余下票数为："+ ticketCount);
        }
    }
}

public class Test2 {

    public static void main(String[] args) {
        MyThread2 mt1 = new MyThread2();
        Thread t1 = new Thread(mt1,"窗口1");
        Thread t2 = new Thread(mt1,"窗口2");
        Thread t3 = new Thread(mt1,"窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
———————————————
输出：
窗口2卖了一张票，余下票数为：4
窗口3卖了一张票，余下票数为：3
窗口1卖了一张票，余下票数为：2
窗口3卖了一张票，余下票数为：0
窗口2卖了一张票，余下票数为：1

过程：
线程1启动，没有获得CPU使用权，于是等待；
线程2启动，获得了CPU使用权，于是进入run()运行；输出 窗口2卖了一张票，余下票数为：2
线程2把资源让出来了，线程3启动，获得了CPU使用权...

为什么顺序是：第四行剩下0，第五行剩下1？反过来了？
因为实际上第五行先执行，第四行后执行；
当第五行还没来得及输出时，就被第四行执行了并输出；

易错！！！
1.容易写成这样：

        Test2 t1 = new Test2("窗口1");
        Test2 t2 = new Test2("窗口2");
        Test2 t3 = new Test2("窗口3");

        Thread thd1 = new Thread(t1);
        Thread thd2 = new Thread(t2);
        Thread thd3 = new Thread(t3);

        thd1.start();
        thd2.start();
        thd3.start();

2.而且容易忘记：
implements Runnable 不用定义String name，因为Thread类中有构造方法可以直接添加名字；
3.编写XX卖出了几张票时，这个窗口名！！
要用Thread.getCurrentThread().getName()（而且！即使写了这个，也容易忘记写上getName）

结果是很随机的，哪个线程获得了CPU使用权，谁就可以卖出一张票；
但是这个结果是合理的，一共5张票；
———————————————
回到总结：
Runnable代码可以被多个线程（Thread实例）共享，适合于多个线程处理同一资源的情况；
验证的就是多个线程处理同一资源的情况：ticketCount是同一资源；
———————————————
分析：

Runnable中：
MyThread2是一个唯一的一个实现Runnable接口的对象，然后我们把他作为参数，传递给三个线程对象；
因此三个线程用的都是同一个Runnable对象中的代码，所以三线程共享了同个资源：ticketCount；

Thread中：
新建了三个线程，每个线程都有自己的ticketCount和name和run()（这些资源对于每个线程来说：是独立的，不是共享的）
因此三个线程各自卖了各自的五张票，共15张票；
———————————————
修改下代码？

把Runnable中：
唯一创建的Runnable对象，改成三个Runnable对象，且把这三个不同的参数传给三个不同线程，结果会不会也变成卖了15张票？（3个线程分别卖了5张票）？

public class Test2 {

    public static void main(String[] args) {
        MyThread2 mt1 = new MyThread2();
        MyThread2 mt2 = new MyThread2();
        MyThread2 mt3 = new MyThread2();
        Thread t1 = new Thread(mt1,"窗口1");
        Thread t2 = new Thread(mt2,"窗口2");
        Thread t3 = new Thread(mt3,"窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

果然结果如同预料，卖了15张；

——————————————————————————————

守护线程 Daemon Thread

Java线程有两类：用户线程 守护线程

  • 用户线程 User Thread：
    运行在【前台】（看得清、摸不到），【执行具体任务】；
    程序的主线程、连接网络的字线程等都是用户线程；

  • 守护线程 Daemon Thread： （顾名思义，某些线程的守护者）
    运行在【后台】，为【其他前台线程】服务；
    特点：
    一旦所有用户线程都结束运行，守护线程就会随着JVM一起结束工作（要守护的对象都消失了，他觉得自己没有存在的必要了）；
    应用：
    数据库连接池中的监控线程；JVM虚拟机启动后的监控线程；
    （如：监测连接池的线程个数，超时时间；监测虚拟机的使用情况、锁持有的情况）
    最常见的守护线程：
    垃圾回收线程

提问：守护线程和用户线程有什么区别？
Java 线程分为守护线程(Daemon Thread) 和 用户线程(User Thread)两类.
通常情况下，我们使用Thread 创建的线程在默认情况下都属于用户线程, 当在启动线程之前, 执行thread.setDaemon(true)时, 线程会变成守护线程。
其实在本质上，用户线程和守护线程并没有太大区别，唯一的区别就是会影响虚拟机的退出(程序的终止)。
当jvm中只剩下守护线程时，虚拟机会退出，及程序终止；
而当jvm中至少拥有一个用户线程时，jvm都不会退出。

———————————————
如何设置守护线程 Daemon Thread？

可以通过调用Thread类的setDaemon(true)方法来设置当前的线程为守护线程；

注意事项：

  • setDaemon(true)方法必须在start()之前调用，否则会抛出IllgalThreadStateException异常；
  • 在守护线程中产生的新线程也是守护线程；
  • 不是所有的人物都可以分配给守护线程来执行，比如【读写】或【计算】逻辑；
    （因为守护线程依附于用户线程而存在，如果守护：读写/计算到一半，用户程序退出，那么读写/计算也会退出，那么程序就崩溃了）

———————————————
模拟一个设计不合理的程序

/*
* 情境：主线程 + 守护线程
* 守护线程：往文件中不断写数据；（模拟一个设计不合理的程序）
* 主线程：阻塞等待来自键盘的输入，一旦获取到了键盘输入，阻塞便解除，
* 当然，主线程一旦结束，守护线程就消失（即使写入数据还未进行完，守护线程也会随着JVM一起结束运行）
*
*/

import java.io.*;
import java.util.Scanner;

class DaemonThread implements Runnable{
    @Override
    public void run() {
        System.out.println("进入守护线程" + Thread.currentThread().getName());
        try {
            writeToFile();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("退出守护线程" + Thread.currentThread().getName());
    }

    private void writeToFile() throws Exception {
        File filename = new File("/Users/chiu/Desktop"+File.separator+"daemon.txt");
        OutputStream os = new FileOutputStream(filename,true);
        int count = 0;
        while(count < 999){
            os.write(("\r\nword" + count).getBytes());
            System.out.println("守护线程" + Thread.currentThread().getName()
            + "向文件中写入了word" + count++);
            Thread.sleep(1000);
        }
    }
}

public class Test1 {
    public static void main(String[] args) {
        System.out.println("进入主线程" + Thread.currentThread().getName());

        DaemonThread daemonThread = new DaemonThread();
        Thread thd = new Thread(daemonThread);
        thd.setDaemon(true); // 设置成守护线程
        thd.start();

        Scanner sc = new Scanner(System.in);
        sc.next(); // 主线程被阻塞；若有输入操作，则解除阻塞，继续执行，从而打印下一句话

        System.out.println("退出主线程" + Thread.currentThread().getName());
    }
}

/*
* 若守护线程正常退出，那么会输出到999句，且输出："退出守护线程" + Name
* 若主线程意外退出，守护线程终止，不会输出到999句，且不会输出："退出守护线程" + Name
*
*/
——————————————
输出：
进入主线程main
进入守护线程Thread-0
守护线程Thread-0向文件中写入了word0
守护线程Thread-0向文件中写入了word1
...
守护线程Thread-0向文件中写入了word30
守护线程Thread-0向文件中写入了word31
aaaaah  // 键盘输入了任意字符
退出主线程main

——————————————
桌面的Daemon.txt

word0
word1
word2
...
word29
word30
word31

——————————————————————————————

JStack （生成线程快照）

用JStack生成线程快照

除了用JStack，还可以用jstat.exe（命令行工具） jvisualvm.exe（界面化工具）

JStack：
作用：生成JVM当前时刻线程的快照（threaddump，即当前进程中所有线程的信息）；
目的：帮助定位程序问题出现的原因，如长时间停顿、CPU占用率过高等；（也可以很容易看出哪些是守护线程和用户线程）

总结：

  1. JStack中，若有 daemon标识 ，则表示是守护线程；若无，则表示用户线程；
  2. 通过查看 Thread State线程状态 ，可以让我们了解到导致某个线程死锁、阻塞的原因；（辅以查阅JDK文档）
    如java.lang.Thread.State: TIMED_WAITING (sleeping)，
  3. tid nid 可以让我们直观看到哪些线程CPU占有率过高；

1.在Terminal查看 JStack 信息：

$ jstack
Usage:
    jstack [-l] <pid>
        (to connect to running process)
        // 如果输入【-l】：指显示关于锁的额外信息
    jstack -F [-m] [-l] <pid&
最低0.47元/天 解锁文章
Yaau
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE——多线程
qq_46002941的博客
01-22 165
记录看视频自学多线程的一些笔记
JAVA多线程编程
WWChu的技术人生
09-26 438
转载自：http://lavasoft.blog.51cto.comJava线程：概念与原理 SCJP5学习笔记 一、操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。 线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程
JavaSE -- 多线程
rbx508780的博客
09-26 219
📕 JAVASE多线程超详细知识点总结 1.相关概念 2.线程的创建与启动 3.Thread类 4.线程的生命周期状态 5.线程安全问题 6.等待唤醒机制 7.释放锁操作与死锁
（Java多线程）多线程原理和使用
我真的很不错的博客
06-07 429
并发与并行 并发：指两个或多个事件在同一个时间段内发生。 并行：指两个或多个事件在同一时刻发生（同时发生）。 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程
java会话管理、多线程.docx
04-21
【Java会话管理与多线程详解】 Java会话管理主要涉及的是在Web应用程序中如何维护用户的状态信息。在Web应用中，用户打开一个页面，然后进行一系列操作，这些操作可能跨越多个HTTP请求。为了保持用户的上下文信息，...
Java多线程Callable接口
01-20
在Java SE5中引入的Callable是一种具有类型参数的泛型，它的类型参数表示的是从方法call()中返回的值，并且必须使用ExecutorService.submit()方法调用它。 import java.util.ArrayList; import java.util....
Java SE文档（全）
02-09
12. **多线程**：Java内置了多线程支持，可以通过实现Runnable接口或继承Thread类创建线程，以及使用synchronized关键字和Lock接口实现线程同步。 以上只是Java SE文档中的一部分内容，实际文档会更详细地涵盖异常...
Java SE实现多人聊天室功能
08-26
Java SE实现多人聊天室功能需要使用到Java SE中的Socket套接字编程、多线程编程、IO流编程等技术，还需要考虑到线程安全问题。 知识点： 1. Java SE中的Socket套接字编程 2. 多线程编程 3. IO流编程 4. 线程安全...
JAVA SE应用详解.pdf
05-28
Java语言具有面向对象、与平台无关、简单稳定、支持多线程等特点，已经成为当下最重要的网络编程语言之一。本书分为12个章节，主要包括Java语言概述 、基本语法规则、面向对象核心技术、数组和集合、异常处理、文件...
javaSE多线程
客官不爱喝酒的博客
09-12 209
1、基本概念：程序、进程、线程 程序(program)： 为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process)： 程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期 如：运行中的QQ，运行中的MP3播放器程序是静态的，进程是动态的 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 若一个进程同一
JavaSE之多线程
zsq_z0304的博客
11-12 125
多线程
JavaSE 多线程
qq_19434213的博客
08-25 171
1 线程概述 1.1 java 是为数不多的支持多线程的语言。 1.2 几乎所有的操作系统都支持进程的概念，所有运行中的任务通常对应一个进程。当一个程序进入内存运行时，即变成了一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。 1.3 一般而言，进程包含如下三个特征： 1.3.1 独立性：进程是系统中独立存在的实体，它可以拥有自己独立
JavaSE_多线程
itszt888的博客
07-20 638
1、课程名称：多线程 2、知识点 2.1、本次预计讲解的知识点 1、 了解进程和线程的区别 2、 理解Java线程的两种实现方法及区别 • 可以清楚的解释出两种实现的方式、区别、联系即可 3、 了解线程的基本控制方法，尤其是线程的休眠 4、 线程的同步与死锁的区别及使用。 • 可以清楚的讲解出为什么需要同步，以及同步的实现，和死锁问题的产生 5、 了解线程
javaSE_多线程
子龙修仙的博客
05-08 205
线程的创建和启动：A：继承Thread类创建线程1.定义Thread类的子类，并重写run方法。2.创建对象，调用start方法启动线程. B：实现Runnable接口来创建线程1.创建一个类实现Runnable接口，并重写run方法。2.创建类对象，并以此实例作为Thread的target来创建Thread对象。3.调用Thread对象的start方法启动线程。 1. Thread public...
JavaSE 多线程(线程的4种创建方式)
weixin_44717746的博客
06-20 152
一：线程创建的方式一：继承Thread类 1.创建一个继承于Thread类的子类 2.重写Thread类的run() —> 将此线程执行的操作声明在run()方法中 3.创建Thread类的子类对象 4.通过此对象调用start() 例子：遍历100以内的偶数 可以看出有两个线程在即MyThread线程 与 main线程 注： **问题一：**我们不能通过直接调用run()方法启动线程。 **问题二：**在启动一个线程，遍历100以内的偶数，不可以还让已经start()的线程去执行。会报
JAVA语言基础_线程、线程池、Lambda表达式
weixin_34097242的博客
05-01 232
2019独角兽企业重金招聘Python工程师标准>>> ...
java并发工具类
qq_42762824的博客
11-16 88
title : 每日深耕，勤练不缀之java并发工具类 带你走进并发的世界 回顾：我们在IO中讲的用线程池，只是相对于几百访问量的并发，那些只是我们练习时的Demo， 我们通常所说的并发包就是java.util.concurrent及其子包，集中了Java并发的各种基础工具类： 提供了比synchronized更加高级的各种同步结构，包括CountDownLatch、CyclicBarrier、Semaphore等，可以更加丰富的多线程操作。 线程安全的容器 ConcurrentHashMap,无.
java多线程并发库使用
最新发布
01-27
Java多线程并发库是指Java语言为方便开发者使用多线程并发编程而提供的一组类和接口。它包含在Java SE的java.util.concurrent包中，提供了丰富的工具和组件，以支持并发编程。 Java多线程并发库的使用可以带来以下几个好处： 1. 提高并发性能：使用多线程并发库可以更好地利用多核处理器的能力，将计算密集型和I/O密集型任务分配给不同的线程，从而提高程序的并发性和响应能力。 2. 简化并发编程：多线程并发库提供了一系列的线程安全的集合类，如ConcurrentHashMap、ConcurrentLinkedQueue等，简化了共享数据的同步和访问控制，避免了手动编写复杂的同步代码。 3. 提供了高级的同步和通信机制：多线程并发库提供了更高级的同步机制，如锁、条件变量、信号量、倒计时门闩等，可以实现更细粒度的并发控制，避免了死锁和资源竞争问题。 4. 支持任务的执行和结果的返回：多线程并发库提供了Executor框架和Future接口，可以方便地提交任务和获取任务结果，更好地管理线程池，提高了任务的执行效率和结果的返回。 总之，Java多线程并发库的使用能够显著提高程序的并发性能，简化并发编程，提供更高级的同步和通信机制，更好地管理线程池，使开发者能够更轻松地编写高效、安全的多线程并发程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值