线程基础！

已于 2023-01-04 18:13:32 修改
阅读量277 收藏
点赞数 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
关注
Java多线程基础-使用多线程
cgmx551的博客
03-08 2013
线程:程序执行流的最小单元【可以理解为：进程中独立运行的子任务】。 多线程优点:最大限度的利用CPU的空闲时间来处理其他任务。 |-目录 |  创建线程 |  线程运行结果与执行顺序无关 |  线程实例变量与安全问题 |  停止线程 |  线程优先级 |  守护线程 |  线程让步 -创建线程 线程的创建方式:  1.继承Thread类 public class ThreadCreateDemo1 { public static void main(String[] args) { ...
java线程基础
12-21
Java线程基础是Java编程中不可或缺的一部分，尤其在开发高并发和实时响应的应用时更为重要。线程允许程序同时执行多个任务，提高了程序的效率和响应速度。 **应用程序与进程** 应用程序是用户可以执行的软件实例，...
Java基础——多线程详解！！！！
qq_52519008的博客
10-04 4883
就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只执行一个代码，因为切换得很快，所以就有同时执行的错觉。程序、进程和线程的大家可以通过百度搜索得知，在这里我就不多阐述。
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6332
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
JAVA多线程基础
weixin_47600732的博客
03-19 4156
JAVA多线程基础 1.什么是并发原理？ 多线程：多线程允许我们“同时”执行多段代码。 线程是并发运行的，线程调度会统一规划CPU时间，将CPU的时间划分为若干片段，然后尽可能的均匀分配给所要并发运行的线程，每个线程在获取CPU时间片段后CPU就会运行它的任务，当时间片段用完后，Cpu会离开并执行获取到CPu时间片的线程，所以，所有线程并非真正的“同时”运行着代码，而是走走停停，这种微观上走走停停，在宏观上感觉是同步进行的现象称为“并发运行”。 2.创建线程Thread 1. 方式一：继承Thread并重写
Java 基础 —— 线程安全
IT__learning的博客
10-31 9031
一、线程安全问题 线程安全 当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的 一个程序在运行起来的时候会转换成进程，通常含有多个线程。通常情况下，一个进程中的比较耗时的操作（如长循环、文件上传下载、网络资源获取等），往往会采用多线程来解决。又比如实际生活中，银行取钱问题、火车票多个售票窗口的问题，通常会涉及到并发的问题，从而需要多线程的技术。 当进程中
javase-线程基础
登峰小蚁
08-06 2442
资源贴： wait和notify与notifyAll的用法：https://blog.csdn.net/jianiuqi/article/details/53448849 synchronized中的static方法和普通方法：https://blog.csdn.net/virgoboy2004/article/details/7585182 线程池的用法：http://cuisuqiang.it...
线程的基础
蹊源的奇思妙想的博客
06-22 1954
线程的基础 进程与线程 1.进程可以理解软件的一次执行结果（进程是资源分配合基本单位） 2.线程可以理解为进程的一个片段（处理器调度的基本单位） 3.同一进程中线程共享资源（相同的栈空间） 4.进程和线程都可以并发执行 线程的生命周期 单个线程的周期：新建、就绪、运行、死亡、阻塞 阻塞：就绪的线程使用锁或者标记成临界区会转变成阻塞状态 就绪：线程调用start()方法，是线程状态从新建状态转变成...
C#基础-多线程
热门推荐
jjailsa的博客
08-15 1万+
闲得蛋疼，整理一下C#线程的基础概念和常规用法。
多线程基础
目目沐沐
03-01 1万+
多线程基础
线程基础知识
持续学习，持续更新
08-04 4265
什么是进程，什么是线程。创建线程的方式。之前的硬件，只有一个CPU之前的OS，只运行一个进程随着多核CPU的出现，人们开始追求对CPU效率的极致压榨多线程的程序随之诞生，但随之诞生的，也是非常难以应对的各种并发bug。............
多线程基础与基于多线程的简单聊天室
06-24
本压缩包“多线程基础与基于多线程的简单聊天室”提供了对多线程技术的实践理解和二次开发的基础。以下是关于这个主题的详细知识点： 1. **多线程的概念**：多线程是指在一个程序中同时执行多个不同的线程，每个...
多线程测试!!!!!!!!
08-25
其中，`Thread`类是创建和管理线程的基础。我们可以创建`Thread`对象，并传入一个委托（通常是一个方法）作为线程执行的入口点。例如： ```csharp Thread thread = new Thread(new ThreadStart(YourMethod)); ...
线程基础.rar
09-22
VC++6.0编写程序,供参考学习多进程多线程程序的开发
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 637
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1125
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 780
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 464
默认对常规Session的理解和使用，如何使用Set-Cookie。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值