最全多线程知识点集结

最新推荐文章于 2024-07-27 17:56:15 发布
最新推荐文章于 2024-07-27 17:56:15 发布
阅读量216 收藏 1
点赞数 1
分类专栏： java 文章标签： 多线程 java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22002457/article/details/106735436
版权

文章目录

程序 进程 线程的理解

1.程序(program)
是为了完成特定任务,用某种语言编写的一组指令的集合,即指一段静态的代码.

2.进程(process)
概念:正在运行的程序;
说明:进程是资源分配的单位,每个进程会得到系统分配的不同的内存区域;

3.线程(thread)
概念:线程是进程的进一步细化,是程序执行的一条路径.
说明: 进程可以细化为多个进程
每个线程,拥有自己独立的:虚拟机栈, 程序计数器
多个线程,共享同一个进程中的结构:方法区,堆
一个Java应用程序java.exe，至少有三个线程：main()主线程，垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

4.并行与并发的理解
并行:多个CPU同时执行多个任务;例如:多个人同时做不同的事.
并发: 一个CPU同时执行多个任务;例如:秒杀,多个人同时做一件事.

线程创建的方式

方式一：继承于Thread

1.创建一个继承于Thread类的子类
2.重写Thread中的run()需要执行的操作
3.创建子类对象，调用start();作用：①启动当前线程②调用当前线程的run()

  • 问题一：我们不能通过直接调用run()的方式启动线程。
  • 问题二：再启动一个线程，不可以让已经start()的程序去执行，会报错IllegalThreadStateException
  • 需要重新创建新的线程对象
//1.创建一个继承于Thread类的子类
class MyThread extends Thread {
    //2.重写Thread 中的run()
    public void run(){
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        MyThread t=new MyThread();
        t.start();
        //如下的是在main线程中执行的
        for (int i = 0; i < 100; i++) {
            if(i%2==0)               System.out.println(Thread.currentThread().getName()+i+"****main****");
            }
        }
    }
}

方式二：实现Runnable接口

  • 1.创建一个实现接口Runnable的类;
  • 2.实现类去实现Runnable中的抽象方法run();
  • 3.创建实现类对象
  • 4.将此对象作为参数传给Thread中的构造器中，创建Thread对象；
  • 5.通过Thread类的对象调用start;①启动线程②调用当前线程的run()–>调用的是Runnable类型的target的run()方法

比较创建线程的两种方式

  • 开发中：优先选择：实现Runnable接口的方式
  • 原因：1.实现的方式没有类的单继承的局限性
  • 2.实现的方式更适合来处理多个线程有共享数据的情况
    联系：
  • public class Thread implements Runnable
  • 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中
ublic class ThreadTest1 {
    public static void main(String[] args) {
        Threadjk p = new Threadjk();
        Thread t1 = new Thread(p);
        t1.setName("线程1");
        t1.start();
        //再启动一个线程
        Thread t2 = new Thread(p);
        t2.setName("线程2");
        t2.start();
    }
}
class Threadjk implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }

    }
}

Thread类中的常用方法

测试Thread中常用的方法

  • 1.start():启动当前线程，调用当前线程的run();
  • 2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明再此方法中
  • 3.currentThread():静态方法，返回执行当前代码的线程
  • 4.getName():获取当前线程的名字
  • 5.setName():设置当前线程的名字
  • 6.yield():释放当前CPU的执行权
  • 7.join():在线程A中调用线程B的join(),此时线程A进入阻塞状态，直到线程B完全执行完以后，线程A才结束阻塞状态；
  • 8.stop():已过时，当执行此方法时，强制结束线程
  • 9.sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒，在指定的毫秒数内，当前线程处于阻塞状态
  • 10.isAlive():判断当前线程是否存活；

1.线程的优先级：

  • NORM_PRIORITY = 5;–>默认优先级
  • MIN_PRIORITY = 1;
  • MAX_PRIORITY = 10;

2.如何获取和设置当前线程的优先级：

  • getPriority():获取线程的优先级
  • setPriority(int p):设置线程的优先级

说明：高优先级的线程要抢占低优先级线程CPU的执行权，但是只是从概率上讲，高优先级的线程高概率的情况下被执行，并不意味着

  • 只有高优先级的线程执行结束后，再执行低优先级的线程

线程的生命周期

在这里插入图片描述
说明：
1.生命周期关注两个概念：状态、相应的方法
2.关注：状态a–>状态b:哪些方法执行了（回调方法）
某个方法主动调用：状态a–>状态b
3.阻塞：临时状态，不可以作为最终状态
死亡：最终状态。

线程的同步机制

方式一：同步代码块

  synchronized(同步监视器){
        //需要被同步的代码
  }

说明：1.操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。
2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
要求：多个线程必须要共用同一把锁。

  • 补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
    在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
public void run() {
        while(true){
            synchronized(this) {//this 表示Dow 对象
                if (sticke > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ",票号为：" + sticke);
                    sticke--;
                } else {
                    break;
                }
            }

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

关于同步方法的总结：

  • 1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
  • 2.非静态的同步方法，同步监视器是：this
  • 3 静态的同步方法，同步监视器是：当前类本身
public synchronized void show(){//同步监视器 this 当前实现类对象
    if (sticke > 0) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ",票号为：" + sticke);
        sticke--;
    }
}

方式三：lock(锁)–开发中优先使用 JDK 5.0 新增

  • 1.实例化Reentrantlock
  • 2.调用lock()锁定方法
  • 3.调用unlock()解锁方法
class Windo implements Runnable{
    private int ticke=100;
    private   ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while(true){
            try {
                lock.lock();
                if (ticke > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "：票号：" + ticke);
                    ticke--;
                } else {
                    break;
                }
            }finally{
                lock.unlock();
            }
        }
    }
}
public class WindowTest3 {
    public static void main(String[] args) {
        Windo t = new Windo();
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");
    }
}

面试题：synchronized和lock的异同？

  • 1.相同点：都能解决线程安全问题
  • 2.不同点：synchronized机制在执行完同步代码之后自动释放同步监视器
  • lock 需要手动的启动同步(lock()),同时结束同步也需要手动实现(unlock())

面试题：解决线程安全问题有几种方法？
有三种分别是：

  • 1.同步代码块
  • 2.同步方法
  • 3.lock锁

信息通讯测试；

两个线程 交替输出1-100

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

说明：
1.wait()\notify()\notifyAll()三个方法使用必须在同步代码块内或同步方法内
2.wait()\notify()\notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器
否则会报错：IllegalMonitorStateException
3.wait()\notify()\notifyAll()三个方法声明在Object类中

class Num implements Runnable {
    private int p = 1;

    @Override
    public void run() {
//        Object obj=new Object();
        while (true) {
            synchronized (this) {

                notify();
                if (p <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + p);
                    p++;
                } else {
                    break;
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

public class NumberWait {
    public static void main(String[] args) {
        Num t = new Num();
        Thread j = new Thread(t);
        Thread j1 = new Thread(t);
        j.start();
        j1.start();
        j.setName("线程一");
        j1.setName("线程二");
    }
}

jdk5.0新增创建多线程方式

方式三：实现Callable接口

优势：
1.call()可以有返回值
2.call()可以抛出异常，被外面的操作所捕获，获取异常信息；
3.call()支持泛型
实现步骤：

  • 1.创建一个实现Callable的实现类
  • 2.实现call()方法，将此线程需要进行的操作声明在call()方法中
  • 3.创建Callable实现类的对象
  • 4.将此实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
  • 5.将FutureTask的对象作为参数传递给Thread类的构造器中，创建Thread对象，并调用start();
  • 6.获取Callable中call()方法的返回值
//1.创建一个实现Callable的实现类
class Able implements Callable{
    @Override
    //2.实现call()方法，将此线程需要进行的操作声明在call()方法中
    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 CallableTest {
    public static void main(String[] args) {
        //3.创建Callable实现类的对象
        Able p = new Able();
        //4.将此实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask task = new FutureTask(p);//public class FutureTask<V> implements RunnableFuture<V>
        //5.将FutureTask的对象作为参数传递给Thread类的构造器中，创建Thread对象，并调用start();
        Thread t = new Thread(task);
        t.start();
        try {
            Object sum=task.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

方式四：使用线程池

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();
    }

}

说明：
好处：

  • 1.提高响应速度（减少了创建新线程的时间）
  • 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
  • 3.便于线程管理
    corePoolSize：核心池的大小
    maximumPoolSize：最大线程数
    keepAliveTime：线程没任务时最多保持多长时间后会终止
码上搬钻
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程知识总结
qq_43623773的博客
06-25 324
进程和线程 进程：简单来说就是运行的一个程序，在我们运行一个main程序时，就会有一个JVM线程，而这个main程序就是一个线程，也称为主线程。（CPU资源分配的最小单位） 线程：一个进程可以有多个线程，同一个进程的线程可以共享该线程的堆区、方法区资源，但每个线程有自己的程序员计数器、虚拟机栈、本地方法栈。 程序计数器：简单来说就是指示线程运行到哪一行，字节码指示器工作时通过改变这个计数器的值来选取下一条需要执行的字节码指令。还有在线程切回时获取该线程上次执行到那. java虚拟机栈：主要有局部变量表、常量
多线程知识点总结（通俗易懂）
haoyueONEX的博客
01-02 935
多线程
多线程的知识点
qq_62086657的博客
05-27 392
多线程、进程、synchronize、生产者与消费者模式、wait（）方法、sleep（）方法、线程生命周期、yield（）方法、jion（）方法、notify（）方法、线程同步与互斥、锁
多线程重点知识归纳总结。
yzh2776680982的博客
06-08 1963
一、线程相关概念 1、程序 程序是一个指令序列。是为完成特定任务、 用某种语言编写的一组指令的集合。简单的说:就是我们写的代码 它以某些程序设计语言编写，运行于某种目标结构体系上。打个比方，程序就如同以英语（程序设计语言）写作的文章，要让一个懂得英语的人（编译器）同时也会阅读这篇文章的人（结构体系）来阅读、理解、标记这篇文章。一般的，以英语文本为基础的计算机程序要经过编译、链接而成为人难以解读，但可轻易被计算机所解读的数字格式，然后放入运行。 2、进程 ............
多线程知识点整理
qq_37141187的博客
07-24 197
多线程知识点整理
6.2 多线程（下）
Huonly
10-27 257
1.线程池 1.1 线程状态介绍 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？Java中的线程 状态被定义在了java.lang.Thread.State枚举类中，State枚举类的源码如下： public class Thread { public enum State { /* 新建 */ NEW , /* 可运行状态
程序员面试2023，集结了阿里、腾讯、京东、美团一线大厂面试实战
03-07
本文将围绕2023年一线互联网大厂如阿里巴巴、腾讯、京东、美团等公司的面试实战经验进行探讨，提供一些核心知识点和面试真题解析。 面试流程通常包括简历筛选、电话初筛、技术面试、HR面试等多个环节。在面试前，你...
代码随想录知识星球精华-大厂面试八股文第二版v1.2.pdf
05-18
Java部分则涵盖了类与对象、异常处理、集合框架、多线程、IO流、JVM（Java虚拟机）工作原理以及内存管理等关键知识点。文档特别强调了对Java核心技术的深入理解，如垃圾回收机制、JVM调优等，以帮助面试者在面试中...
Java火影忍者游戏源代码
03-16
此外，Java的多线程机制在游戏运行中也扮演重要角色，如控制游戏循环和同步。 2. **Android开发环境**：由于是手机版游戏，开发者需要对Android SDK有深入理解，包括AndroidManifest.xml文件的配置、Activity和...
剑指offer刷题笔记.zip
05-13
11. **并发与多线程**：线程同步、死锁、线程池的概念和应用。 12. **网络编程**：TCP/IP协议、HTTP协议的基础知识，socket编程。 13. **数据库**：SQL查询优化、事务处理、索引原理等。 14. **数据一致性与...
剑指offer（java版）.rar_剑指offer_剑指offer java_剑指offer（java版）
09-24
5. **多线程与并发**：Java提供了丰富的多线程支持，包括Thread类、Runnable接口以及Executor框架。理解线程安全、死锁、活锁、饥饿等概念，以及如何使用synchronized关键字、wait/notify机制和Lock接口，是高级Java...
多线程知识点总结
jacksonary的博客
06-02 6639
1.进程和线程的区别进程：是程序的执行过程，具有动态性，即运行的程序就叫进程，不运行就叫程序 线程：系统中的最小执行单元，同一进程中有多个线程，线程可以共享资源，一旦出现共享资源，必须注意线程安全！！Java线程分为两类，一类是守护线程，典型是垃圾回收GC；第二类是用户线程，当JVM中都是JVM守护线程，那么当前的JVM将退出。2.线程创建的两种方式，继承Thread类、实现Runnable接口2
多线程编程基础知识（一）
xydqsy的博客
12-11 359
当前流行的Windows操作系统能同时运行几个程序（独立运行的程序又称为进程），对于同一个程序，它又可以分为若干个独立的执行流，我们称之为线程，线程提供了多任务处理的能力。用线程和进程的观点来研究软件是当今普遍采用的方法，进程和线程的概念的出现，对提高软件的并行性有着重要的意义。现在的大型应用软件无一不是多线程多任务处理，单线程的软件是不可想象的。因此掌握多线程多任务设计方法对每个程序员都是必需要掌
多线程与高并发编程之基础知识（上）
热门推荐
boker_han的博客
10-01 5万+
前言： 使用多线程，第一步就是需要知道如何实现自定义线程，因为实际开发中，需要线程完成的任务是不同的，所以我们需要根据线程任务来自定义线程，那么，JDK提供了三种自定义线程的方式，供我们实际开发中使用，来开发出符合需求的多线程程序！ 以下给出线程的三种实现方式，并且对每种实现的优缺点进行分析，最后对三种实现方式进行总结； 方式一：继承Thread类，重写run方法 package com.thr...
golang 接口
m0_70982551的博客
07-24 818
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 369
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
【Java算法专场】二分查找(下）
最新发布
zhyhgx的博客
07-27 435
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
springboot之自动装配
weixin_50153914的博客
07-23 513
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java多线程深度解析：知识点与企业实战
"Java多线程相关知识点及企业面试题" 在Java编程中，多线程是核心概念之一，尤其对于构建高效、响应迅速的系统至关重要。以下是对Java多线程知识点的详细总结： 1. **多线程相关概念** - **程序**：一组指令的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值