Java多线程笔记【二】

最新推荐文章于 2024-08-12 15:45:48 发布
最新推荐文章于 2024-08-12 15:45:48 发布
阅读量136 收藏
点赞数
分类专栏： Java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44728441/article/details/124872576
版权

2.2 Java线程的生命周期

线程状态，也称为线程的生命周期，代表着线程再代码运行中的状态

Thread.State

2.2.1 六种状态

  • NEW：刚刚新建的Thread的对象，但还未调用start()启动线程时，
  • RUNNABLE： 线程对象创建后，其他线程(比如 main 线程）调用了该对象的 start 方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取 cpu 的使用权。
  • BLOCKED： 线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend，wait等方法都可以导致线程阻塞
  • WAITING：等待另外一个线程执行特定的动作（（通知或中断））
  • TIMED_WAITING：该状态不同于WAITING，它可以在指定的时间后自行返回。
  • TERMINATED：表示该线程已经执行完毕，如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪。

在这里插入图片描述

2.3 线程的同步

2.3.1 线程的安全问题

public class TicketMain {
    public static void main(String[] args) {
        Ticket t1 = new Ticket();

        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t1);
        Thread thread3 = new Thread(t1);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();

    }
}


public class Ticket implements Runnable{
    private int ticketCount = 100;
    @Override
    public void run() {
        while (true){
            if (ticketCount == 0){
                break;

            }else{
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "买票，票还有" + ticketCount + "张" );
                ticketCount--;
            }
        }
    }
}

安全问题：

  • 相同得票出现了多次
  • 出现了负数票

注：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

共享数据：多个线程共同操作的变量：比如上面代码的票数 ticketCount

2.3.2 同步代码块

锁多条语句操作共享数据，可以实现同步代码块实现

synchronized(同步监视器){
	多条语句操作共享数据的代码
}

注：

  • 默认情况是打开的，只要一个线程进去执行代码了，锁就会关闭。当线程执行完毕出来，锁才会自动打开

  • 同步监视器（锁）可以是任何对象。因为任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。但是要求多个线程要共用同一把锁

  • Runnable可以考虑用this当作同步监视器

  • 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）

同步监视器的执行过程:

  • 第一个线程访问，锁定同步监视器，执行其中的代码
  • 第二个线程访问，发现同步监视器被锁定，无法访问
  • 第一个线程访问完毕，解锁同步监视器
  • 第二个线程访问，发现同步监视器没有锁，锁定同步加速器并访问

好处和弊端

  • 好处：解决了多线程的数据安全问题
  • 弊端：当线程很大时，因为每个线程都会去判断同步上的锁吗，这是很耗费资源的，无形中会降低程序的运行效率
public class TicketMain {
    public static void main(String[] args) {
        Ticket t1 = new Ticket();

        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t1);
        Thread thread3 = new Thread(t1);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();

    }
}
public class Ticket implements Runnable{
    private int ticketCount = 100;
    private Object obj = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj){ // 多个线程必须使用同一把锁
                if (ticketCount == 0){
                    break;
                }else{
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "买票，票还有" + ticketCount + "张" );
                    ticketCount--;
                }
            }
        }
    }
}

2.3.3 同步方法

把synchronized关键字加到方法是，同步方法的锁对象是this

修饰符 synchronized 返回值类型 方法名(方法参数){}

同步代码块和同步方法的区别

  • 同步代码块可以锁住指定代码，同步方法是锁住方法中所有代码
  • 同步代码块可以指定锁对象，同步方法不能指定锁对象
  • 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this）
public class Demo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

        t1.setName("窗口一");
        t2.setName("窗口二");

        t1.start();
        t2.start();

    }
}

class MyRunnable implements Runnable {
    private int ticketCount = 100;
    @Override
    public void run() {
        while (true){
            synchronizedMethod();
            if(ticketCount == 0){
                break;
            }

        }
    }

    private synchronized void synchronizedMethod() {
        if (ticketCount > 0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张");
            ticketCount--;

        }
    }
}

public class Demo {
    public static void main(String[] args) {
        // 创建线程对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.start();
        t2.start();

    }
}

class MyThread extends Thread {
    private static int ticketCount = 100;
    @Override
    public void run() {
        while (true){
            synchronizedMethod();
            if(ticketCount == 0){
                break;
            }
        }
    }
    // 继承Thread 用静态方法
    private static synchronized void synchronizedMethod() {
        if (ticketCount > 0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketCount--;
            System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张");
        }
    }
}

2.3.4 死锁

线程的死锁是指由于俩个或多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前进执行，**主要是因为锁的嵌套 **

产生死锁的必要条件：

  1. 互斥条件：一个资源每次只能被一个进程使用
  2. 请求与保存条件：一个进程因请求资源而阻塞时，对已获得得资源保持不放
  3. 不剥夺条件：进程以获得得资源吗，在未使用之前，不能强行剥夺
  4. 循环等待条件：若干进程之间形成一种头尾相接循环等待资源关系

只有破坏上面任意一个条件就可以避免死锁得发送

2.3.5 Lock(锁)

JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

  • private final ReentrantLock lock = new ReentrantLock()：可以传入参数 boolean ,如果为true 则按线程进入的顺序，如果false则随机抽取线程进入
package lock;

import java.util.concurrent.locks.ReentrantLock;

public class TestLock {

    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();

        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }

}


class TestLock2 implements Runnable{

    int ticketNums = 100;

    // 定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            lock.lock();
            try {
                if (ticketNums > 0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else{
                    break;
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                // 解锁
                lock.unlock();
            }
        }
    }
}

注意：如果同步代码有异常，要将unlock()写入finally语句块，确保锁会得到释放

2.3.5.1 synchronized 与 Lock 的对比
  1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放
  2. Lock只有代码块锁，synchronized有代码块锁和方法锁
  3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
  4. Lock -> 同步代码块（已经进入了方法体，分配了相应资源） -> 同步方法（在方法体之外）
猩空中的猩⭐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
17java基础多线程测评题
weixin_44140163的博客
03-28 3456
选择题 题目1(单选): 对于以下多线程创建代码补全( A ) public class MyThread01 { public static void main(String[] args) { MyThread mt = new MyThread(); // 开启线程 __位置3__ } } class MyThread __位置1__ Thread { @Override public void __位置2__() {
Java 多线程总结笔记
N0tExpecterr0r的博客
09-19 4369
Java多线程总结笔记 实现多线程的方法 查看Thread类的源码，可以发现它实现了Runnable接口，然后在自己的run方法中调用了Runnable的run方法。这里其实就是静态代理这一设计模式，Thread是代理角色，而Runnable则是真实角色。在Thread的start方法中，会为我们开辟新的线程并执行其run方法，而Thread的run方法会调用它内部持有引用的Runnable的ru...
JavaSE_多线程入门 线程安全 死锁 状态 通讯 线程池
m0_56069948的博客
05-31 126
🚀 优质资源分享 🚀 学习路线指引（点击解锁） 知识定位 人群定位 🧡 Python实战微信订餐小程序 🧡 进阶级 本课程是python flask+微信小程序的完美结合，从项目搭建到腾讯云部署上线，打造一个全栈订餐系统。 💛Python量化交易实战💛 入门级 手把手带你打造一个易扩展、更安全、效率更高的量化交易系统 1 多线程入门 1.1 多线程相关的概念 并发与并行 并行：在同一时刻，有多个任务在多个CPU上同时执行。 并发：在同一时刻，有多个任务在单个CPU上交替执行。
JavaSE之多线程、线程安全问题和synchronized代码块
weixin_47543906的博客
11-09 239
在多线程环境下，多个线程会抢占同步代码块中的锁对象。当一个线程获取锁，就可以成功进入同步代码块，其他线程获取不到锁，需要在同步代码块外面等待（阻塞）。 获得锁的线程执行完同步代码块后会释放锁，此时所有等待的线程会重新争夺锁对象（释放锁的线程也会再次参与争夺）。 抢到锁的线程就可以进行同步代码块执行。
『JAVA多线程·学习之路』-线程的安全问题
Hhzzy99的博客
11-18 1692
Java多线程-线程安全问题的学习总结
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 20万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java多线程笔记
weixin_44159128的博客
04-15 1424
Java基础中的多线程基本实现方法
Java黑马程序员-多线程笔记
luohanisme的博客
10-17 985
哔哩哔哩java黑马视频笔记
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3268
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
Java多线程自学笔记
01-19
### Java多线程自学笔记知识点总结 #### 一、Java多线程概念 - **多线程定义**：多线程是指程序中可以同时执行多个线程的能力。Java虚拟机支持多线程机制，允许应用程序在不同的线程上并行执行任务。 - **线程特点...
黑马程序员–Java多线程讲解笔记
12-22
Java多线程是Java编程中不可或缺的部分，它允许程序同时执行多个任务，提高了程序的效率和响应速度。本文主要探讨了多线程的概念、应用场景以及Java中创建线程的两种方式。 首先，进程和线程是理解多线程的基础概念...
java多线程笔记分享
12-22
java多线程笔记分享
Java多线程源码笔记.pdf
05-08
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高系统效率。在Java中，实现多线程主要有两种方式：通过继承Thread类和实现Runnable接口。Thread类提供了创建新线程的基本功能，而Runnable...
（javaweb）请求响应postman
2301_79144798的博客
08-08 534
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 503
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 535
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
集合（1）
最新发布
supercool7的博客
08-12 797
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
狂神说java多线程笔记
10-11
狂神在他的Java多线程笔记中，详细介绍了Java多线程的相关知识，包括线程的创建、启动、停止、等待、唤醒等操作，以及线程安全、锁、同步等概念和技术。 在Java多线程中，线程的创建有两种方式：继承Thread类和实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猩空中的猩⭐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值