首页 > 编程语言 >【Java学习笔记】多线程基础

【Java学习笔记】多线程基础

时间：2024-12-20 10:31:52浏览次数：9  
标签：Runnable run Thread void 笔记 线程 Java 多线程 public

并行：同一时刻，多任务同时进行
多任务分别进行

一、线程相关概念

1.程序

是为完成特定任务、用某种语言编写的一组指令的集合。
简单的说:就是我们写的代码

2.进程

（1）进程指的就是运行中的程序，比如我们使用QQ,就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统就会为迅雷分配新的内存空间。

（2）进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态过程：有它自身的产生、存在和消亡的过程

3.线程

（1）线程由进程创建的，是进程的一个实体

（2）一个进程可以拥有多个线程
（例：正在下载的任务可以下载多个文件）

4.其他相关概念

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

（2）多线程：同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件

（3）并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。一个任务就是一个进程
（同一时刻，多任务同时进行）
在这里插入图片描述

（4）并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。
在这里插入图片描述

二、线程使用

1.创建线程的两种方式

在这里插入图片描述

1.1 继承Thread类，重写run方法

说明：

  • Thread类中的run()是实现的Runnable接口run()，在run()方法中写上自己的业务逻辑，然后调用start()方法就可以启动这个线程，run()方法会被自动调用。
  • 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行。这时主线程和子线程是交替执行的。
  • 如果主线程在子线程之前结束，子线程也会正常执行并不会因为主线程的结束而结束
  • 子线程也可以启动自己的子线程

例：

package com.hspedu.threaduse;
/**
 * @author 韩顺平
 * @version 1.0
 * 演示通过继承 Thread 类创建线程
 */
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
    
      //创建 Cat 对象，可以当做线程使用
      Cat cat = new Cat();
      
      //老韩读源码
      /*
      (1)
      public synchronized void start() {
         start0();
      }
      (2)
      //start0() 是本地方法，是 JVM 调用, 底层是 c/c++实现
      //真正实现多线程的效果， 是 start0(), 而不是 run
      private native void start0();
      
    */
    
      cat.start();//启动线程-> 最终会执行 cat 的 run 方法
      
      //cat.run();//run 方法就是一个普通的方法, 没有真正的启动一个线程，就会把 run 方法执行完毕，才向下执行
      //说明: 当 main 线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
      //这时 主线程和子线程是交替执行.. 
      System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字 main
      for(int i = 0; i < 60; i++) {
         System.out.println("主线程 i=" + i);
         //让主线程休眠
         Thread.sleep(1000);
       }
   }
}

//老韩说明
//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run 方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的 run 方法
/*
      @Override
      public void run() {
           if (target != null) {
                target.run();
            }
       }
*/


class Cat extends Thread {

      int times = 0;
      @Override
      public void run() {//重写 run 方法，写上自己的业务逻辑
      
            while (true) {
              //该线程每隔 1 秒。在控制台输出 “喵喵, 我是小猫咪”
              System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());
              //休眠 1 秒 ctrl+alt+t
            try {
                 Thread.sleep(1000);
            } catch (InterruptedException e) {
                  e.printStackTrace();
            }
            if(times == 80) {
                  break;//当 times 到 80, 退出 while, 这时线程也就退出.. 
                  }
            }
     }
}
1.1.1为什么使用start()，而不直接调用方法
Cat cat = new Cat();
      
      //老韩读源码
      /*
      (1)
      public synchronized void start() {
         start0();
      }
      (2)
      //start0() 是本地方法，是 JVM 调用, 底层是 c/c++实现
      //真正实现多线程的效果， 是 start0(), 而不是 run
      private native void start0();
      
    */
    
      cat.start();//启动线程-> 最终会执行 cat 的 run 方法
      
      //cat.run();//run 方法就是一个普通的方法, 没有真正的启动一个线程，就会把 run 方法执行完毕，才向下执行

在这里插入图片描述

1.2 实现Runnable接口，实现run方法

说明：

  • java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时就不能通过继承Thread类方法来创建线程了。
  • java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程
  • 该方式不能通过直接调用start()来启动线程，需要创建Thread对象，再把实现了Runnable的对象放入Thread，通过Thread对象来调用start()方法

例子：

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //创建Thread对象，把 dog对象(实现Runnable),放入Thread
        Thread thread = new Thread(dog);
        thread.start();
    }
}
 
class Dog implements Runnable { //通过实现Runnable接口，开发线程
 
    int count = 0;
 
    @Override
    public void run() {
        while (true) {
            System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());
 
            //休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
            if (count == 10) {
                break;
            }
        }
    }
}

模拟了一个极简的Thread类

//线程代理类 , 模拟了一个极简的Thread类
class ThreadProxy implements Runnable {
    private Runnable target = null;//属性，类型是 Runnable
 
    @Override
    public void run() {
        if (target != null) {
            target.run();//动态绑定（运行类型）
        }
    }
 
    public ThreadProxy(Runnable target) {
        this.target = target;
    }
 
    public void start() {
        start0();//这个方法是真正实现多线程方法
    }
 
    public void start0() {
        run();
    }
}

1.3继承 Thread和实现 Runnable 的区别

  • 从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
  • 实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制。
    （建议使用Runnable接口）

2.线程终止退出

（1）当线程完成任务后，会自动退出。

（2）还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

例子：启动一个线程T，在主线程中通过控制变量值去停止线程

public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();
 
        //如果希望main线程去控制t1 线程的终止, 必须可以修改 loop
        //让t1 退出run方法，从而终止 t1线程 -> 通知方式
 
        //让主线程休眠 10 秒，再通知 t1线程退出
        System.out.println("main线程休眠10s...");
        Thread.sleep(10 * 1000);
        t1.setLoop(false);
    }
}
 
class T extends Thread {
    private int count = 0;
    //设置一个控制变量
    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {
 
            try {
                Thread.sleep(50);// 让当前线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中...." + (++count));
        }
 
    }
 
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

三、线程常用方法

1.第一组

在这里插入图片描述

1.1 细节

在这里插入图片描述

  • 线程优先级范围
    Thread类中有三个静态常量来表示优先级
    /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;//最小优先级
 
   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;//正常优先级
 
    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10//最大优先级

2 第二组

在这里插入图片描述

3.用户线程和守护线程

（1）用户线程：也叫工作线程，当线程的任务执行完结束

（2）守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

（3）常见的守护线程：垃圾回收机制

例子：将一个线程设置为守护线程

  thread.setDaemon(true);
  thread.start();//需要先设置，再启动

四、线程生命周期

1.线程的七种状态

JDK 中用 Thread.State 枚举表示了线程的几种状态
线程可以处于以下状态之一(可通过thread.getState()查看线程状态)：

  • NEW：new,尚未启动的线程处于此状态。

  • RUNNABLE：runnable可执行状态,在Java虚拟机中执行的线程处于此状态。
    （可细分为Ready准备执行状态和Running正在执行状态）

  • BLOCKED：blocked,被阻塞等待监视器锁定的线程处于此状态。

  • WAITING：waiting,正在等待另一个线程执行特定动作的线程处于此状态。

  • TIMED_WAITING：timed_waiting,正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。

  • TERMINATED：terminated己退出的线程处于此状态。

2.线程状态转换示意图

在这里插入图片描述

五、线程的同步

任何同一时刻，只允许一个线程访问并操作数据

1.线程同步机制

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

（2）也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作

2. 实现同步具体方法-synchronized

1.同步代码块

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

2.同步方法

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

六、互斥锁

1.基本介绍

（1）Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。

（2）每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。

（3）关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问

（4）同步的局限性：导致程序的执行效率要降低

（5）静态同步方法的锁为当前类本身

（6）非静态同步方法的锁可以是当前对象this,也可以是其他对象(但必须是同一个对象)

2. 注意事项

在这里插入图片描述
在这里插入图片描述

七、死锁

1.基本介绍

在这里插入图片描述

2.理解

当A线程拿到了B线程的所需要的锁，B线程拿到了A线程的所需要的锁，A线程必须把B线程的所需要的锁交给B，B才能执行，B线程必须把A线程的所需要的锁交给A，A才能执行，这样就会导致死锁

八、释放锁

1.会释放锁的操作

  1. 当前线程的同步方法、同步代码块执行结束。

    案例：上厕所，完事出来

  2. 当前线程在同步代码块、同步方法中遇到break、return。

    案例：没有正常的完事，经理叫他修改bug,不得已出来

  3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束。

    案例：没有正常的完事，发现忘带纸，不得已出来

  4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

    案例：没有正常完事，觉得需要酝酿下，所以出来等会再进去

2.不会释放锁的操作

  1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep0、Thread.yieldO方法暂停当前线程的执行，不会释放锁。

    案例：上厕所，太困了，在坑位上眯了一会

  2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用

标签：Runnable,run,Thread,void,笔记,线程,Java,多线程,public
From： https://blog.csdn.net/2401_88623584/article/details/144542288

相关文章

  • PAWNYABLE kernel userfaultfd 笔记
    感觉这个是比较古老（2020左右的）用法了，看看即可？概念userfaultfd可以类比成一个缺页异常的handler，如果handler可以处理很久，那可能更好达到竞争的效果工作流程参考KernelPwnSyscalluserfaultfdandSyscallsetxattr-Wings的博客户通过userfaultfd系统调用接收文件描......
  • java常见知识点
    工作中发现，很多同事，尤其是新同事，对一些基础知识点不熟悉，在此做梳理和总结，便于后期沟通。一、jvm预热https://www.cnblogs.com/crazymakercircle/p/17691632.html为什么要jvm预热？jvm即使编译，动态编译java字节码为优化后的机器码。第一波流量过来，触发即使编译，导致耗时过长，影响可......
  • java--代码段--String--构建字符串StringBuilder
    str="/u1D56B";StringBuilderbuilder=newStringBuilder();//首先构建一个空的字符串构建器charch=58;builder.append(ch);//当每次需要添加一部分内容时，就调用append方法。builder.append(str);StringcompletedString=builder.toString();//在需要构建字符串......
  • Java学习，数组中查找指定元素
    Java中查找数组中的指定元素是一个常见的操作。数组中查找指定的元素，并返索引：publicclassFindElementInArray{  publicstaticvoidmain(String[]args){    int[]numbers={10,20,30,40,50};    inttarget=30;    intindex......
  • Java学习，数组是否相等
    Java中判断两个数组是否相等，不是直接的事情，数组对象之间的 equals()方法，并不会逐个比较数组元素，是比较数组对象的引用是否相同（即它们是否指向内存中同一个位置）。要判断两个数组，是否包含相同的元素并且顺序也相同。判断两个整数数组是否相等publicclassArrayEqualityChecke......
  • （免费源码）计算机毕业设计必学必看 万套实战教程 java、python、php、node.js、c#、APP
    摘要随着我国经济迅速发展，人们对手机的需求越来越大，各种手机软件也都在被广泛应用，但是对于手机进行数据信息管理，对于手机的各种软件也是备受用户的喜爱，机房预约系统小程序被用户普遍使用，为方便用户能够可以随时进行机房预约系统小程序的数据信息管理，特开发了基于机房预约系统......
  • （免费源码）计算机毕业设计必学必看 万套实战教程 java、python、php、node.js、c#、APP
    摘 要随着科学技术的飞速发展，社会的方方面面、各行各业都在努力与现代的先进技术接轨，通过科技手段来提高自身的优势，校园商店当然也不能排除在外。校园商店是以实际运用为开发背景，运用软件工程原理和开发方法，采用Java技术构建的一个管理系统。整个开发过程首先对软件系统进行......
  • javase-17、API.数学相关
    一、Math类Math类提供了大量的静态方法来便于我们实现数学计算，如求绝对值、取最大或最小值等。https://doc.qzxdp.cn/jdk/17/zh/api/java.base/java/lang/Math.html所在模块：java.base所在包：java.langstaticdoubleabs(doublea)返回a值的绝对值其它重构方......
  • JAVA中的interface
    接口接口是比抽象类更抽象的一种结果或者类，通常使用interface来进行描述interface中不允许出现变量接口和接口之间是可以继承的（interface1exetendinterface2）抽象类（abstractclass）与接口（interface）的区别继承--只能继承一个类;可以继承多个interface字段--可以定义实例字段;不可......
  • JAVA中的访问修饰符
    private--同一类中可见;使用对象:变量，方法default(即默认，什么都不写)--在同一包中可见;使用对象:类，接口，变量，方法public--对所有类可见;使用对象:类，接口，变量，方法protected:对同一包内的类和所有子类可见;使用对象:变量，方法属性一般都是private方法一般都是publicUser类pa......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99