线程基础！

已于 2023-01-04 18:13:32 修改
阅读量230 收藏
点赞数 1
文章标签： java jvm 开发语言
于 2023-01-03 15:50:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huier_h/article/details/128531383
版权
本文介绍了Java线程的基础知识，包括线程的概念、创建方式（继承Thread类和实现Runnable接口）、线程的生命周期、同步机制以及死锁问题。示例代码展示了如何避免多线程中出现的超卖问题，并讨论了线程同步的重要性。
摘要由CSDN通过智能技术生成

线程基础

文章目录

1.概念

程序

存储在硬盘上的代码，特点：静止的文件，占用外存而不是内存。

进程

运行硬盘上的代码，特点：运行中的文件，占用内存，实例：启动IDEA，就启动了一个进程，操作就会为该进程分配内存空间。

进程是程序的一次执行过程，或者是正在运行中的文件。是一个动态的过程：有自己的生命周期：产生、存在、销毁。

线程

线程是由进程创建，是进程的一个实体。

一个进程可以有多个线程。

其它

单线程：同一个时刻，进程（程序）只允许执行一个线程。

单线程：同一个时刻，进程（程序）可以执行多个线程。

并发：同一个时刻，进程（程序）交替执行多个线程，单核cpu使用并发。

并行：同一个时刻，进程（程序）同时执行多个线程，多核cpu可以使用并行。

2.线程的使用

2.1 继承Thread类

Thread实现了Runnable接口

快速入门

public class QuickStart extends Thread{
    @Override
    public void run() {//在run方法中定义新线程所要执行的任务
        // 该方法是来自Runnable接口，Thread类仅仅是重写该方法
        for (int i = 0; i < 100; i++) {
            System.out.println("新线程"+Thread.currentThread().getName()+"的任务正在执行中！");
        }
        //线程休眠
        try {
            Thread.sleep(1000);//单位ms
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new QuickStart().start();//start方法是开启新线程并执行新线程任务run方法

        //主线程
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程"+Thread.currentThread().getName()+"的任务正在执行中！");
        }
    }
}

当程序（进程）启动时，首先执行main方法（开启一个线程），在main方法中又开启了一个新的线程，程序（进程）使用并发的方法交替执行两个线程。

Thread类实现了Runnable接口，重写了run方法，run方法就是定义当前线程所要执行的任务；我们的线程类只需要继承Thread类，重写run方法定义自己的线程的任务，然后通过start方法开启新的线程即可。

run方法：定义线程所要执行的任务。

start方法：开启一个新的线程。

sleeep方法：使当前线程休眠一定的时间，程序（进程）在休眠的期间不会执行该线程。

进程的生命周期：产生、存在、销毁，在快速入门中当两个线程全都结束任务后，进程销毁。

注意点

        //直接调用run方法
        new QuickStart().run();

如果直接调用run方法，此时就是普通的方法执行，因为并没有开启一个新的线程，仍然只有程序（进程）刚启动时所创建的main线程。

开启一个新的线程，自动执行run方法。

重点

使用start方法开启一个新的线程的底层是继续调用start0方法，这个start0方法是一个本地方法，由本地去执行。

start方法调用start0方法后，新的线程并不一定会立即执行，只是将线程变成了可运行状态，具体的调用时机，取决于本地的调度算法，也就是取决于cpu，由cpu统一调度管理。

2.2 重写Runnable接口

快速入门

public class QuickStart implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("新线程"+Thread.currentThread().getName()+"的任务正在执行中！");
        }
        //线程休眠
        try {
            Thread.sleep(1000);//单位ms
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new Thread(new QuickStart()).start();//使用Thread的有参构造传入线程类

        for (int i = 0; i < 100; i++) {
            System.out.println("主线程"+Thread.currentThread().getName()+"的任务正在执行中！");
        }
    }
}

设计模式：代理

使用静态代理模式

模拟静态代理

  1. 创建Person接口

    public interface Person {
    void eat();
}

  2. 创建ChildrenProxy代理类实现Person接口，并添加特有方法

    public class ChildrenProxy implements Person {

    private Children children;

    public ChildrenProxy(Children children) {
        this.children = children;
    }

    @Override
    public void eat() {
        children.eat();
        System.out.println("孩子们喜欢喝饮料！");
    }

    //特有的方法
    public void proxy(){
        eat();
    }
}

  3. 创建接口实现类，并调用代理对象特定方法

        public static void main(String[] args) {
        //1.原始对象
        Children children = new Children();
        //2.代理对象，增强了原始对象，但是需要原始对象的部分代码
        new ChildrenProxy(children).proxy();
    }

代理：就是对原有对象的增强。

2.3 Runnable接口和Thread类

  1. Runnable接口可以解决Java的单继承模式
  2. 实现Runable接口更加适合多个线程共享一个资源的情况，因为在Runnable接口仅仅定义了如果开启线程要执行的任务，而开启线程依旧需要Thread类，我们可以使用同一个类去创建两个线程，两个线程共享同一个资源类

3.经典多线程买票

Thread类

public class SellTicket01 extends Thread{

    private static int tickets = 100;

    @Override
    public void run() {
        while (true){
            if(tickets <= 0) {
                break;
            }else {
                System.out.println("窗口"+Thread.currentThread().getName()+"售票成功，剩余票数："+tickets);
                tickets--;
            }
        }
    }

    public static void main(String[] args) {
        new SellTicket01().start();//开启线程1
        new SellTicket01().start();//开启线程2
        new SellTicket01().start();//开启线程3
    }
}

问题：3个线程剩余票数不同，且票数不能递减，超卖。

分析：产生这些问题的原因是程序（进程）是并发执行，如果已经经过了判断，但是在其它线程已经将票卖完，再次来到这个线程时则不会再判断，直接卖票，造成了超卖。

Runnable接口

public class SellTickets02 implements Runnable{

    private  int tickets = 100;

    @Override
    public void run() {
        while (true){
            if(tickets <= 0) {
                System.out.println("售票结束，由"+Thread.currentThread().getName()+"结束");
                break;
            }else {
                System.out.println("窗口"+Thread.currentThread().getName()+"售票成功，剩余票数："+tickets);
                tickets--;
            }
        }
    }

    public static void main(String[] args) {
        SellTickets02 target = new SellTickets02();

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

问题：超卖

4.线程终止

  • 自然终止
  • 设置某个变量或条件控制终止
public class ThreadExit extends Thread{

    private boolean loop;

    public ThreadExit(){
        this.loop = true;
    }

    @Override
    public void run() {
        while (loop){
            System.out.println(Thread.currentThread().getName()+"线程正在运行中！");
        }
    }

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

    public static void main(String[] args) throws InterruptedException {
        ThreadExit threadExit = new ThreadExit();

        threadExit.start();
        Thread.sleep(5000);
        threadExit.setLoop(false);
    }
}

5.线程常用方法

常用一

  • 获取线程名
  • 修改线程名
  • 线程休眠
  • 线程中断
  • 获取线程优先级
  • 修改线程优先级
public class Group01 extends Thread{

    @Override
    public void run() {
        for(int i = 0;i < 100;i++){
            System.out.println(Thread.currentThread().getName()+"正在运行中！");

            try{
                System.out.println(Thread.currentThread().getName()+"正在休眠中！");
                Thread.sleep(5000);
            }catch (InterruptedException interruptedException) {//中断异常
                System.out.println(Thread.currentThread().getName()+"中断休眠！");
            }

        }
    }

    public static void main(String[] args) {
        Group01 thread = new Group01();
        thread.setName("灰二");
        thread.start();
        System.out.println("新线程名字："+thread.getName());
//        thread.setPriority(Thread.MAX_PRIORITY);//10
//        thread.setPriority(Thread.NORM_PRIORITY);//5
//        thread.setPriority(Thread.MIN_PRIORITY);//1
        System.out.println("新线程优先级："+thread.getPriority());//1 5 10(常量)

        for(int i = 0;i < 100;i++){
            System.out.println(Thread.currentThread().getName()+"正在运行中！");

            if(i % 10 == 0){
                thread.interrupt();
            }
        }

        thread.interrupt();//中断线程，但是并没有结束线程，一般用来中断正在休眠的线程(中断会抛出异常
        // ，可以捕获进行后续操作)
    }
}

注意点：设置线程优先级并不一定会生效，最终解释权由cpu归属；设置线程名必须要在线程启动之前；中断线程并不会造成线程停止，只是中断当前的操作，多用来中断休眠。

常用二

  • 线程让步
  • 线程插队
public class Group02 extends Thread{
    @Override
    public void run() {
        for(int i = 0;i < 20;i++){
            System.out.println(Thread.currentThread().getName()+"正在运行中！");

            try {
                Thread.sleep(2000);
            } catch (InterruptedException interruptedException) {
                interruptedException.printStackTrace();
            }

            if(i == 5){
                Thread.currentThread().yield();//线程让步，让出cpu的控制权，可能不会成功
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Group02 thread = new Group02();
        thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"正在运行中！");

            Thread.sleep(2000);

            if(i == 5){
                thread.join();//线程插队，直到thread线程执行完毕，主线程继续执行
            }
        }
    }
}

注意点：yield是线程让步，表示让出自己的cpu控制权，cpu去执行其它线程，可能不会成功；join是线程插队，表示让线程插入当前线程，只有插入线程执行完毕后，当前线程才能继续执行。

6.用户线程和守护线程

**用户线程：**工作线程，当线程的任务执行完毕或者以通知的方式结束。

**守护线程：**工作线程服务，当所有的用户线程结束，守护线程自动结束。垃圾回收机制就是常见的守护线程

public class QuickStart extends Thread{
    @Override
    public void run() {
        while (true){
            System.out.println("守护线程执行中！");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException interruptedException) {
                interruptedException.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        QuickStart thread = new QuickStart();
        thread.setDaemon(true);//设置为守护线程
        thread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("用户线程运行中！");
        }
        System.out.println("用户线程结束！");
    }
}

注意点：设置守护线程应该在线程启动之前。

7.线程的生命周期

官方文档显示：Java线程的生命周期是6个。

  1. new：尚未启动的线程
  2. runnable：运行
    • ready：就绪，一切就绪，只待cpu
    • running：运行，cpu正在执行中
    • 使用yield方法，可以从运行->就绪，可能不会成功，因为并没有跳出运行区
  3. blocked：阻塞，排队
    • 等待锁到达同步区
    • 获得锁到达就绪状态
  4. waiting：等待
    • wait，join，LockSupport.park()到达等待状态
    • notify，notifyAll，LockSupport.unpark()到达就绪状态
  5. time waiting：超时等待
    • sleep，wait，join，LockSupport.parkNanos()，LockSupport.parkUntill()进入超时等待状态
    • 时间结束到达就绪状态
  6. terminated：终止
public class ThreadState extends Thread{

    @Override
    public void run() {
        while (true){
            System.out.println(Thread.currentThread().getName()+"运行中！");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException interruptedException) {
                System.out.println(Thread.currentThread().getName()+"休眠中！");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadState threadState = new ThreadState();
        System.out.println(threadState.getName()+"当前状态是："+threadState.getState());
        threadState.start();

        while (State.TERMINATED != threadState.getState()){
            System.out.println(threadState.getName()+"当前状态是："+threadState.getState());
            Thread.sleep(1000);
        }
    }
}

8.线程同步机制

使用同步机制解决买票的超卖问题。

线程同步机制

在多线程中，一些数据不允许被多个线程同时操作，此时就可以使用线程同步机制保证在任何时刻只能有一个线程操作该数据。

线程同步：操作数据时，一次只能由一个线程操作。

形象比喻：

​ {

​ 数据：一个单间厕所

​ 同步：一次只能进入一个人上厕所，其它人在门外等待

​ }

同步方法

  1. 同步代码块：synchronized(对象){}
  2. public synchronized void method(){}
public class SellTicket01 extends Thread{

    private static int tickets = 100;

    private static boolean loop = true;

    @Override
    public void run() {
        while (loop){
            sell();
        }
    }

    public synchronized void sell(){
        if (tickets <= 0) {
            System.out.println("售票结束，由" + Thread.currentThread().getName() + "结束");
            loop = false;
            return;
        } else {
            System.out.println("窗口" + Thread.currentThread().getName() + "售票成功，剩余票数：" + --tickets);
            try {
                Thread.sleep(50);
            } catch (InterruptedException interruptedException) {
                interruptedException.printStackTrace();
            }
        }

    }

    public static void main(String[] args) {
        new SellTicket01().start();//开启线程1
        new SellTicket01().start();//开启线程2
        new SellTicket01().start();//开启线程3
    }
}

注意点：票数减1时，最好直接使用自减，耗时小，测试更加精确。

public class SellTickets02 implements Runnable{

    private  int tickets = 100;

    @Override
    public void run() {
        while (true){
           synchronized (this){
               if(tickets <= 0) {
                   System.out.println("售票结束，由"+Thread.currentThread().getName()+"结束");
                   break;
               }else {
                   System.out.println("窗口"+Thread.currentThread().getName()+"售票成功，剩余票数："+--tickets);
               }
           }
        }
    }

    public static void main(String[] args) {
        SellTickets02 target = new SellTickets02();

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

同步方法的局限性

程序的执行效率降低。

同步方法的锁

非静态方法的锁：this，或其它唯一标识对象

静态方法的锁：类本身 类.class

同步的原则

  1. 尽可能使用同步代码块
  2. 多个线程的锁必须是同一个
  3. 划定公用资源，即为公共区域

9.死锁

public class QuickStart extends Thread{
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();
    private boolean flag;

    public QuickStart(boolean flag){
        this.flag = flag;
    }

    @Override
    public void run() {
        if(flag){
            synchronized (lock1){
                System.out.println("进入A");
                synchronized (lock2){
                    System.out.println("进入B");
                }
            }
        }else {
            synchronized (lock2){
                System.out.println("进入C");
                synchronized (lock1){
                    System.out.println("进入D");
                }
            }
        }
    }

    public static void main(String[] args) {
        QuickStart t = new QuickStart(true);
        QuickStart f = new QuickStart(false);

        t.start();
        f.start();

        while (t.getState() != State.TERMINATED){
            System.out.println(t.getState());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException interruptedException) {
                interruptedException.printStackTrace();
            }
        }

        while (f.getState() != State.TERMINATED){
            System.out.println(f.getState());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException interruptedException) {
                interruptedException.printStackTrace();
            }
        }
    }
}

10.释放锁

  1. 线程的同步方法执行结束。
  2. 线程在同步代码块，同步方法中遇到break、return。
  3. 线程在同步代码块发生异常。
  4. 同步方法中执行了wait方法，当前线程暂停并释放锁。

11.不释放锁

  1. sleep、yield
  2. suspend
HuiEr_h
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java基础——多线程详解！！！！
qq_52519008的博客
10-04 4793
就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只执行一个代码，因为切换得很快，所以就有同时执行的错觉。程序、进程和线程的大家可以通过百度搜索得知，在这里我就不多阐述。
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6279
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
Java多线程（超详细！）
热门推荐
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
线程基础
没闲的小孩多酱
04-14 150
除了进程之外，线程是一个十分重要的概念，特别是随着CPU频率增长开始出现停滞，而开始往多核方向发展，多线程，作为实现软件的并发执行的一个重要方法，有着越来越重要的地位。 一、什么是线程 线程（Thread），有时也叫轻量级进程（LWP），是程序执行流和CPU调度的最小单元。一个标准的线程由线程ID，当前指令指针（PC），寄存器集合和堆栈组成。通常意义上讲，一个进程由多个线程组成，各个线程之间共...
java线程基础
12-21
Java线程基础是Java编程中不可或缺的一部分，尤其在开发高并发和实时响应的应用时更为重要。线程允许程序同时执行多个任务，提高了程序的效率和响应速度。 **应用程序与进程** 应用程序是用户可以执行的软件实例，...
多线程基础与基于多线程的简单聊天室
06-24
本压缩包“多线程基础与基于多线程的简单聊天室”提供了对多线程技术的实践理解和二次开发的基础。以下是关于这个主题的详细知识点： 1. **多线程的概念**：多线程是指在一个程序中同时执行多个不同的线程，每个...
java并发编程：线程基础
08-09
Java并发编程中的线程基础是理解多线程编程的关键，它涵盖了从线程的创建到管理，再到线程间通信的全过程。多线程编程在处理高性能和高响应性的应用程序时至关重要，因为它允许程序在单个进程中同时执行多个任务，...
多线程测试!!!!!!!!
08-25
其中，`Thread`类是创建和管理线程的基础。我们可以创建`Thread`对象，并传入一个委托（通常是一个方法）作为线程执行的入口点。例如： ```csharp Thread thread = new Thread(new ThreadStart(YourMethod)); ...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 591
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 8138
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
操作系统原子操作
zzt_is_me的博客
08-28 5448
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
基于Java+Springboot+Vue+elememt宠物用品商城系统设计实现
最新发布
央顺科技官方博客
08-31 800
随着信息技术的不断发展，我们现在已经步入了信息化的时代了，而信息时代的代表便是网络技术的日渐成熟，而现在网络已经和我们的生活紧密的联系起来了，我们不敢想象没有网络我们的生活会像怎么样，也许就像食物中没有调料现在的生活离开了网络会变得索然无味。通过网络我们可以足不出户的做许多事情，例如工作、娱乐、学习，交友和购物等等许多我们数之不尽的事情，而就是因为网络我们的生活变得多姿多彩，或许有时甚至帮我们省下不少的时间和给予了我们更多的机遇。宠物网上商城对我们来说就有这些意义。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 508
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
spring-data-redis中RedisRepository仓储
OceanSky的专栏
08-27 436
Id@RedisHash注解的value属性和@Id注解指定键值的命名空间，组合成user:id；@RedisHash的属性timeToLive属性指定键值的超时时间。CrudRepository接口中默认定义实现了save、saveAll、findById、existsById、findAll、findAllById、count、deleteById、delete、deleteAllById、deleteAll等方法，基本满足了对redis操作的需求；如果有特殊需求可以自定义实现。
死锁及其产生条件
秋夫人
08-26 2481
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
优秀的开源项目
猪猪
08-28 533
目录热key多线程并行秒级百G级日志工具ES操作工具消息推送平台HTTP 客户端业务层的分布式限流组件企业级微服务解决方案hotkey: 京东App后台中间件，毫秒级探测热点数据，毫秒级推送至服务器集群内存，大幅降低热key对数据层查询压力asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各线程的执行顺序，带全链路执行结果回调。多线程编排一站式解决方案。来自于京东主App后台。asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各
JVM 内存参数
iOS逆向与安全
08-29 1441
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值