Java重修笔记 第五十六天 坦克大战（六）多线程基础 - 线程同步、死锁

news2024/11/15 13:00:36
  • 多线程同步机制

        多线程编程中，一些敏感数据可能会被多个线程同时访问造成数据混乱（例如票数），使用线程同步机制，通过锁对象（对象实例或类实例）的方式来保证该段代码在任意时刻，最多只能由一个线程来访问，从而保证了数据的安全性。

  • synchronized 实现线程同步
1. 修饰普通方法

        同步普通方法本质上锁的是：调用该方法的实例对象

        （1）不加锁，同一个对象多个线程一起执行，互不干扰
public class Synchronized {
    public static void main(String[] args) {
        // 不加锁，同一个对象多个线程一起执行，互不干扰
        MyClass01 myClass01 = new MyClass01();
        new Thread(myClass01).start();
        new Thread(myClass01).start();
    }
}

class MyClass01 implements Runnable {

    // 两个线程同时进入 run 方法
    @Override
    public void run() {
        method01();
        method02();
    }

    public void method01() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method01 方法被 " + Thread.currentThread().getName() + " 执行...");

    }
    public void method02() {
        System.out.println("method02 方法被 " + Thread.currentThread().getName() + " 执行...");
    }
}

运行结果：（结果不固定）

        （2）不加锁，不同对象多个线程一起执行，互不干扰
public class Synchronized {
    public static void main(String[] args) {
        // 不加锁，不同对象多个线程一起执行，互不干扰
        MyClass01 myClass0101 = new MyClass01();
        MyClass01 myClass0102 = new MyClass01();
        new Thread(myClass0101).start();
        new Thread(myClass0102).start();
    }
}

class MyClass01 implements Runnable {

    // 两个线程同时进入 run 方法
    @Override
    public void run() {
        method01();
        method02();
    }

    public void method01() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method01 方法被 " + Thread.currentThread().getName() + " 执行...");

    }
    public void method02() {
        System.out.println("method02 方法被 " + Thread.currentThread().getName() + " 执行...");
    }
}

运行结果：（结果不固定）

        （3）给普通方法加锁，锁住了同一个对象实例 this，线程阻塞
public class Synchronized03 {
    public static void main(String[] args) {
        // 给普通方法加锁，锁住了同一个对象实例 this，线程阻塞
        MyClass02 myClass02 = new MyClass02();
        new Thread(myClass02).start();
        new Thread(myClass02).start();
    }
}

class MyClass02 implements Runnable {

    // 两个线程同时执行到 run 方法
    @Override
    public void run() {
        method01();
        method02();
    }

    // 这个方法在两个线程中都锁住了 this 对象
    // 所以必须等第一个线程执行完 method01 方法, 下一个线程才能执行
    public synchronized void method01() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method01 方法被 " + Thread.currentThread().getName() + " 执行...");
    }

    public void method02() {
        System.out.println("method02 方法被 " + Thread.currentThread().getName() + " 执行...");
    }
}

运行结果：

        （4）给普通方法加锁，锁住了不同的对象实例，互不干扰
public class Synchronized03 {
    public static void main(String[] args) {
        // 给普通方法加锁，锁住不同的对象实例，
        MyClass02 myClass0201 = new MyClass02();
        MyClass02 myClass0202 = new MyClass02();
        new Thread(myClass0201).start();
        new Thread(myClass0202).start();
    }
}

class MyClass02 implements Runnable {

    // 两个线程同时执行到 run 方法
    @Override
    public void run() {
        method01();
        method02();
    }

    // 锁住两个不同的实例对象不会阻塞
    public synchronized void method01() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method01 方法被 " + Thread.currentThread().getName() + " 执行...");
    }

    public void method02() {
        System.out.println("method02 方法被 " + Thread.currentThread().getName() + " 执行...");
    }
}

运行结果：（结果不固定）

 2. 修饰静态方法

        同步静态方法本质上锁的是：调用该方法的类对象

        （1）不加锁，同一个对象多个线程一起执行，互不干扰
public class Synchronized03 {
    public static void main(String[] args) {
        // 不加锁，同一个对象多个线程一起执行，互不干扰
        MyClass03 myClass03 = new MyClass03();
        new Thread(myClass03).start();
        new Thread(myClass03).start();
    }
}

class MyClass03 extends Thread {

    // 两个线程同时执行到 run 方法
    @Override
    public void run() {
        method01();
        method02();
    }
    
    public static void method01() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method01 方法被 " + Thread.currentThread().getName() + " 执行...");
    }

    public static void method02() {
        System.out.println("method02 方法被 " + Thread.currentThread().getName() + " 执行...");
    }
}

运行结果：（结果不固定）

        （2）不加锁，不同对象多个线程一起执行，互不干扰
public class Synchronized03 {
    public static void main(String[] args) {
        // 不加锁，不同对象多个线程一起执行，互不干扰
        MyClass03 myClass0301 = new MyClass03();
        MyClass03 myClass0302 = new MyClass03();
        new Thread(myClass0301).start();
        new Thread(myClass0302).start();
    }
}

class MyClass03 extends Thread {

    // 两个线程同时执行到 run 方法
    @Override
    public void run() {
        method01();
        method02();
    }
    
    public static void method01() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method01 方法被 " + Thread.currentThread().getName() + " 执行...");
    }

    public static void method02() {
        System.out.println("method02 方法被 " + Thread.currentThread().getName() + " 执行...");
    }
}

运行结果：（结果不固定）

        （3）给静态方法加锁，锁住了同一个对象实例，也就是同一个类实例，线程阻塞
public class Synchronized03 {
    public static void main(String[] args) {
        // 给静态方法加锁，锁住了同一个对象实例，也就是同一个类实例，线程阻塞
        MyClass04 myClass04 = new MyClass04();
        new Thread(myClass04).start();
        new Thread(myClass04).start();
    }
}

class MyClass04 implements Runnable {

    // 两个线程同时执行到 run 方法
    @Override
    public void run() {
        method01();
        method02();
    }
    
    // 锁住了同一个类实例，线程阻塞
    public static synchronized void method01() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method01 方法被 " + Thread.currentThread().getName() + " 执行...");
    }

    public static void method02() {
        System.out.println("method02 方法被 " + Thread.currentThread().getName() + " 执行...");
    }
}

运行结果：

        （4）给静态方法加锁，锁住了不同的对象实例，但本质锁的是同一个类实例，线程阻塞
public class Synchronized03 {
    public static void main(String[] args) {
        // 给静态方法加锁，锁住了同一个对象实例，也就是同一个类实例，线程阻塞
        MyClass04 myClass04 = new MyClass04();
        new Thread(myClass04).start();
        new Thread(myClass04).start();
    }
}

class MyClass04 implements Runnable {

    // 两个线程同时执行到 run 方法
    @Override
    public void run() {
        method01();
        method02();
    }
    
    // 锁住了同一个类实例，线程阻塞
    public static synchronized void method01() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method01 方法被 " + Thread.currentThread().getName() + " 执行...");
    }

    public static void method02() {
        System.out.println("method02 方法被 " + Thread.currentThread().getName() + " 执行...");
    }
}

运行结果：

3. 修饰代码块

        通过在 synchronized 关键字后面的对象（实例对象或类对象）来上锁，随便 new 个啥进去都行，只要保证不同线程中括号里的是同一个对象实例或类对象，那么就能成功上锁

        （1）不加锁，同一个对象多个线程一起执行，互不干扰
public class Synchronized04 {
    public static void main(String[] args) {

        // 不加锁，同一个对象多个线程一起执行，互不干扰
        MyClass05 myClass05 = new MyClass05();
        for (int i = 0; i < 5; i++) {
            new Thread(myClass05).start();
        }
    }
}

class MyClass05 implements Runnable {

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println("代码块被 " + Thread.currentThread().getName() + " 执行...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：（结果不固定）

        （2）加锁，但是每个线程传入的对象不一样，没锁住互不干扰
public class Synchronized04 {
    public static void main(String[] args) {

        // 加锁，但是每个线程传入的对象不一样，没锁住互不干扰
        for (int i = 0; i < 5; i++) {
            MyClass05 myClass05 = new MyClass05();
            new Thread(myClass05).start();
        }
    }
}

class MyClass05 implements Runnable {

    @Override
    public void run() {
        synchronized (this) {
            try {
                Thread.sleep(1000);
                System.out.println("代码块被 " + Thread.currentThread().getName() + " 执行...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：（结果不固定）

        （3）加锁，每个线程传入同样的对象，线程阻塞
public class Synchronized04 {
    public static void main(String[] args) {

        // 加锁，每个线程传入同样的对象，线程阻塞
        MyClass05 myClass05 = new MyClass05();
        for (int i = 0; i < 5; i++) {
            new Thread(myClass05).start();
        }
    }
}

class MyClass05 implements Runnable {

    @Override
    public void run() {
        synchronized (this) {
            try {
                Thread.sleep(1000);
                System.out.println("代码块被 " + Thread.currentThread().getName() + " 执行...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

        （4）加锁，锁住类对象，线程阻塞
public class Synchronized04 {
    public static void main(String[] args) {

        // 加锁，锁住类对象，线程阻塞
        for (int i = 0; i < 5; i++) {
            MyClass05 myClass05 = new MyClass05();
            new Thread(myClass05).start();
        }
    }
}

class MyClass05 implements Runnable {

    @Override
    public void run() {
        synchronized (MyClass05.class) {
            try {
                Thread.sleep(1000);
                System.out.println("代码块被 " + Thread.currentThread().getName() + " 执行...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

  • 实现上锁步骤

1. 找到需要上锁的部分

2. 用代码块或者方法封装起来

3. 让多个线程判断锁的对象为同一个即可

  • 线程死锁

        多个线程都占用了对方的锁资源，即 A 线程想要 B 线程持有的锁资源，而 B 线程想要 A 线程持有的锁资源，且双方互不释放，就会导致死锁的发生。

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

        DeadLockDemo deadLockDemo01 = new DeadLockDemo(true);
        deadLockDemo01.setName("线程 A ");
        DeadLockDemo deadLockDemo02 = new DeadLockDemo(false);
        deadLockDemo02.setName("线程 B ");
        deadLockDemo01.start();
        deadLockDemo02.start();
    }
}

class DeadLockDemo extends Thread {
    static Object object1 = new Object(); // 保证不管有多少个实例对象, 都共享同一个 object1
    static Object object2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {

        // 线程 A 传进来的 flag 为 true, 线程 B 同步传进来的 flag 为 false
        // 这样就会出现一个问题, 那就是线程 A 持有 object1 锁并在尝试获取 object2 锁
        // 但是线程 B 持有着 object2 锁同时尝试获取 object1 锁, 双方都持有对方想要的锁却不释放
        // 这样就造成了程序死锁的发生
        if (flag) {
            synchronized (object1) { // 加入对象互斥锁
                System.out.println(Thread.currentThread().getName() + "进入 object1 锁的代码块");
                synchronized (object2) {
                    System.out.println(Thread.currentThread().getName() + "进入 object2 锁的代码块");
                }
            }
        } else {
            synchronized (object2) {
                System.out.println(Thread.currentThread().getName() + "进入 object2 锁的代码块");
                synchronized (object1) {
                    System.out.println(Thread.currentThread().getName() + "进入 object1 锁的代码块");
                }
            }
        }
    }
}

运行结果：

  • 释放锁
1. 什么操作会释放锁资源
        （1）当这个同步代码块执行结束后，自动释放锁资源
        （2）遇到 break 或者 return 语句强制退出方法/代码块时，自动释放锁资源
        （3）同步代码块或同步方法中遇到未处理的 Error 或者 Exception 异常退出时，自动释放锁资源
        （4）通过 wait 方法来让当前线程暂停（join 方法底层调用 wait 方法），线程暂停后会释放锁资源
2. 什么操作不会释放锁资源
        （1）调用 sleep 、yield 方法时，不会释放锁资源
        （2）调用 suspend 方法将线程挂起，也不会释放锁资源

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2139348.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

TCP socket

TCP socket

TCP的socket和UDP大同小异&#xff0c;基本的代码结构都是相同的。一些相同的接口本文就不赘述了&#xff0c;例如&#xff0c;socket,bind&#xff0c;有需要看这篇文章UDP socket 服务端server 两步&#xff1a;初始化服务端&#xff0c;运行服务端 初始化服务端 创建soc…
阅读更多...
Java项目基于docker 部署配置

Java项目基于docker 部署配置

linux新建文件夹 data cd datatouch Dockerfilesudo vim Dockerfile# 使用一个基础的 Java 镜像&#xff08;根据自己项目中使用的是什么jdk版本设置&#xff0c;用于拉取执行jar包的jdk环境&#xff09; FROM openjdk:8# 指定工作目录 VOLUME /data# 复制应用程序的 JAR 文件…
阅读更多...
Redis模拟消息队列实现异步秒杀

Redis模拟消息队列实现异步秒杀

目录 一、消息队列含义 二、Redis实现消息队列 1、基于List的结构模拟实现消息队列 2、基于PubSub的消息队列 3、基于Stream的消息队列 4、基于Stream的消息队列- 消费者组 一、消息队列含义 消息队列&#xff08;Message Queue&#xff09;&#xff0c;字面意思就是存放…
阅读更多...
基于SpringBoot的招生宣传管理系统【附源码】

基于SpringBoot的招生宣传管理系统【附源码】

基于SpringBoot的招生宣传管理系统&#xff08;源码L文说明文档&#xff09; 目录 4 系统设计 4.1 系统概述 4.2系统功能结构设计 4.3数据库设计 4.3.1数据库E-R图设计 4.3.2 数据库表结构设计 5 系统实现 5.1管理员功能介绍 5.1.1管理员登录 …
阅读更多...
【JavaScript】LeetCode：36-40

【JavaScript】LeetCode：36-40

文章目录 36 两数相加37 删除链表的倒数第n个节点38 两两交换链表中的节点39 k个一组翻转链表40 随机链表的复制 36 两数相加 创建一个新的链表&#xff08;哨兵节点指向&#xff09;&#xff0c;这个链表用来表示两个数相加后的和。从个位开始相加&#xff0c;每次都向新链表尾…
阅读更多...
PCL 点云随机渲染颜色

PCL 点云随机渲染颜色

目录 一、概述 1.1原理 1.2实现步骤 1.3 应用场景 二、代码实现 2.1关键函数 2.2完整代码 三、实现效果 PCL点云算法汇总及实战案例汇总的目录地址链接&#xff1a; PCL点云算法与项目实战案例汇总&#xff08;长期更新&#xff09; 一、概述 本文将介绍如何使用PCL库…
阅读更多...
PMP–一、二、三模–分类–14.敏捷–技巧–项目生命周期

PMP–一、二、三模–分类–14.敏捷–技巧–项目生命周期

文章目录 技巧项目生命周期 一模14.敏捷--项目生命周期--原型法--迭代型生命周期&#xff0c;通过连续的原型或概念验证来改进产品或成果。每个新的原型都能带来新的干系人新的反馈和团队见解。题目中明确提到需要反馈&#xff0c;因此原型法比较好用。23、 [单选] 一个敏捷团队…
阅读更多...
DAY13信息打点-Web 应用源码泄漏开源闭源指纹识别GITSVNDS备份

DAY13信息打点-Web 应用源码泄漏开源闭源指纹识别GITSVNDS备份

#知识点 0、Web架构资产-平台指纹识别 1、开源-CMS指纹识别源码获取方式 2、闭源-习惯&配置&特性等获取方式 3、闭源-托管资产平台资源搜索监控 演示案例&#xff1a; ➢后端-开源-指纹识别-源码下载 ➢后端-闭源-配置不当-源码泄漏 ➢后端-方向-资源码云-源码泄漏 …
阅读更多...
Linux下的简单TCP客户端和服务器

Linux下的简单TCP客户端和服务器

客户端 #include <arpa/inet.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <unistd.h> #include <sys/socket.h>int main() {struct sockaddr_in* caddr(struct sockaddr_in*)malloc(sizeof(struct sockaddr…
阅读更多...
【JavaEE】IO基础知识及代码演示

【JavaEE】IO基础知识及代码演示

目录 一、File 1.1 观察get系列特点差异 1.2 创建文件 1.3.1 delete()删除文件 1.3.2 deleteOnExit()删除文件 1.4 mkdir 与 mkdirs的区别 1.5 文件重命名 二、文件内容的读写----数据流 1.1 InputStream 1.1.1 使用 read() 读取文件 1.2 OutputStream 1.3 代码演示…
阅读更多...
【有啥问啥】自动提示词工程（Automatic Prompt Engineering, APE）：深入解析与技术应用

【有啥问啥】自动提示词工程（Automatic Prompt Engineering, APE）：深入解析与技术应用

自动提示词工程&#xff08;Automatic Prompt Engineering, APE&#xff09;&#xff1a;深入解析与技术应用 引言 随着大语言模型&#xff08;LLM&#xff09;如 GPT、BERT 等的快速发展&#xff0c;如何高效地与这些模型进行互动成为了重要的研究方向之一。提示词&#xff…
阅读更多...
阿里P8和P9级别有何要求

阿里P8和P9级别有何要求

阿里巴巴的P8和P9级别&#xff0c;代表着公司的资深技术专家或管理者岗位&#xff0c;要求候选人具有丰富的职业经历、深厚的技术能力以及出色的领导力。以下是对P8和P9级别的要求、考察点以及准备建议的详细分析。 P8 级别要求 1. 职业经历&#xff1a; 8年以上的工作经验&a…
阅读更多...
PCIe进阶之TL：Common Packet Header Fields TLPs with Data Payloads Rules

PCIe进阶之TL：Common Packet Header Fields TLPs with Data Payloads Rules

1 Transaction Layer Protocol - Packet Definition TLP有四种事务类型：Memory、I/O、Configuration 和 Messages，两种地址格式：32bit 和 64bit。 构成 TLP 时，所有标记为 Reserved 的字段（有时缩写为 R）都必须全为0。接收者Rx必须忽略此字段中的值，PCIe Switch 必须对…
阅读更多...
响应式网站的网站建设，需要注意什么?

响应式网站的网站建设，需要注意什么?

响应式网站建设需要注意多个方面&#xff0c;以确保网站能够在各种设备和屏幕尺寸上提供一致且良好的用户体验。下面详细介绍响应式网站建设的注意事项&#xff1a; 响应式网站的网站建设&#xff0c;需要注意什么? 考虑多终端适配 设计样式&#xff1a;在设计响应式网站时&…
阅读更多...
豆包MarsCode | 一款智能编程助手开发工具

豆包MarsCode | 一款智能编程助手开发工具

豆包MarsCode | 一款智能编程助手开发工具 豆包MarsCode 是基于豆包大模型的智能开发工具&#xff0c;提供 Cloud IDE 和 AI 编程助手&#xff0c;支持代码补全、智能问答、代码解释与修复&#xff0c;兼容主流编程工具与 100 种编程语言&#xff0c;助力编程更智能便捷 豆包 M…
阅读更多...
InterPro蛋白质结构域数据下载

InterPro蛋白质结构域数据下载

前言 偶然发现InterPro数据库挺不错的。 之前使用selenium爬取了AlphaFlod数据&#xff0c;于是也想试试把InterPro的结构域数据爬取一下。 结果发现官方已经给好了代码&#xff0c;真是太善解人意了。 当然&#xff0c;想要批量下载还需要魔改一下官方代码。 步骤一&#…
阅读更多...
【初阶数据结构】排序

【初阶数据结构】排序

目录 一、排序的概念及其运用 1.1排序的概念 1.2常见的排序算法 二、常见排序算法的实现 2 .1插入排序 2 .1.1基本思想&#xff1a; 2.1.2直接插入排序&#xff1a; 算法复杂度&#xff1a; 最坏情况&#xff1a; 最好的情况&#xff1a; 直接插入排序的特性总结&…
阅读更多...
思维商业篇(2)—业务第一性

思维商业篇(2)—业务第一性

思维商业篇(2)—业务第一性 前言 第一性原理是超过因果律的第一因&#xff0c;且是唯一因。 第一性原理是事物唯一的源头&#xff0c;是抽象。是看透事物的本质&#xff0c;要把事物分解成最基本的组成&#xff0c;从源头上去解决问题。 对于一个企业来说&#xff0c;第一性…
阅读更多...
01，大数据总结，zookeeper

01，大数据总结，zookeeper

1 &#xff0c;zookeeper &#xff1a;概述 1.1&#xff0c;zookeeper&#xff1a;作用 1 &#xff0c;大数据领域 &#xff1a;存储配置数据   例如&#xff1a;hadoop 的 ha 配置信息&#xff0c;hbase 的配置信息&#xff0c;都存储在 zookeeper 2 &#xff0c;应用领…
阅读更多...
PXE服务

PXE服务

一.PXE服务的功能介绍 1.无盘启动&#xff1a;PXE允许计算机在没有本地存储设备的情况下启动操作系统。这对于构建无盘工作站非常有用&#xff0c;因为计算机可以直接从网络加载操作系统和其他应用程序1。 2.远程安装操作系统&#xff1a;PXE技术可以用于远程安装操作系统&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023