Java基础 10.8

最新推荐文章于 2025-12-02 21:20:38 发布
原创 最新推荐文章于 2025-12-02 21:20:38 发布 · 884 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

1.线程终止

基本说明

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

应用案例

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;
    }
}

2.线程常用方法

方法第一组

注意事项和细节

  1. start 底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程
  2. 线程优先级的范围
  3. interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程
  4. sleep：线程的静态方法，使当前线程休眠

应用案例

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试相关的方法
        T t = new T();
        t.setName("a");
        t.setPriority(Thread.MIN_PRIORITY);//1
        t.start();//启动子线程


        //主线程打印5 hi ,然后我就中断 子线程的休眠
        for(int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }

        System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());//1

        t.interrupt();//当执行到这里，就会中断 t线程的休眠.



    }
}

class T extends Thread { //自定义的线程类
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "  吃包子~~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
                Thread.sleep(20000);//20秒
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt 方法时，就会catch 一个 异常, 可以加入自己的业务代码
                //InterruptedException 是捕获到一个中断异常.
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
            }
        }
    }
}

方法第二组

应用案例

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {

        T2 t2 = new T2();
        t2.start();

        for(int i = 1; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程(小弟) 吃了 " + i  + " 包子");
            if(i == 5) {
                System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
                //join, 线程插队
                //t2.join();// 这里相当于让t2 线程先执行完毕
                Thread.yield();//礼让，不一定成功..
                System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
            }

        }
    }
}

class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程(老大) 吃了 " + i +  " 包子");
        }
    }
}

用户线程和守护线程

  • 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
  • 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
  • 常见的守护线程：垃圾回收机制

应用案例

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我们希望当main线程结束后，子线程自动结束
        //,只需将子线程设为守护线程即可
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();

        for( int i = 1; i <= 10; i++) {//main线程
            System.out.println("宝强在辛苦的工作...");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread {
    public void run() {
        for (; ; ) {//无限循环
            try {
                Thread.sleep(1000);//休眠1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("马蓉和宋喆快乐聊天，哈哈哈~~~");
        }
    }
}

3.线程生命周期

线程状态转换图

程序查看线程状态

public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + " 状态 " + t.getState());
        t.start();

        while (Thread.State.TERMINATED != t.getState()) {
            System.out.println(t.getName() + " 状态 " + t.getState());
            Thread.sleep(500);
        }

        System.out.println(t.getName() + " 状态 " + t.getState());

    }
}

class T extends Thread {
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 10; i++) {
                System.out.println("hi " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

4.线程的同步

 Synchronized

线程同步机制

  1. 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性
  2. 也可以这里理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作

同步具体方法

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

2. synchronized还可以放在方法声明中,表示整个方法-为同步方法
public synchronized void m (String name){
//需要被同步的代码
}

5.互斥锁

基本介绍

  1. Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性
  2. 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象
  3. 关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
  4. 同步的局限性：导致程序的执行效率要降低
  5. 同步方法(非静态的)的锁可以是this，也可以是其他对象(要求是同一个对象)
  6. 同步方法(静态的)的锁为当前类本身

案例

public class SellTicket {
    public static void main(String[] args) {

        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        //这里我们会出现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程


        System.out.println("===使用实现接口方式来售票=====");
        SellTicket02 sellTicket02 = new SellTicket02();

        new Thread(sellTicket02).start();//第1个线程-窗口
        new Thread(sellTicket02).start();//第2个线程-窗口
        new Thread(sellTicket02).start();//第3个线程-窗口


    }
}


//使用Thread方式

class SellTicket01 extends Thread {

    private static int ticketNum = 100;//让多个线程共享 ticketNum

    @Override
    public void run() {
        while (true) {

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));

        }
    }
}



//实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum

    @Override
    public void run() {
        while (true) {

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2

        }
    }
}

注意事项和细节

  • 同步方法如果没有使用static修饰：默认锁对象为this
  • 如果方法使用static修饰，默认锁对象：当前类.class

实现的落地步骤

  1. 需要先分析上锁的代码
  2. 选择同步代码块或同步方法
  3. 要求多个线程的锁对象为同一个即可

6.线程的死锁

基本介绍

多个线程都占用了对方锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁发生

案例

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() {

        //下面业务逻辑的分析
        //1. 如果flag 为 T, 线程A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
        //2. 如果线程A 得不到 o2 对象锁，就会Blocked
        //3. 如果flag 为 F, 线程B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
        //4. 如果线程B 得不到 o1 对象锁，就会Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁, 下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入1");
                synchronized (o2) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入2");
                }
                
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入3");
                synchronized (o1) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入4");
                }
            }
        }
    }
}

7.释放锁

下列操作释放锁

  1. 当前线程的同步方法、同步代码块执行结束 案例：上厕所,完事出来
  2. 当前线程在同步代码块、同步方法中遇到break、return 案例：没有正常的完事，经理叫他修改bug，不得已出来
  3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束 案例：没有正常的完事，发现忘带纸，不得已出来
  4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。 案例：没有正常完事，觉得需要酝酿下，所以出来等会再进去

下列操作不会释放锁

  1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁 案例：上厕所，太困了，在坑位上眯了一会
  2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用
Java基础
nicenice_的博客
09-06 1659
当类或是方法的内容不能够很确定时，定义“抽象类” “抽象方法”。子类继承，重写。然后才能用子类创建对象。注：abstract 和 final 两个关键字不能一起使用。try:ex:会报错，没有打印出j，因为错在第二行，直接终端运行。输出：使用try：即使有错也不会终端运行了，输出：因为在try中没有处理问题，所以会抛出错误但没处理，可以在try中直接给出解决方法。首先：自定义一个登陆异常，又分好几种情况，在这里是账号异常和密码异常，所以又定义了两个子类。
Java基础语法规范
实践出真理，接毕设/课设项目开发指导
05-31 381
菜鸟教程Java基础学习。
JAVA基础
qq_37950031的博客
04-25 716
JDK的安装目录 bin 该路径下存放了JDK的各种工具命令，javac和java就放在这个目录 conf 该路径下存放了JDK的相关配置文件 include 该路径下存放了一些平台特定的头文件 jmods 该路径存放了JDK的各种模块 legal 该路径下存放了JDK各模块的授权文档 lib 该路径下存放了JDK工具的一些补充JAR包 常用DOS命令 打开命令提示符窗口 ①按下min+R ②输入cmd ③按下回车键 盘符名称：盘符切换。E：回车，表示切换到E盘。 dir：查看当前
Java基础知识复习
m0_59239420的博客
02-21 390
运算符： - 算术运算符 + - * / - 赋值运算符 += -= *= /= %= 取余 - 比较运算符（关系运算符） >= <= > < - 逻辑运算符 & && 1. 两边都是true，结果是true 2. 一边是false，结果是false. 短路特点：符号左边是false，右边不再运 || 1. 两边都是false，结果是false<br /> 2. ...
Java基础API
ling_hun_pang_zi的博客
12-26 496
Java基础API 目录： Scanner类 匿名对象 Random类 ArrayList集合 String类 static静态 Arrays工具类 Math类 1.Scanner类 使用步骤： 1、导包：import java.util.Scanner; 2、创建(System.in代表从键盘输入) Scanner sc = new Scanner(System.in); 3、使用 in...
JAVA 基础知识梳理
my_45885798的博客
03-10 766
JAVA基础 java 特性 封装： 封装指的是属性私有化，根据需要提供setter和getter方法来访问属性。即隐藏具体属性和实现细节，仅对外开放接口，控制程序中属性的访问级别。 目的：增强安全性和简化编程，使用者不必在意具体实现细节，而只是通过外部接口即可访问类的成员。 继承： 继承是指将多个相同的属性和方法提取出来，新建一个父类。 Java中一个类只能继承一个父类，且只能继承访问权限非private的属性和方法。 子类可以重写父类中的方法，命名与父类中同名的属性。 目的：代码复用。 多态：
Java基础总结
m0_48817685的博客
09-21 1247
t为空格\n为换行需在引号内使用​输入输出语句的首字母都需大写println为换行输出，print为不换行输出//为单行注释/**为多行注释 */​。
java基础应用
qq_45009586的博客
07-24 882
​ 数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。​ 数据类型[] 数组名int[] arr;char[] arr;​ 数组动态初始化就是只给定数组的长度，由系统给出默认初始化值​ 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。​ 这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。​ 内存是计算机中的重要原件，临时存储区域，作用是运行程序。​ 我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。
java基础-Math类
m0_61285646的博客
05-01 2402
Math继承了Object类。
Java软件开发实战 Java基础与案例开发详解 10-9 练习题 共5页.pdf
07-07
### 一、Java基础概念 #### 1.1 什么是Java？ Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems公司在1995年发布。它旨在简化C++语言的复杂性，并增加对网络计算的支持。 #### 1.2 认识Java语言 ...
Java软件开发实战 Java基础与案例开发详解 10-1 java异常处理 共7页.pdf
07-07
以上是对Java异常处理核心知识点的详细总结，涵盖了异常的基础概念、异常处理的主要机制以及如何使用这些机制来编写健壮可靠的Java程序。通过学习这些内容，开发者可以更好地理解和掌握Java异常处理机制，从而提高...
Java软件开发实战 Java基础与案例开发详解 14-8 练习题 共6页.pdf
07-07
Java SE是最基础的部分，提供了开发桌面应用程序的基础API；Java EE则主要用于开发Web应用程序和服务端应用程序；Java ME则针对嵌入式设备和移动设备。 #### 1.4 Java SE环境安装和配置 安装Java SE环境首先需要...
Java 泛型详解：类型参数的力量
ZHE|张恒的博客
11-28 1186
本文系统讲解了Java泛型的概念与使用方式。泛型通过在类或方法中引入类型参数，提高了代码的类型安全性和复用性。主要内容包括：1）泛型的基本语法，如定义泛型类和接口；2）泛型方法及其类型推断；3）三种通配符（?、? extends T、? super T）的使用场景；4）边界限制和多重限制；5）泛型的优缺点，如类型安全与类型擦除的影响；6）常见陷阱，如静态上下文和instanceof的限制。泛型是现代Java编程的重要特性，能显著减少类型转换和运行时错误。
TensorRT笔记（5）：研究timingCache
ouliten的博客
12-02 817
在里出现了大量的timingCache，但是当时没有取研究这是干啥的，本文就来解析一下。样例都基于上面的文章。
基于Springboot2+Vue2的旅游景点购票系统
自学网站s.jf3q.com,菜鸟的成长之路
12-02 600
本系统是一个集旅游景点信息展示、在线购票、用户游记分享与互动交流于一体的综合性平台。核心价值在于提供便捷的景点门票预订服务，同时构建活跃的旅游社区，促进用户间的经验分享。
Plugin ‘org.springframework.bootspring-boot-maven-plugin‘ not found的解决方法
2509_94105214的博客
11-30 228
尝试使用 VPN 或更换网络环境，然后再次执行 Maven 构建命令。出现这个报错通常是因为 Maven 无法找到相应的 Spring Boot Maven 插件。如果仍然有问题，请提供更多详细信息，例如完整的错误堆栈跟踪和你的 Maven 配置，以便我更好地帮助你解决问题。如果没有，可以将相应的配置添加到父项目的。执行 Maven 的清理命令，然后重新构建项目。这将清除所有已编译的类文件和错误的依赖缓存，并重新下载正确的依赖。如果你的项目是基于父项目的，检查父项目的。
Java 缓冲区优化
qq_43427354的博客
12-02 463
在 Java 中，缓冲区（Buffer） 是一块用于临时存储数据的内存区域，核心作用是协调数据生产者和消费者的速度差异，减少频繁 I/O 操作或数据拷贝的开销，提升程序性能。它本质是 “数据中转站”，避免了直接对原始数据源（如文件、网络流、数组）的频繁读写，通过 “批量处理” 优化效率。
蓝桥杯20534爆破 java
最新发布
2302_80219214的博客
12-02 767
我们可以用Prim 算法，该算法的核心是从一个起点开始，逐步将距离当前连通集合最近的节点加入集合，最终形成最小生成树。
07_Spring AI 干货笔记之提示词
在科技的浪潮中，我们寻找着创新的火种，在代码的海洋里，我们编织着智慧的网。腾飞开源，就是这样一个由技术精英汇聚而成的博客平台，我们致力于分享在Java、Python、IoT和人工智能等领域的最新研究成果和实战经验。 在腾飞开源的博客上，你会看到紧跟技术前
11-30 1741
本文详细介绍了Spring AI中的提示词核心概念与API设计。提示词作为引导AI模型生成特定输出的关键输入，其结构从简单字符串演进为包含多角色消息的复杂形式。Spring AI通过Prompt和Message接口提供结构化提示词管理，支持系统、用户、助手等角色分配。PromptTemplate类实现动态内容渲染，并支持自定义模板引擎。文章还涵盖提示词工程的最佳实践与令牌机制，为开发者提供完整的提示词设计解决方案。
Java编程基础与实战技巧
这篇内容涵盖了Java编程的基础知识，主要讲解了Java语言中的数据类型、操作符、字符串以及集合框架等核心概念。以下是详细的解释： 1. Java基本数据类型：Java有两类数据类型，即基本类型（如int、float、boolean）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值