Java多线程04—同步方法解决线程的安全问题

简介: Java多线程04—同步方法解决线程的安全问题

同步方法解决线程的安全问题

@[toc]

处理实现Runnable的线程安全问题

  • 如果操作共享数据的代码完整的声明在一个方法中,我们可以将此方法声明为同步的

(ps:相当于把操作共享数据的部分放在另外一个方法之中,再把这个方法写成synchronized的,然后run方法去调用这个方法)

代码部分:

package com.jsm.java2;
//这里用实现Runnable接口的方式做之前抢票的例题
public class WindowTest2 {
    public static void main(String[] args) {
        Window2 w1 = new Window2();

        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);
        t1.start();
        t2.start();
        t3.start();
    }
}
class Window2 implements Runnable{
    private int num =100;//未加static,因为此时三个线程共用同一个num,此时只造了一个对象
    @Override
    public void run() {
        while (true){
            show();
            if (num==0){
                break;//不判断的话线程需要手动关闭
            }
        }
    }
    public synchronized void show(){
        if (num>0){
            System.out.println(Thread.currentThread().getName()+"卖出的票号为:"+num);
            num--;
        }
    }
}

处理继承Thread类的线程安全问题

  • 该种情况不能像上面那样直接另外写一个synchronized方法来调用,因为锁的问题,这钟情况下建了多个对象锁不唯一
  • 这种情况下考虑把方法写成静态的
package com.jsm.java2;
/*
同步方法处理继承Thread类的线程安全问题
 */
class WindowTest1 {
    public static void main(String[] args) {
        Window3 w1 = new Window3();
        Window3 w2 = new Window3();
        Window3 w3 = new Window3();

        w1.start();
        w2.start();
        w3.start();
    }
}
class Window3 extends Thread{

    private static int num =100;
    @Override
    public void run() {
        while (num>0){
            show();
            if (num == 0) {
                break;
            }
        }

    }
    private static synchronized void show(){//同步监视器:Window3.class
        if (num>0){
            System.out.println(Thread.currentThread().getName()+":卖票,票号为:"+num);
            num--;
        }
    }
}

总结

  • 同步方法仍然涉及到同步监视器,只是不需要显式的声明
  • 非静态的同步方法,同步监视器是:this
  • 静态的同步方法,同步监视器是:当前类本身


使用同步机制将单例模式中的懒汉式改写为线程安全的

在文章:Java设计模式之单例设计模式

原代码:

package day2;
//单例设计模式的懒汉式实现
public class SingletonTest2 {
}
class Order{
    //1.私有化类的构造器
    private Order(){

    }
    //2.声明当前类对象,没有初始化
    //4.此对象也必须声明为static的
    private static Order o1=null;

    //3.声明public 、static的返回当前类的方法
    public static Order getO1(){
        if (o1==null){
            o1= new Order();
        }
        return o1;
    }
}
//ps:懒汉式暂时还存在线程安全问题,后面多线程时,可修复

线程安全问题原因:就是调用get01方法的时候,第一个线程调用的时候判断o1为null,所以就正打算去new对象,结果这时候发生堵塞或者cpu执行别的任务了,另一个线程进来也判断为空了,就又去准备new一个对象,相当于先后被两次赋值过。


使用同步机制将单例模式中的懒汉式改写为线程安全的

package com.jsm.java1;
//使用同步机制将单例模式中的懒汉式改写为线程安全的
public class BankTest {
}
class Order{

  
    private Order(){

    }
    
    private static Order o1=null;
    //方式一:同步方法
    public synchronized static Order get01(){
        if (o1==null){
            o1=new Order();
        }
        return o1;
    }
    //方法二:同步代码,但是效率稍差,因为除了第一次线程进去需要new一个对象,后面线程进去其实都不需要new一个对象
    /* public static Order get01(){

        synchronized (Order.class) {
            if (o1==null){
                o1=new Order();
            }
            return o1;
        }
    }
    */
    
}

此时的锁:静态的同步方法,同步监视器是:当前类本身,所以是Order.class

PS:方法二形象举例讲解:就好像买新发布的鞋一样,只有一双,但是一次只能进去一个人,大家不知道只有一双,而且假设进去的人出来后没法和等待的人接触,然后进去第一个人买到了,走了,又进去第二个人,然后说卖完了,走了,然后又进去第三个人,又说买完了,又走了,以此类推,后面每个人都进去走一次,后面的人的等待就是浪费时间。

代码更改为

public static Order get01() {
    if (o1 == null) {
        synchronized (Order.class) {
            if (o1 == null) {
                o1 = new Order();
            }
        }
        
    }
    return o1;
}

这样的效率更高的原因:在进入操作共享数据的代码块之前就对是否o1==null进行一次判断,可能着时候有多个线程挤进来了,但是还不涉及对共享数据进行操作,所以进行判断之后就看谁运气好抢到了位置进到了对共享数据的操作部分,举个例子,一下子有ABC三个线程进入了第一次if判断语句,可能产生堵塞,三个都判断为null,所以都进来了,但是遇见了synchronized,只能ABC三个抢位置看谁先进入,这时候假设B进入了,然后B判断为空,new了一个对象,走了,后面两个又重新进来,重新判断,都不为空,然后都出去了,但是ABC之后的又线程又进来,这时候第一层if语句就已经把所有线程记之门外了,所以就不用再进去判断,直接return o1出去了,所以这样更加提高了效率。

目录
相关文章
|
3月前
|
安全 算法 Java
Java 多线程:线程安全与同步控制的深度解析
本文介绍了 Java 多线程开发的关键技术,涵盖线程的创建与启动、线程安全问题及其解决方案,包括 synchronized 关键字、原子类和线程间通信机制。通过示例代码讲解了多线程编程中的常见问题与优化方法,帮助开发者提升程序性能与稳定性。
143 0
|
3月前
|
数据采集 监控 调度
干货分享“用 多线程 爬取数据”:单线程 + 协程的效率反超 3 倍,这才是 Python 异步的正确打开方式
在 Python 爬虫中,多线程因 GIL 和切换开销效率低下,而协程通过用户态调度实现高并发,大幅提升爬取效率。本文详解协程原理、实战对比多线程性能,并提供最佳实践,助你掌握异步爬虫核心技术。
|
4月前
|
Java 数据挖掘 调度
Java 多线程创建零基础入门新手指南:从零开始全面学习多线程创建方法
本文从零基础角度出发,深入浅出地讲解Java多线程的创建方式。内容涵盖继承`Thread`类、实现`Runnable`接口、使用`Callable`和`Future`接口以及线程池的创建与管理等核心知识点。通过代码示例与应用场景分析,帮助读者理解每种方式的特点及适用场景,理论结合实践,轻松掌握Java多线程编程 essentials。
249 5
|
5月前
|
机器学习/深度学习 消息中间件 存储
【高薪程序员必看】万字长文拆解Java并发编程!(9-2):并发工具-线程池
🌟 ​大家好,我是摘星!​ 🌟今天为大家带来的是并发编程中的强力并发工具-线程池,废话不多说让我们直接开始。
192 0
|
8月前
|
Linux
Linux编程: 在业务线程中注册和处理Linux信号
通过本文,您可以了解如何在业务线程中注册和处理Linux信号。正确处理信号可以提高程序的健壮性和稳定性。希望这些内容能帮助您更好地理解和应用Linux信号处理机制。
134 26
|
8月前
|
Linux
Linux编程: 在业务线程中注册和处理Linux信号
本文详细介绍了如何在Linux中通过在业务线程中注册和处理信号。我们讨论了信号的基本概念,并通过完整的代码示例展示了在业务线程中注册和处理信号的方法。通过正确地使用信号处理机制,可以提高程序的健壮性和响应能力。希望本文能帮助您更好地理解和应用Linux信号处理,提高开发效率和代码质量。
138 17
|
10月前
|
存储 安全 Java
Java多线程编程秘籍:各种方案一网打尽,不要错过!
Java 中实现多线程的方式主要有四种:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点,适用于不同的场景。继承 Thread 类最简单,实现 Runnable 接口更灵活,Callable 接口支持返回结果,线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外,还介绍了多线程相关的常见面试问题及答案,涵盖线程概念、线程安全、线程池等知识点。
599 2
|
11月前
|
设计模式 Java 开发者
Java多线程编程的陷阱与解决方案####
本文深入探讨了Java多线程编程中常见的问题及其解决策略。通过分析竞态条件、死锁、活锁等典型场景,并结合代码示例和实用技巧,帮助开发者有效避免这些陷阱,提升并发程序的稳定性和性能。 ####
|
11月前
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱,如竞态条件、死锁和内存一致性错误,并提供了实用的避免策略。通过分析典型错误案例,本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧,从而提升并发程序的稳定性和性能。 ####
|
10月前
|
缓存 Java 调度
多线程编程核心:上下文切换深度解析
在现代计算机系统中,多线程编程已成为提高程序性能和响应速度的关键技术。然而,多线程编程中一个不可避免的概念就是上下文切换(Context Switching)。本文将深入探讨上下文切换的概念、原因、影响以及优化策略,帮助你在工作和学习中深入理解这一技术干货。
239 10