Java多线程学习笔记（二）

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量128 收藏
点赞数
分类专栏： Java 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AHawkeye/article/details/116423142
版权
本文通过售票案例探讨Java多线程的实现方式，包括实现Runnable接口和继承Thread类，并分析线程安全问题。通过引入同步代码块和`synchronized`关键字，解决了资源竞争导致的线程安全问题，提高了代码的正确性和可靠性。
摘要由CSDN通过智能技术生成

从卖票入手

先看多线程的一个经典例子：创建三个窗口卖票，总票数是100张。
先看这个代码：

package com.xzc;

class Window extends Thread{
    public Window(){

    }
    public Window(String name){
        super(name);
    }
    private int ticket = 100;

    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                System.out.println(getName()+":卖票，票号为："+ticket--);
            }else {
                break;
            }
        }
    }
}
public class Test {
    public static void main(String[] args) {
        Window w1 = new Window("窗口一");
        Window w2 = new Window("窗口二");
        Window w3 = new Window("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }

}

输出结果：
在这里插入图片描述
出现了同一张票，被多个窗口卖出的情况。这是因为我们提供的ticket是实例变量，属于每一个对象，每一个线程，这个资源不被共享。如果我们把ticket设为静态变量：

java private static int ticket = 100;
输出结果：
在这里插入图片描述
大致是共享了资源，但是还会出现一些问题！实际上这里就有线程安全问题。这里输出是因为要有一定延迟，所以从输出结果看并不是依次递减。

创建多线程

方法二：实现Runnable接口

1.创建一个实现了Runnable接口的类
2.实现Runnable类的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器，创建Thread类的对象
5.通过Thread类对象调用start方法。

package com.xzc;

class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        new Thread(new MyThread(),"线程一").start();
    }

}

输出结果：
在这里插入图片描述
遍历了0~100的偶数，这里就是创建一个实现了runnable类接口的类的对象，把他作为参数传入Thread类的构造器，其实该构造器还可以有一个参数，就是线程名，我们这里直接用。这里的start有两个作用：1.启动线程。2.调用Runnable类型的target的run方法。我们可以重用这个类，再启动一个线程。

package com.xzc;

class MyThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        new Thread(new MyThread(),"线程一").start();
        new Thread(new MyThread(),"线程二").start();
    }

}

输出结果：
在这里插入图片描述

再谈卖票问题

package com.xzc;

class Window implements Runnable{
    public Window(){}
    private int ticket;
    public Window(int ticket){
        this.ticket = ticket;
    }
    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket--);
            }else {
                break;
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Window w = new Window(100);
        new Thread(w,"窗口一").start();
        new Thread(w,"窗口二").start();
        new Thread(w,"窗口三").start();
    }

}

输出结果：
在这里插入图片描述
可以发现，已经能比较好地实现资源共享了，但是这种实现方式也有线程安全问题，也会有重票的问题。但是，我们没有加static关键字，就有100张票，这是因为虽然ticket是实例变量，但是我们只有一个window对象放到构造器当参数，自然而然就是同一个ticket。

两种创建多线程方式

开发中，优先选择实现Runnable接口的方式，原因：
1.实现的方式没有类的单继承的局限性，可以让类继承一些特定的父类。
2.实现的方式更适合来处理多个线程共享数据的情况。
联系：Thread本身就实现了Runnable接口。
相同点：两种方式都要重写run方法。

线程的生命周期

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

线程安全

如果我们让实现runnable接口的车票程序的run方法里加个sleep

package com.xzc;

class Window implements Runnable{
    public Window(){}
    private int ticket;
    public Window(int ticket){
        this.ticket = ticket;
    }
    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket--);
            }else {
                break;
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Window w = new Window(100);
        new Thread(w,"窗口一").start();
        new Thread(w,"窗口二").start();
        new Thread(w,"窗口三").start();
    }

}

输出结果：
在这里插入图片描述
输出0和-1的概率大大提升。这是因为有一张票的时候，我们t1线程进来，被阻塞，还没输出，t2进来，也被阻塞，同理t3，然后就出现了如下情况：
在这里插入图片描述
不管是重票还是错票，问题出现的原因都是当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。如何解决？当一个线程在操作ticket的时候，其他线程不能参与进来，直到该线程完成操作。这种情况，即使该线程被阻塞，也不能被改变。

同步代码块解决实现Runnable接口的线程安全问题

关键字：synchronized

synchronized(/*同步监视器*/){
	//需要被同步的代码
}
//操作共享数据的代码，即为需要被同步的代码
//同步监视器，俗称锁。任何一个类的对象，都可以充当锁。要求多个线程，共用同一把锁。

package com.xzc;

class Window implements Runnable{
    public Window(){}
    private int ticket;
    public Window(int ticket){
        this.ticket = ticket;
    }
    Object obj = new Object();
    @Override
    public void run() {

        while (true){
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket--);
                } else {
                    break;
                }
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Window w = new Window(100);
        new Thread(w,"窗口一").start();
        new Thread(w,"窗口二").start();
        new Thread(w,"窗口三").start();
    }

}

输出结果：
在这里插入图片描述
一定注意要求多个线程，共用同一把锁，这里我们一个window对象，就一个对象obj，保证了所有线程共用一个锁。不会出现线程安全问题。
同步的好处时解决了线程安全问题，但是操作同步代码时，只能有一个线程参与，其他线程等待，相当于一个单线程过程，效率比较低。

同步代码块解决实现继承Thread类的线程安全问题

因为此时是不一样的window对象，如果和之前用一样的方法，肯定不能共用一个锁，因为每一个window对象的obj实例不一样，导致无法共用一个锁。把obj设为static即可。

package com.xzc;

class Window2 extends Thread{
    public Window2(){

    }
    public Window2(String name){
        super(name);
    }
    private static int ticket = 100;
    private static final Object obj = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + ":卖票，票号为：" + ticket--);
                } else {
                    break;
                }
            }
        }
    }
}
public class Test2 {
    public static void main(String[] args) {
        Window2 w1 = new Window2("窗口一");
        Window2 w2 = new Window2("窗口二");
        Window2 w3 = new Window2("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }

}

输出结果：
在这里插入图片描述
在实现Runnable接口的锁，其实直接用this关键字即可。synchronized (this){}，因为这里this指的是Window的一个对象，他是实现Runnable接口的类的对象，唯一，所以为了方便，不用new一个object，直接用this即可。但是在继承thread类的对象中，就不能用this了，因为我们new了三个对象出来，不是唯一的。有什么简便方法呢，用反射。

package com.xzc;

class Window2 extends Thread{
    public Window2(){

    }
    public Window2(String name){
        super(name);
    }
    private static int ticket = 100;
    private static final Object obj = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (Window2.class) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + ":卖票，票号为：" + ticket--);
                } else {
                    break;
                }
            }
        }
    }
}
public class Test2 {
    public static void main(String[] args) {
        Window2 w1 = new Window2("窗口一");
        Window2 w2 = new Window2("窗口二");
        Window2 w3 = new Window2("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }

}

我们在synchronized参数传入Window2的Class对象即可。synchronized (Window2.class)

AHawkeye
关注
专栏目录
安卓建立新线程的三种方式
水舞残枫的博客
03-29 2093
既然用到了线程通信，那就把多线程趁机学一下吧。 首先是建立新线程。 1、新建一个类继承自Thread，然后重写父类的run()方法，并在里面编写要处理的事务。 class MyThread extends Thread{ @Override public void run(){ //处理事务 } } 启动线程的时候需要new出M...
interface和abstract类的区别
梨子的博客
09-22 229
interface和abstract类的区别 抽象类： 含有abstract修饰符的class即为抽象类，abstract 类无法被实例化。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。 接口（interface）： 接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集
Java 多线程学习笔记
2301_76962889的博客
07-13 1886
*进程：**是操作系统进行资源分配和调度的基本单位，是程序的一次执行过程。**例如：**当你打开一个应用程序，如浏览器、音乐播放器等，操作系统就会为其创建一个进程。**线程：**是进程的一个执行单元，是 CPU 调度和分派的基本单位，一个进程可以包含多个线程。**例如：**在浏览器进程中，可以有多个线程同时运行，例如一个线程负责页面渲染，另一个线程负责网络请求。提高 CPU 利用率，充分利用多核处理器**例如：**下载软件使用多线程可以同时下载多个文件片段，充分利用带宽，提高下载速度。
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3455
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
尚硅谷_java多线程_学习笔记
qq_17079255的博客
10-08 1673
文章标题
Java多线程学习笔记 - 1
涞公子的博客
03-13 2486
多任务 概述： 多任务就是同时运行多个任务。 好处： 充分利用了CPU的资源，提高了代码的执行效率。 执行方式： 并发：在一段时间内交替去执行多项任务【任务数 > 核数】 并行：多个计算机内核一起执行任务，一个内核负责执行一个任务【任务数 <= 核数】 实现方式： 多线程或多进程。 进程与线程介绍： 进程 概述： 线程 概述： 进程与线程之间的关系 一个进程内含有一个或多个线程，但至少含有一个线程。 ...
Java多线程笔记详解
you are sherlocked by me!
10-09 559
这是学习多线程知识的学习笔记，大家可以选择自己感兴趣的部分阅读学习 详细代码见github代码   Java多线程学习笔记1之多线程基础 内容: 1) 基本概念以及线程的实现方法   Java多线程学习笔记2之多线程基础 内容: 1) 数据同步 2) 非线程安全情况以及处理方法 3) Java内存模型 4) Thread.currentThread()抽象方法使用 ...
java多线程学习笔记
weach的博客
12-19 916
java多线程
Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
热门推荐
qq_35716689的博客
03-16 25万+
异步日志记录是一种提升系统性能和可维护性的有效手段。牵着猫散步的鼠鼠。通过将日志记录操作异步化，不仅可以减少对业务处理流程的影响，还可以提高日志处理的灵活性和扩展性。然而，实现异步日志记录机制也伴随着一定的挑战，如日志的实时性、顺序性和丢失风险等问题。
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
java多线程学习笔记之自定义线程池
08-29
Java多线程学习笔记之自定义线程池 本篇文章主要介绍了Java多线程学习笔记之自定义线程池，通过深入了解ThreadPoolExecutor这个核心类，我们可以自定义线程池，满足不同的线程池需求。 Java多线程学习笔记之自定义...
黑马程序员–Java多线程讲解笔记
12-22
Java多线程是Java编程中不可或缺的部分，它允许程序同时执行多个任务，提高了程序的效率和响应速度。本文主要探讨了多线程的概念、应用场景以及Java中创建线程的两种方式。 首先，进程和线程是理解多线程的基础概念...
多线程学习笔记
03-18
多线程学习笔记 iOS开发中，多线程是一种常见的技术手段，用于优化应用程序的性能，提升用户体验。多线程的核心是让程序能够并发地执行多个任务，合理地利用设备的计算能力，尤其是在拥有多个核心的处理器上。 ...
工厂模式的介绍及实现
户伟伟的博客
09-25 121
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Spring Boot 学习和使用
cesske的博客
09-24 1101
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 447
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
智能BI平台项目
2302_79400545的博客
09-22 241
BI商业智能：数据可视化、报表可视化系统。
Java多线程学习笔记：线程状态与同步机制
"这篇学习笔记主要探讨了多线程的概念、创建与启动方式、线程方法、线程的生命周期及状态、系统锁synchronized的使用和特性，包括可重入锁和锁升级机制。" 在Java编程中，多线程是一项重要的并发处理技术，它允许...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值