【JAVA】线程知识点总结

已于 2024-03-23 21:30:32 修改
阅读量617 收藏 20
点赞数 16
文章标签： java
于 2024-03-23 21:07:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43710228/article/details/136970593
版权

目录

1、相关概念

1.1 进程

一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程。

1.2 线程

线程由进程创建，是进程的一个实体。一个进程可以拥有多个线程。一个进程的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

1.3 单线程

同一个时刻，只允许执行一个线程。

1.4 多线程

同一个时刻，可以执行多个线程。比如一个QQ进程可以同时打开多个聊天窗口，一个浏览器进程，可以同时打开多个网页。

1.5 并发

同一个时刻，多个任务交替执行。单核CPU实现的多任务就是并发。

1.6 并行

同一个时刻，多个任务同时执行。多核CPU可以实现并行。

2、线程基本使用

2.1 创建线程的两种方式

2.1.1 继承Thread类，重写run方法

public class Thread01 {
    public static void main(String[] args) throws InterruptedException{
        MyThread thread1 = new MyThread();
        thread1.start();//start()最终会执行run方法。通过start()调用才能开启线程，开启线程后不会对下面的语句进行阻塞，而是子线程和主线程并发执行。
                        //如果使用thread1.run()方法，则是将run方法当作普通方法调用，不能开启子线程。
                        //start()方法是通过JVM调用start0()方法实现多线程效果的，start0底层由c/c++实现。

        for(int i=0;i<3;i++) {
            System.out.println("主线程执行："+ i);
            Thread.sleep(1000);
        }
        System.out.println("主线程结束");//主线程结束，不会导致子线程结束，除非子线程是守护线程。
    }
}

class MyThread extends Thread {
    int times = 0;
    @Override
    public void run() {
        while(true) {
            System.out.println((++times) + "线程名:" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
            if (times == 100) {
                break;
            }
        }

    }
}
//输出结果：
//主线程执行：0
//1线程名:Thread-0
//主线程执行：1
//2线程名:Thread-0
//主线程执行：2
//3线程名:Thread-0
//主线程结束
//4线程名:Thread-0
//5线程名:Thread-0
//6线程名:Thread-0

2.1.2 实现Runnable接口

为什么有第一种方法还要有这种方法？
java是单继承的，某些情况下一个类已经继承了某个类，这时就无法再继承Thread类了。

public class Thread02 {
    public static void main(String[] args) {
        Tiger tiger = new Tiger();
        new Thread(tiger).start();
    }
}
class Animal {

}

class Tiger extends Animal implements Runnable {
    int times = 0;
    @Override
    public void run() {
        while(true) {
            System.out.println("线程名："+Thread.currentThread().getName()+(++times));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(times == 100) {
                break;
            }
        }

    }
}

在这里插入图片描述

2.1.3 多线程执行

创建两个线程，一个线程每隔1s输出"hello,world"，一个线程每隔0.5s输出"hi,world"。

public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        new Thread(t1).start();
        new Thread(t2).start();

    }
}
class T1 implements Runnable {
    int count = 0;

    @Override
    public void run() {
        while(true) {
            System.out.println("hello,world" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class T2 implements Runnable {
    int count = 0;

    @Override
    public void run() {
        while(true) {
            System.out.println("hi,world" + (++count));
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

2.1.4 继承Thread和实现Runnable的区别

1、本质上没有区别，Thread类本身就实现了Runnable接口
2、实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable。

3、线程终止

3.1 基本说明

1、当线程完成任务后，会自动退出
2、可以通过使用变量控制run方法退出的方式停止线程，即通知方式。

3.2 应用示例

子线程通过loop变量控制循环，主线程5s后通过修改loop的值使子线程结束循环。

public class Thread04 {
    public static void main(String[] args) {
        AThread aThread = new AThread();
        new Thread(aThread).start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        aThread.setLoop(false);
        

    }
}
class AThread implements Runnable {
    private boolean loop = true;
    @Override
    public void run() {
        while(loop) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("AThread运行中");
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

4、线程常用方法

1、setName：设置线程名称，使之与参数name相同。
2、getName：返回该线程的名称。
3、start：使该线程开始执行。
4、run：调用线程对象run方法。
5、setPriority：更改现成的优先级。
6、getPriority：获取线程的优先级。
7、sleep：让线程休眠指定的毫秒数。静态方法，可以通过Thread直接调用。
8、interrupt：中断线程。
9、yield：线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，不一定礼让成功。静态方法，可以通过Thread直接调用。
10、join：线程的插队。插队的线程一旦插队成功，则一定先执行完插入的线程的所有任务。
线程优先级：
在应用程序中，如果要对线程进行调度，最直接的方式就是设置线程的优先级。优先级越高的线程获得CPU执行的机会越大，而优先级越低的线程获得CPU执行的机会越小。线程的优先级用1～10的整数来表示，数字越大优先级越高。除了可以直接使用数字表示线程的优先级外，还可以使用Thread类中提供的3个静态常量表示线程的优先级，如下所示：
1.static int MAX_PRIORITY：表示线程的最高优先级，值为10。
3.static int NORM_PRIORITY：表示线程的普通优先级，值为5。
2.static int MIN_PRIORITY：表示线程的最低优先级，值为1。

join示例

public class Thread05 {
    public static void main(String[] args) throws InterruptedException{
        T3 t = new T3();
        Thread t1 = new Thread(t);
        t1.start();
        t1.join();
        System.out.println("主线程运行");

    }
}

class T3 implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<5;i++) {
            System.out.println(i);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
// 输出：
//0
//1
//2
//3
//4
//主线程运行

线程的类型
1、用户线程：也叫工作线程，当线程的任务执行完或以通知方式结束。默认创建的线程都是用户线程。
2、守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束。常见的守护线程：垃圾回收机制。使用setDaemon(true)方法可以将一个线程对象设置为守护线程，必须要放在线程的 start() 之前。isDaemon() 方法可以返回是否是守护线程。

5、线程的生命周期

5.1线程状态转换图

线程状态转换图
代码解释

  • Thread.sleep(long millis)：这个方法会使当前线程休眠指定的毫秒数。它可以用来在程序中暂停执行，但不会释放锁或者让其他线程有机会执行。
  • o.wait()：这是Object类中的一个方法，它让当前线程等待，直到另一个线程调用相同对象的 notify() 或 notifyAll() 方法。在等待期间，线程会释放对象的锁。
  • o.notify() 方法用于唤醒等待在对象 o 上的一个线程（如果有多个线程等待，则唤醒其中一个，具体哪一个取决于JVM的实现）。
  • o.notifyAll() 方法则会唤醒所有等待在对象 o 上的线程。
    这两个方法通常与 o.wait() 配合使用，用于实现线程之间的协调和通信。等待线程在某些条件满足时调用 o.wait() 进入等待状态，而唤醒线程则在某些条件满足时调用 o.notify() 或 o.notifyAll() 来通知等待线程继续执行。
  • t.join()：这个方法会使当前线程等待调用它的线程 t 执行完毕。
  • LockSupport.parkNanos(long nanos)：这是 LockSupport 类的一个方法，它会阻塞当前线程，最多阻塞指定的纳秒数。如果提供的 nanos 参数大于零，则当前线程会被阻塞指定的纳秒数。如果 nanos 参数为零或负数，则该方法立即返回而不会阻塞当前线程。
  • LockSupport.parkUntil(long deadline)：这个方法会使当前线程阻塞，直到指定的时间点（以毫秒为单位）。如果 deadline 参数大于当前时间，则当前线程会被阻塞直到指定的时间点；否则该方法会立即返回而不会阻塞当前线程。
  • LockSupport.park()：用于阻塞当前线程。与 Thread.sleep() 不同，LockSupport.park() 不会抛出 InterruptedException，因此它更适用于在特定条件下阻塞线程。这个方法通常与 unpark() 方法一起使用，unpark(Thread thread) 方法用于解除线程的阻塞状态。调用 unpark(Thread thread) 方法会将目标线程的许可状态设置为“已使用”。如果线程在 park() 之前调用了 unpark(Thread thread)，那么 park() 方法会立即返回，否则当前线程将被阻塞，直到调用 unpark() 方法。

5.2 线程状态

Thread.State枚举表示了线程的6种状态

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

通过getState方法能够查看线程的状态。

6、线程的同步

在多线程编程中，一些敏感数据不能被多个线程同时访问，此时需要使用同步访问技术，保证数据在任何同一时刻最多有一个线程访问，以保证数据的完整性。

6.1 同步具体方法-Synchronized

1、同步代码块

synchronized (对象) { //得到对象的锁，才能操作同步代码
// 需要被同步代码;
}

2、同步方法

public synchronized void m (String name) {
// 需要被同步的代码
}

3、选择作为锁的对象

在实际编程中，选择作为锁的对象时，通常会选择以下几种方式：

  1. 使用共享资源本身的对象：如果你有一个共享资源，比如一个共享的数据结构，你可以使用该数据结构的实例作为锁对象。
public class SharedResource {
    private List<Integer> data = new ArrayList<>();

    public void addToData(int value) {
        synchronized (this) {
            data.add(value);
        }
    }

    public int getDataSize() {
        synchronized (this) {
            return data.size();
        }
    }
}
  1. 使用私有的对象作为锁：有时候，如果你没有一个特定的共享资源，你可以创建一个私有的对象作为锁。
public class SomeClass {
    private Object lock = new Object();

    public void someMethod() {
        synchronized (lock) {
            // 同步代码块
        }
    }
}
  1. 使用静态对象作为锁：如果需要对静态资源进行同步，可以使用该类的 Class 对象作为锁。
public class SharedResource {
    private static List<Integer> data = new ArrayList<>();

    public static void addToData(int value) {
        synchronized (SharedResource.class) {
            data.add(value);
        }
    }

    public static int getDataSize() {
        synchronized (SharedResource.class) {
            return data.size();
        }
    }
}

4、使用synchronized解决售票问题

public class SellTicket {
    public static void main(String[] args) {
        SellTicket sellTicket = new SellTicket();
        new Thread(sellTicket).start();//第1 个线程-窗口
        new Thread(sellTicket).start();//第2 个线程-窗口
        new Thread(sellTicket).start();//第3 个线程-窗口
    }
}
class SellTicket implements Runnable {
    private int ticketNum = 100;//让多个线程共享ticketNum
    private boolean loop = true;//控制run 方法变量
    
    //同步方法（静态的）的锁为当前类本身
    public synchronized static void m1() {//锁是加在SellTicket03.class
    }
    public static void m2() {
        synchronized (SellTicket.class) {
            System.out.println("m2");
        }
    }
    //1. public synchronized void sell() {} 就是一个同步方法
    //2. 这时锁在this 对象
    //3. 也可以在代码块上写synchronize ,同步代码块, 互斥锁还是在this 对象
    public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell 方法
        synchronized (this) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }
            //休眠50 毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口" + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));
        }
    }
    @Override
    public void run() {
        while (loop) {
            sell();//sell 方法是一共同步方法
        }
    }
}

细节：

  1. 同步方法如果不是静态的，默认锁对象为this；如果是静态的，默认锁对象：当前类.class
  2. 在上锁时注意多个线程的锁对象必须是同一个

7、线程的死锁

7.1 介绍

多个线程都占用了对方的锁资源，但都不能释放，导致了死锁。

7.2 案例

  • 如果flag 为T, 线程A 就会先得到/持有o1 对象锁, 然后尝试去获取o2 对象锁
  • 如果线程A 得不到o2 对象锁，就会Blocked
  • 如果flag 为F, 线程B 就会先得到/持有o2 对象锁, 然后尝试去获取o1 对象锁
  • 如果线程B 得不到o1 对象锁，就会Blocked
public class DeadLock {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A 线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B 线程");
        A.start();
        B.start();

    }
}
class DeadLockDemo extends Thread {
    static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用static
    static Object o2 = new Object();
    boolean flag;
    public DeadLockDemo(boolean flag) {//构造器
        this.flag = flag;
    }
    @Override
    public void run() {
        if (flag) {
            synchronized (o1) {//对象互斥锁, 下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入1");
                synchronized (o2) { // 这里获得o2对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入3");
                synchronized (o1) { // 这里获得o1对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入4");
                }
            }
        }
    }
}

8、释放锁

8.1 下面操作会释放锁

  1. 当前线程的同步方法、同步代码块执行结束。
  2. 当前线程在同步代码块、同步方法中遇到break、return。
  3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
  4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

8.2 下面操作不会释放锁

  1. 当前线程在同步代码块、同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁。
  2. 当前线程在同步代码块、同步方法时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。方法不再推荐使用。
无忌11
关注
  • 16
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 线程知识点总结
qq_56350439的博客
04-22 3464
程序、进程、线程： 程序：是指含有指令和数据的文件，被存储在磁盘或其他的数据设备中，也就是说程序是静态的代码； 进程：是程序的一次执行过程，是代码在数据集合上的一次运行活动，是系统资源分配和调度的基本单位； 线程：是进程的一个执行路径， ...
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6236
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
Java基础知识点总结
是阿超
09-25 4574
Java基础知识点总结
Java多线程知识点总结
枯木何日可逢春
01-29 2375
Java多线程知识点总结
JAVA多线程知识总结
weixin_52493276的博客
09-19 225
多线程：充分的利用计算机资源，同时执行不同的操作1.计算机的操作系统。进程和线程2.使用java来完成多线程的编码3.线程中的常方法4.线程同步（重点）5.死锁6.生产者消费者模型。异步操作系统：本质就是一个运行在一堆硬件上的巨型软件存在的意义：帮助上层应用程序屏蔽掉硬件的丑陋的接口操作系统的发展史：1.手工操作2.批处理系统3.多道批处理4.分时系统5.实时系统进程：正在执行的程序，其实就是一块内存区域，内部存储这程序的资源。
java线程知识点总结[归类].pdf
10-11
Java 线程知识点总结 Java 线程是一种轻量级的进程，它是进程中的一个独立的控制单元，线程在控制着进程的执行。每个进程至少有一个线程。Java 虚拟机（JVM）启动时会有一个进程 java.exe，该进程至少有一个线程...
java基础知识点总结.doc
12-21
Java基础知识点总结 Java是一种高级的、基于对象的编程语言，具有跨平台、可移植、分布式、多线程、动态的特点。 Java基础知识点总结是学习Java的基础，以下是Java基础知识点总结： 对象的初始化 在创建对象时，...
JAVA核心知识点总结.pdf
10-02
《JAVA核心知识点总结》 Java作为一款广泛应用的编程语言，其核心知识点对于开发者来说至关重要。本资料旨在为准备面试或者系统学习Java的人员提供一个全面的复习框架。以下是对其中部分关键知识点的详细阐述： **...
Java多线程-多线程知识点总结和企业真题
02-04
Java多线程--多线程知识点总结和企业真题
Lombok的hashCode方法
LiZhen314的博客
06-27 308
在继承关系中，父类的hashCode针对父类的所有属性进行运算，而子类的hashCode却只是针对子类才有的属性进行运算，立此贴提醒自己。callSuper = false，根据子类自身的字段值 来生成hashcode， 当两个子类对象比较时，只有子类对象的本身的字段值相同，父类字段值可以不同，callSuper = true，根据子类自身的字段值和从父类继承的字段值 来生成hashcode，当两个子。比较时，只有子类对象的本身的字段值和继承父类的字段值都相同，equals方法的返回值是true。
日常工作记录目录
与海
06-21 661
EasyExcel实现二维码下载与展示
Homebrew使用
gghh2015的博客
06-21 490
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
Rust高性能日志库tklog0.0.8—支持mod设置参数
donnie4w技术专栏
06-21 920
tklog是rust高性能结构化日志库，支持同步日志，异步日志，支持自定义日志的输出格式，支持按时间，按文件大小分割日志文件，支持日志文件压缩备份，支持官方日志库标准API，支持mod独立参数设置
multiprocessing.Queue 多个进程生产和多个进程消费怎么处理
qh0526wy的博客
06-24 202
在主进程中，我们创建了多个消费者和生产者进程，并将它们启动。生产者进程将数据放入队列，消费者进程从队列中取出数据并处理。生产者进程完成后，我们向队列发送。进行多个生产者和多个消费者的场景时，队列可以很好地协调这些进程。这个模式允许多个生产者并发地向队列中放入数据，同时多个消费者并发地从队列中取出并处理数据，直到所有生产者完成生产，消费者接收到结束信号。函数，分别用于从队列中获取数据和向队列中放入数据。来确保队列可以在多个进程之间共享。方法等待队列中的所有任务完成时很有用。在这个示例中，我们创建了一个队列。
计算机等级考试-Java考试大纲
最新发布
weixin_54454406的博客
06-27 58
二级Java语言程序设计考试大纲。
SpringCloud Alibaba Sentinel基础入门与安装
小小默：进无止境
06-19 536
随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式、多语言异构化服务架构的流量治理组件，主要以流量为切入点，从流量路由、流量控制、流量整形、熔断降级、系统自适应过载保护、热点流量防护等多个维度来帮助开发者保障微服务的稳定性。
SpringCloud微服务框架的原理及应用详解（一）
凛鼕将至的博客
06-21 1057
Spring Cloud是一个基于Spring Boot实现的服务治理工具包，在微服务架构中用于管理和协调服务。它提供了一系列框架和组件，如服务发现、配置管理、熔断器、智能路由等，用于简化分布式系统的开发。Spring Cloud通过提供一系列开箱即用的组件和工具，帮助开发者快速构建和部署微服务架构的系统。
JVM 相关知识整理
杨杨杨~~的博客
06-20 820
如果您觉得有用的话，记得给，写作不易啊^ _ ^。而且听说，实在白嫖的话，那欢迎常来啊!!!
Java线程面试题大全.docx
08-10
1. 什么是线程？ 2. 线程和进程有什么区别？ 3. 如何在 Java 中实现线程？ 4. 用 Runnable 还是 Thread？ 5. Thread 类中的 start () 和 run () 方法有什么区别？ 6. Java 中 Runnable 和 Callable 有什么不同？ 7. Java 中 CyclicBarrier 和 CountDownLatch 有什么不同？ 8. Java 内存模型是什么？ 9. Java 中的 volatile 变量是什么？ ......... ........

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值