Java学习日志(十一): 线程安全，线程同步

最新推荐文章于 2024-05-14 16:15:34 发布
最新推荐文章于 2024-05-14 16:15:34 发布
阅读量784 收藏 3
点赞数 2
分类专栏： JavaEE学习日志 文章标签： java javaee javase 多线程 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sakuraaaaaaa/article/details/104209972
版权

JavaEE学习日志持续更新----> 必看！JavaEE学习路线（文章总汇）

Java学习日志（十一）

线程安全

产生原理

若有三个电影院同时上映了战狼3，每个电影院要卖100张不同号码的电影票，三位电影院老板有了三种不同的卖票思路。

第一位老板：设置了一个售卖窗口，这个窗口卖1-100号码的票，则不会出现问题，此时则为单线程程序，不会出现线程安全问题。
在这里插入图片描述
第二位老板：设置了三个售卖窗口，第一个窗口卖1-33号的票，第二个窗口卖34-67号的票，第三个窗口卖68-100号的票，则不会出现问题，此时则为多线程程序，但不访问共享资源，不会出现线程安全问题。
在这里插入图片描述
第三位老板：设置了三个售卖窗口，三个窗口同时卖1-100号的票，则出现了问题，此时则为多线程程序，访问了共享资源，会出现线程安全问题。

在这里插入图片描述

代码模拟：

/*
    卖票案例
 */
public class RunnableImpl implements Runnable {
    //定义共享票源
    private int ticket = 100;
    //线程任务：卖票
    @Override
    public void run() {
        //卖票重复执行
        while(true){
            //增加一个判断，票大于0
            if(ticket>0){
            	//添加sleep方法，增加线程安全问题出现的几率
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //卖票操作
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票！");
                ticket--;
            } else {
                break;
            }
        }
    }
}
/*
    开启三个线程，同时进行卖票
 */
public class Demo01PayTicket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl r = new RunnableImpl();
        //创建三个线程
        Thread t0 = new Thread(r,"售票员A");
        Thread t1 = new Thread(r,"售票员B");
        Thread t2 = new Thread(r,"售票员C");
        //开启新的线程
        t0.start();
        t1.start();
        t2.start();
    }
}

结果：出现安全问题

...
售票员C正在卖第16张票！
售票员A正在卖第16张票！
售票员B正在卖第14张票！
售票员A正在卖第13张票！
售票员C正在卖第12张票！
售票员B正在卖第11张票！
售票员A正在卖第10张票！
售票员C正在卖第10张票！
售票员B正在卖第8张票！
售票员A正在卖第7张票！
售票员C正在卖第7张票！
售票员B正在卖第5张 票！
售票员A正在卖第4张票！
售票员C正在卖第4张票！
售票员B正在卖第2张票！
售票员C正在卖第1张票！
售票员A正在卖第0张票！
售票员B正在卖第-1张票！

线程安全问题产生的原因：

售票员C正在卖第1张票！
售票员A正在卖第0张票！
售票员B正在卖第-1张票！

第一种安全问题：出现-1和0张票的原因（出现超出if语句范围的数值）
①售票员C线程抢到了cpu的执行权，进入到run中执行，执行到了if语句中，碰到sleep，睡眠，失去cpu的执行权。
②售票员A线程抢到了cpu的执行权，进入到run中执行，执行到了if语句中，碰到sleep，睡眠，失去cpu的执行权。
③售票员B线程抢到了cpu的执行权，进入到run中执行，执行到了if语句中，碰到sleep，睡眠，失去cpu的执行权。
④售票员C线程睡醒了，继续执行程序进行卖票。

售票员C正在卖第1张票！
ticket--;ticket = 0;

`⑤售票员A线程睡醒了，继续执行程序进行卖票。

售票员A正在卖第0张票
ticket--;ticket = -1;

`⑥售票员B线程睡醒了，继续执行程序进行卖票。

售票员B正在卖第-1张票！
ticket--;ticket = -2;

第二种安全问题：出现重复卖票的原因

售票员A正在卖第10张票！
售票员C正在卖第10张票！
售票员B正在卖第8张票！

售票员A和售货员C两个线程都在打印正在卖第10张票，这时候ticket还没有进行自减操作。之后ticket自减两次，所以第9张票消失，售票员B只能卖第8张票。

线程同步

解决线程安全的第一种方式：同步代码块

格式：

 synchronized(锁对象){
        出现安全问题的代码（访问了共享数据的代码）
 }

注意事项：

  1. 锁对象可以是任意对象 new Person，new Student
  2. 锁对象必须保证多个线程使用的是同一个锁对象
  3. 锁对象的作用：把括号中的代码锁住，只让一个线程进去执行

示例：卖票案例

public class RunnableImpl implements Runnable {
    private int ticket = 100;
    //在成员位置创建一个锁对象
    Object obj = new Object();

    @Override
    public void run() {
        while(true){
            synchronized (obj){
                //访问了共享数据的代码
                if(ticket>0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票！");
                    ticket--;
                }
            }
        }
    }
}
public class Demo01PayTicket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl r = new RunnableImpl();
        //创建三个线程
        Thread t0 = new Thread(r,"售票员A");
        Thread t1 = new Thread(r,"售票员B");
        Thread t2 = new Thread(r,"售票员C");
        //开启新的线程
        t0.start();
        t1.start();
        t2.start();
    }
}

同步技术的原理：使用了一个锁对象，这个锁对象也叫同步锁，还叫对象监视器

当线程执行到同步代码块的时候，会判断同步代码中，是否有锁对象：
如果有，那么这个线程就会获取锁对象，进入到同步中执行，在执行过程中，无论是否失去了CPU的执行权，都不会释放锁对象，线程执行完同步中的代码，才会把锁对象归还给同步代码。
如果没有，那么这个线程就会进入阻塞状态，在同步外边一直等待同步中的线程归还锁对象，直到同步中的线程把锁对象归还，才能获取锁对象进入到同步中执行。

总结：

  1. 没有锁对象，进不去同步
  2. 同步中的对象没有执行完，也不会归还锁

这样就保证只有一个线程在同步中执行，代码就安全了

问题：程序频繁判断锁，获取锁，归还锁，效率就会降低

解决线程安全的第二种方式：同步方法

格式：

 修饰符 synchronized 返回值类型 方法名(参数列表){
        出现安全问题的代码
 }

使用步骤：

  1. 创建一个方法，方法的修饰符添加上synchronized
  2. 把访问了共享数据的代码放入到方法中
  3. 调用同步方法

注意：同步方法的锁对象就是this（本类对象 new RunnableImpl）

示例：卖票案例

public class RunnableImpl implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            //3.调用同步方法
            payTicket();
        }
    }

    /*
        定义一个方法
        1.创建一个方法，方法的修饰符添加上synchronized

     */
    public synchronized void payTicket() {
        //2.把访问了共享数据的代码放入到方法中
        //访问了共享数据的代码
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票！");
            ticket--;
        }
    }
}
public class Demo01PayTicket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl r = new RunnableImpl();
        //创建三个线程
        Thread t0 = new Thread(r,"售票员A");
        Thread t1 = new Thread(r,"售票员B");
        Thread t2 = new Thread(r,"售票员C");
        //开启新的线程
        t0.start();
        t1.start();
        t2.start();
    }
}

扩展：静态同步方法
静态同步方法（优先于对象加载到内存中）：锁对象是的class文件对象(反射)RunnableImpl.class–>唯一

示例：卖票案例

public class RunnableImpl implements Runnable {
    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            //3.调用同步方法
            payTicket();
        }
    }

    /*
        定义一个方法
        1.创建一个方法，方法的修饰符添加上synchronized

     */
    //静态同步方法（优先于对象加载到内存中）：锁对象是的class文件对象(反射)RunnableImpl.class-->唯一
    public static synchronized void payTicket() {
        //2.把访问了共享数据的代码放入到方法中
        //访问了共享数据的代码
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票！");
            ticket--;
        }
    }
}
public class Demo01PayTicket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl r = new RunnableImpl();
        //创建三个线程
        Thread t0 = new Thread(r,"售票员A");
        Thread t1 = new Thread(r,"售票员B");
        Thread t2 = new Thread(r,"售票员C");
        //开启新的线程
        t0.start();
        t1.start();
        t2.start();
    }
}

解决线程安全的第三种方式：使用Lock锁

java.util.concurrent.locks.Lock接口
JDK1.5之后的新特性，Lock实现提供了比使用synchronized方法和语句可以获得的更广泛的锁定操作。

Lock接口中的方法：

  • void lock() 获得锁。
  • void unlock() 释放锁。

实现类：java.util.concurrent.locks.ReentrantLock implements Lock

使用步骤：

  1. 在成员位置创建一个Lock接口的实现类对象ReentrantLock
  2. 在可能会出现安全问题的代码前，调用Lock方法获取锁对象
  3. 在可能会出现安全问题的代码后，调用Lock方法释放锁对象

示例：卖票案例

public class RunnableImpl implements Runnable {
    //1.在成员位置创建一个Lock接口的实现类对象ReentrantLock
    Lock l = new ReentrantLock();

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            //2.在可能会出现安全问题的代码前，调用Lock方法获取锁对象
            l.lock();
            if (ticket > 0) {
                try {
                    Thread.sleep(10);
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票！");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //无论程序是否异常，都会把锁对象释放，节约内存，提高程序效率
                    //3.在可能会出现安全问题的代码后，调用Lock方法释放锁对象
                    l.unlock();
                }
            }
        }
    }
}
public class Demo01PayTicket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl r = new RunnableImpl();
        //创建三个线程
        Thread t0 = new Thread(r,"售票员A");
        Thread t1 = new Thread(r,"售票员B");
        Thread t2 = new Thread(r,"售票员C");
        //开启新的线程
        t0.start();
        t1.start();
        t2.start();
    }
}
隔叶听风
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
多线程编写同一个txt日志
09-02
线程 编写 txt日志 临界代码区 数组模版 错误消息打印
线程安全的JAva日志类
boyhailong的专栏
10-20 1595
暂时是学习吧，测试还没成功，但是先记录下，就是单例类，创建文件，写文件。是线程安全的。 package myPackage; import java.io.BufferedWriter; import java.io.File; import java.io.FileOutputStream; import java.io.FileWriter; import java.io.IOExce
java学习日志（十二）-- 线程安全
铁匠铺掌柜的博客
03-27 500
1.多线程的运行出现了安全性问题——通过分析，发现下程序打印0，-1，-2等错票。 问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部份，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。 解决办法：对多条操作数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以执行。 java对于多线程的安全问题提供了专业的解决方式。 同步代码块。
线程安全的日志类设计
a348731263的博客
02-13 273
最近在写多线程方面的内容, 其实多线程开发设计清楚了在写, 并不会有太大的坑, 尽管如此, 难免有需要调试的时候, 多线程的程序单步调试有时候难以发现bug, 通过记录日志, 可以用来查找问题, 方便调试. 其实有不少开源的C++日志库, 比如大名鼎鼎的log4cxx, 轻量级的glog, 还有一些热心的同行提供的开源工程, 我大体看了几个, 觉得不是很符合我的胃口, 于是就花了一天的...
c++写日志 线程安全
一个草根敲键盘的故事
05-14 415
#include <iostream> #include <thread> #include "Abnormality.h" int _stdcall video_work(void*arg) { FILE *fp = (FILE *)arg; int index = 100; while (index--) { bugs(fp," i=%d\n", index); } return 0; } int main() { FILE *fp = NULL; .
Java毕业设计-Java多线程与线程安全实践-基于Http协议的断点续传.rar
03-22
为了避免数据不一致和竞争条件，项目使用了Java的同步机制（如synchronized关键字、Lock接口等）来确保线程安全。 3. 断点续传：项目基于Http协议实现了断点续传功能。当下载过程中出现异常或网络中断时，可以从...
Linux多线程服务端编程：使用muduo C++网络库
08-17
第2章线程同步精要 2.1互斥器（mutex）. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 2.1.1只使用非递归的mutex . . . . . . . . . . . . . .. . . . . . . . . . 33 2.1.2死锁. . . . . . . ....
java8stream源码-SharedBookmark:同步我的工作书签
06-04
java8 stream 源码 Table of Contents 杂项 油猴 jobs 面试 Java面试题 算法面试题 linux面试题 misc Java misc Netty Java8 Java9 泛型 网络编程 多线程 单元测试 应用示例 JDBC 序列化 JVM IO NIO 集合 Map List ...
netty-starter:Netty权威指南学习之旅
04-30
Netty学习day01：同步阻塞式I/O源码分析服务端TimerServerTimerServer根据传入的参数设置监听端口，如果没有入参，使用默认值8080。启动后会发现主线程阻塞在ServerSocket的accept()方法上：可通过JConsole查看线程...
【白雪红叶】JAVA学习技术栈梳理思维导图.xmind
04-25
关于java程序员发展需要学习的路线整理集合 技术 应用技术 计算机基础知识 cpu mem disk net 线程，进程 第三方库 poi Jsoup zxing Gson 数据结构 树 栈 链表 队列 图 操作系统 linux 代码控制...
【Java】 线程安全 synchronized
程序猿开发日志【学习永无止境】
09-14 557
一、线程安全问题： 并发编程的原则：设计并发编程的目的是为了使程序获得更高的执行效率，但绝不能出现数据一致性(数据准确)问题，如果并发程序连最基本的执行结果准确性都无法保证，那并发编程就没有任何意义。 为什么会出现数据不正确： 如果一个资源（变量，对象，文件，数据库）可以同时被很多线程使用就会出现数据不一致问题，也就是我们说的线程安全问题。这样的资源被称为共享资源或临界区。
Java日志
aaha58009的博客
02-27 80
Java常用日志框架历史 1996年早期，欧洲安全电子市场项目组决定编写它自己的程序跟踪API（Tracing API）。经过不断的改善，这个API终于成为一个十分受欢迎的Java日志软件包，即Log4j。后来，Log4j成为Apache基金会项目中的一员。 期间Log4j近乎成了Java社区的日志标准。据说Apache基金会还曾经建议Sun引入Log4j到Java的标准库中，但...
[完全随笔]日志线程的线程同步
weixin_33811961的博客
04-30 90
            在一个很小的应用程序中，我想加入记录日志的功能，已辅助分析判断一些诸如登录被拒绝等事件的原因。由于这个小程序是一个对话框程序，基本都是在内存中运行的，而记录日志则需要频繁的开闭文件，写文件，从“自觉”感觉我有一点担心记录日志会影响运行效率。因此为了不影响UI线程的响应性能，我决定新开一个单独的线程专门做这件事，称其为“日志线程”。             同时，为了降低访...
十六.线程安全之同步
weixin_52735772的博客
09-20 61
线程安全之同步 守护线程(daemon) 线程分为用户线程和守护线程 虚拟机必须确保用户线程执行完毕 虚拟机不用等待守护线程执行完毕 后台日志记录，监控内存，垃圾回收等 同步机制(vital) 并发：同一个对象被多个线程同时操作 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候就需要线程同步(等待机制)，多个需要同时访问此对象的线程进入这个对象的等待池中， 形成队列，等待前面线程使用完毕后再使用。 队列和锁 由于同一进程中的多个线程共享一块存储空间，在带来方便的同时也带
多线程下面日志输出-线程安全-消息队列循环输出
chengseasee的专栏
08-25 2034
/×××××××××××Thread.h××××××××××××××/ #ifndef __THREAD__ #define __THREAD__ #ifdef WIN32 #include #include #else #include #include #endif using namespace std; class ThreadException {
java jar包如何运行或调用
NLP与推荐算法
05-08 344
java服务启动
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 410
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
java导出excel动态加载多sheet多复杂表头
最新发布
weixin_43931108的博客
05-14 121
java导出excel动态加载多sheet多复杂表头
【全面介绍下Spring】
2301_81357485的博客
05-11 556
Spring框架提供了用于构建Web应用程序的多个模块，如Spring MVC、Spring WebFlux和Spring Web Services。Spring使用IoC容器来管理应用组件之间的依赖关系，通过IoC，开发人员可以将对象的创建和组装转移给Spring容器来管理，从而降低了组件之间的耦合。🌈总之，Spring框架为Java应用程序开发提供了丰富的功能和强大的扩展性，它通过提供模块化的解决方案和简化开发流程，帮助开发人员更高效地构建高质量的企业级应用程序。
java log4j2如何避免多线程导致的日志错乱
05-31
为了避免这种情况，可以在log4j2配置文件中设置一个Appender的locking属性为true，这样在写入日志时会使用同步锁来保证线程安全。示例如下： ``` [%t] %m%n" /> <locking>true ``` 另外，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值