JAVA基础：多线程 （学习笔记）

猫爪笔记2024-10-27 9:55

多线程

一，什么是线程？

  • 程序：为完成特定任务、用某种语言编写的一组指令的集合,是一段静态的代码
  • 进程：程序的一次执行过程。

正在运行的一个程序，进程作为资源分配的单位，在内存中会为每个进程分配不同的内存区域。 （进程是动态的）是一个动的过程 ，进程的生命周期 : 有它自身的产生、存在和消亡的过程

  • 线程：是进程的进一步细化， 是一个程序内部的一条执行路径。

若一个进程同一时间并行执行多个线程，就是支持多线程的。

1.并行和并发

  • 并行：多个CPU同时执行多个任务
  • 并发：一个CPU"同时"执行多个任务（采用时间片切换）

二，创建线程的三种方式

1，继承Thread类

  1. 这个run方法不能直接调用，直接调用就会被当做一个普通方法，要用 . start() ，启动线程。
  2. 开辟道路的代码必须在前面！！
入门例子
java 复制代码 
//运行的类
public static void main(String[] args) {

   /*   DomeThread dt = new DomeThread();
        dt.start();*/

        new DomeThread().start();//开了一条新的路

        for (int i = 0; i < 100; i++) {
            System.out.println("main()" + i);
        }

    }//穿插运行
}
================================================================================
//准备
public class DomeThread extends Thread {//继承线程类  重写run()

    @Override
    public void run() {//另外一条道的执行代码
        show();
    }

    public void show() {
        for (int i = 0; i < 100; i++) {
            System.out.println("DomeThread_show()" + i);
        }
    }
}
三个窗口售卖火车票----三种方式的例题，也是线程安全问题的例题
java 复制代码 
//运行
 /**
     * 用继承方式的并行售票
     *
     * @param args
     */

    public static void main2(String[] args) {//main方法---主线程
        //假设有三个窗口同时买票
        //没有构造方法命名会报错
        TicketThread tt1 = new TicketThread("窗口1");//命名方法1
        TicketThread tt2 = new TicketThread();
        tt2.setName("窗口2");//命名方法2
        TicketThread tt3 = new TicketThread("窗口3");
        tt1.start();
        tt2.start();
        tt3.start();

    }
===========================================================================================
//准备

public class TicketThread extends Thread{


    static int count=10;//静态--有一个对象对他进行改变，其他对象再使用时就是修改过的

    @Override
    public void run() {
        while (count>0) {
            count--;
            System.out.println(this.getName()+"卖出一张票，还剩"+count+"张");
        }
    }

    public TicketThread() {
    }

    public TicketThread(String name) {
        super(name);
    }
}
缺点：
  1. 没有返回值
  2. 不能抛出异常

接 三，1------同步代码块 （重写 run() ）

java 复制代码 
 @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            synchronized (TicketThread.class) {//同步代码块    同步关键字（锁子）
                if (count > 0) {
                    count--;
                    System.out.println(this.getName() + "卖出一张票，还剩" + count + "张");
                }
            }
        }
    }
//TicketThread.class  或者 this.getClass

2，实现Runnable接口

Thread类实现了Runnable接口

java 复制代码 
//运行 
 public static void main3(String[] args) {
        TicketRunnable tr = new TicketRunnable();
        Thread thread1 = new Thread(tr, "窗口1");
        Thread thread2 = new Thread(tr, "窗口2");
        Thread thread3 = new Thread(tr, "窗口2");
        thread1.start();
        thread2.start();
        thread3.start();
    }

============================================================================
//准备

public class TicketRunnable implements Runnable {
    int count = 10;


    @Override
    public void run() {
        while (count > 0) {
            count--;
            System.out.println(Thread.currentThread().getName() + "卖出一张票，还剩" + count + "张");
        }//Thread.currentThread().getName()---获得正在运行的线程的名字
    }

}
缺点
  1. 没有返回值
  2. 不能抛出异常

接 三，2----- 同步方法 （重写run() , 新增一个synchronized同步方法）

java 复制代码 
package thread;

public class TicketRunnable implements Runnable {
    int count = 10;


    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            buyTicket();
        }
    }
    public synchronized  void buyTicket(){//默认锁 this对象
        if (count > 0) {
            count--;
            System.out.println(Thread.currentThread().getName()+ "卖出一张票，还剩" + count + "张");
        }
    }
}

补充---休眠

java 复制代码 
 @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            buyTicket();

           //休眠，如果运行时一直是一个窗口，可以用这个
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }

接 三，3----Lock锁 （重写run() , 定义锁）

java 复制代码 
package thread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TicketRunnable implements Runnable {
    int count = 10;

    Lock lock=new ReentrantLock(); //多态  接口=实现类  可以使用不同的实现类
    @Override
    public void run() {

        for (int i = 0; i <= 100; i++) {
            lock.lock();
            try {
                if (count > 0) {
                    count--;
                    System.out.println(Thread.currentThread().getName()+ "卖出一张票，还剩" + count + "张");
                }
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }finally {
                lock.unlock();
            }


        }
    }
  
}

3，实现Callable接口

好处：
  1. 有返回值
  2. 能抛出异常
缺点：
  1. 线程创建比较麻烦
java 复制代码 
//运行 
/**
     * 实现Callable接口的并行售票
     */
 public static void main(String[] args) {
        TicketCall tc=new TicketCall();

        FutureTask ft=new FutureTask(tc);
        Thread t1=new Thread(ft,"窗口1");//存在默认名，如果你不命名，程序会显示Thread-0
        FutureTask ft1=new FutureTask(tc);
        Thread t2=new Thread(ft1,"窗口2");
        FutureTask ft2=new FutureTask(tc);
        Thread t3=new Thread(ft2,"窗口3");
        t1.start();
        t2.start();
        t3.start();

//获取线程得到的返回值：
        Object obj = ft.get();
        System.out.println(obj);

    }
======================================================================
//准备

package thread;

import java.util.concurrent.Callable;

public class TicketCall implements Callable {

    int count = 10;

    @Override
    public Object call() throws Exception {
        while (count > 0) {
            count--;
            System.out.println(Thread.currentThread().getName() + "卖出一张票，还剩" + count + "张");
        }//Thread.currentThread().getName()---获得正在运行的线程的名字
        return null;
    }
}
补充

  1. 实现Callable接口，可以不带泛型，如果不带泛型，那么call方式的返回值就是Object类型

    java 复制代码 
    public class TicketCall implements Callable<Integer> {

  2. 如果带泛型，那么call的返回值就是泛型对应的类型

  3. 从call方法看到：方法有返回值，可以跑出异常

4，线程的生命周期

四，线程的常用方法

  • start() : 启动当前线程，表面上调用start方法，实际在调用线程里面的run方法 【例题中有】
  • run() : 线程类 继承 Thread类 或者 实现Runnable接口的时候，都要重新实现这个run方法，run方法里面是线程要执行的内容 【例题中有】
  • currentThread :Thread类中一个静态方法：获取当前正在执行的线程 【Runnable例中】
  • setName : 设置线程名字 【Thread例中】
  • getName 读取线程名字 【例题中有】
  • 通过调用**interrupt()**方法来中断其阻塞状态
  • 设置优先级
  1. 同优先级别的线程，采取的策略就是先到先服务，使用时间片策略
  2. 如果优先级别高，被CPU调度的概率就高
  3. 级别：1-10 默认的级别为5
  4. 线程的优先级是在创建线程时设置的，在创建线程后的任何时候都可以重新设置
java 复制代码 
//运行
class Test{
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //创建两个子线程，让这两个子线程争抢资源：
        TestThread01 t1 = new TestThread01();
        t1.setPriority(10);//优先级别高
        t1.start();
        TestThread02 t2 = new TestThread02();
        t2.setPriority(1);//优先级别低
        t2.start();
    }
}
=====================================================================
//准备
public class TestThread01 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }
}
-----------------------------------------------------------
class TestThread02 extends Thread{
    @Override
    public void run() {
        for (int i = 20; i <= 30 ; i++) {
            System.out.println(i);
        }
    }
}
  • join() : 当一个线程调用了join方法，这个线程就会先被执行，它执行结束以后才可以去执行其余的线程。 注意：必须先start，再join才有效。
java 复制代码 
//测试
class Test{
    //这是main方法，程序的入口
    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 100 ; i++) {
            System.out.println("main-----"+i);
            if(i == 6){
                //创建子线程：
                TestThread tt = new TestThread("子线程");
                tt.start();
                tt.join();//"半路杀出个程咬金"
            }
        }
    }
}
====================================================
//准备
public class TestThread extends Thread {
    public TestThread(String name){
        super(name);
    }
    @Override
    public void run() {
        for (int i = 1; i <= 10 ; i++) {
            System.out.println(this.getName()+"----"+i);
        }
    }
}
  • sleep : 人为的制造阻塞事件
java 复制代码 
public class Test01 {
    //这是main方法，程序的入口
    public static void main(String[] args) {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("00000000000000");
    }
}

案例：完成秒表功能

java 复制代码 
public class Test02 {
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //2.定义一个时间格式：
        DateFormat df = new SimpleDateFormat("HH:mm:ss");
        while(true){
            //1.获取当前时间：
            Date d = new Date();
            //3.按照上面定义的格式将Date类型转为指定格式的字符串：
            System.out.println(df.format(d));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
  • setDaemon设置伴随线程
  1. 将子线程设置为主线程的伴随线程，主线程停止的时候，子线程也不要继续执行了
  2. 案例：皇上 --》驾崩 ---》妃子陪葬 【将指定的线程设置成后台线程】
java 复制代码 
//运行
class Test{
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //创建并启动子线程：
        TestThread tt = new TestThread();
        tt.setDaemon(true);//设置伴随线程  注意：先设置，再启动
        tt.start();
        //主线程中还要输出1-10的数字：
        for (int i = 1; i <= 10 ; i++) {
            System.out.println("main---"+i);
        }
    }
}
=========================================================
//准备
public class TestThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 1000 ; i++) {
            System.out.println("子线程----"+i);
        }
    }
}
  • yield方法----的作用是让当前线程放弃CPU时间片，进入和可运行状态，与其他等待的可运行状态线程竞争CPU时间片。它并不会直接提升线程的优先级，而是让当前线程主动放弃执行权，从而让其他线程有机会运行‌

五，线程安全问题

1，同步代码块 //代码见 上面 --接 三，1

java 复制代码 
 synchronized (TicketThread.class)
总结一

----认识同步监视器（锁子） ----- synchronized(同步监视器){ }

  1. 必须是引用数据类型，不能是基本数据类型
  2. 也可以创建一个专门的同步监视器，没有任何业务含义
  3. 一般使用共享资源做同步监视器即可
  4. 在同步代码块中不能改变同步监视器对象的引用
  5. 尽量不要String和包装类Integer做同步监视器
  6. 建议使用final修饰同步监视器
总结二

----同步代码块的执行过程

  1. 第一个线程来到同步代码块，发现同步监视器open状态，需要close,然后执行其中的代码。
  2. 第一个线程执行过程中，发生了线程切换（阻塞 就绪），第一个线程失去了cpu，但是没有开锁open。
  3. 第二个线程获取了cpu，来到了同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态。
  4. 第一个线程再次获取CPU,接着执行后续的代码；同步代码块执行完毕，释放锁open。
  5. 第二个线程也再次获取cpu，来到了同步代码块，发现同步监视器open状态，拿到锁并且上锁，由阻塞状态进入就绪状态，再进入运行状态，重复第一个线程的处理过程（加锁）。
  6. 强调：同步代码块中能发生CPU的切换吗？能！！！ 但是后续的被执行的线程也无法执行同步代码块（因为锁仍旧close） 。
总结三
  1. 多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块
  2. 多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块， 但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块

2，同步方法 //代码见 上面 --接 三，2

java 复制代码 
 public synchronized  void buyTicket(){  }
总结一
  1. 多线程在争抢资源，就要实现线程的同步（就要进行加锁，并且这个锁必须是共享的，必须是唯一的。
  2. 咱们的锁一般都是引用数据类型的。
  3. 目的：解决了线程安全问题。
总结二

--- 关于同步方法

  1. 不要将run()定义为同步方法
  2. 非静态同步方法的同步监视器是this
  3. 静态同步方法的同步监视器是 类名.class 字节码信息对象
  4. 同步代码块的效率要高于同步方法 ------------原因：同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是却是方法的内部
  5. 同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块

3，Lock锁 //代码见 上面 --接 三，3

java 复制代码 
 Lock lock=new ReentrantLock(); //多态  接口=实现类  可以使用不同的实现类
    。。。。。。。。
 lock.lock();//打开锁
    。。。。。。。
 lock.unlock();//关闭锁：--->即使有异常，这个锁也可以得到释放
Lock和synchronized的区别
  1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁
  2. Lock只有代码块锁，synchronized有代码块锁和方法锁
  3. .使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
优先使用顺序：
  1. Lock----同步代码块（已经进入了方法体，分配了相应资源）----同步方法（在方法体之外）
相关推荐
feilieren13 分钟前
leetcode - 684. 冗余连接
java·开发语言·算法
东林知识库22 分钟前
2024年10月HarmonyOS应用开发者基础认证全新题库
学习·华为·harmonyos
The Future is mine23 分钟前
Java根据word模板导出数据
java·开发语言
随便取个六字32 分钟前
C++学习：类和对象（二）
c++·学习
一颗甜苞谷36 分钟前
开源一款前后端分离的企业级网站内容管理系统，支持站群管理、多平台静态化，多语言、全文检索的源码
java·开发语言·开源
星夜孤帆37 分钟前
Java面试题集锦
java·开发语言
论迹44 分钟前
【Java】-- 接口
java·开发语言
OMGmyhair1 小时前
【 C++ 】C++11的初步学习
开发语言·c++·学习
呵呵哒(￣▽￣)"1 小时前
尚硅谷-react教程-求和案例-优化3-整合UI组件和容器组件-总结优化-笔记
前端·笔记·react.js
dawn1912282 小时前
Java 中的正则表达式详解
java·开发语言·算法·正则表达式·1024程序员节
热门推荐
01Windows10安装PCL1.14.0及点云配准02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）03【经验分享】Ubuntu22.04安装微信(linux官方版)04前端vue3实现本地及在线文件预览（含pdf/txt/mp3/mp4/docx/xlsx/pptx）05制冷毛细管的计算方法介绍06RAG 实践- Ollama+RagFlow 部署本地知识库07ECharts 地图实战分析：实现一个完整的地图下钻功能08Coze扣子平台完整体验和实践（附国内和国际版对比）09苍穹外卖面试总结10基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测