【JAVA学习之路 | 提高篇】线程安全问题及解决

简介: 【JAVA学习之路 | 提高篇】线程安全问题及解决

1.前言

当我们使用多个线程访问同一资源时(可以是同一变量,同一文件,同一条记录),若多个线程只要只读操作,则不会发生线程安全问题;如果多个线程既有可读又有可写操作时,将可能导致线程安全问题.

2.提出问题

例 : 三个人对银行账户存储的100块存款进行取钱,如果该账户还有存款,就可以取.该问题可能发生线程安全问题吗?

3.继承Thread类的方式进行模拟 :

public class ThreadTest {
    public static void main(String[] args) {
        MulterThread t1 = new MulterThread("线程-1");
        MulterThread t2 = new MulterThread("线程-2");
        MulterThread t3 = new MulterThread("线程-3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class MulterThread extends Thread {
    static int change = 100;
    public MulterThread() {
        super();
    }
 
    public MulterThread(String name) {
        super(name);
    }
 
    @Override
    public void run() {
        while(true) {
            if (change > 0) {
                System.out.println(Thread.currentThread().getName() + "\t\t" + change);
                change--;
            } else {
                break;
            }
 
        }
    }
}
 
控制台 : 
//显然有问题,100的时候被取的两次
线程-2    100
线程-1    100
线程-2    99
线程-1    98
线程-2    97
线程-1    96
线程-2    95
线程-1    94
线程-1    92
线程-2    93

注 :


  • 为什么change变量要声明为static : 如果不声明为static,那么new了三个MulterThread对象,就会有300块的存款,与抢占同一资源的场景不符.
  • 为什么会出现两次100呢 : 很显然,每次运行结果不一样,按该次运行结果举例.当线程2调用run()方法进入输出语句的时候,执行到下一句change--还需要一段时间,而此时线程1也调用了run(),并也执行到了输出语句,此时change--语句并未执行,所以二者都打印的是100.

3.实现Runnable接口的方法进行模拟

public class RunnableTest {
    public static void main(String[] args) {
        A a = new A();
        Thread t1 = new Thread(a);
        Thread t2 = new Thread(a);
        Thread t3 = new Thread(a);
        t1.start();
        t2.start();
        t3.start();
    }
 
}
class A implements Runnable{
    int change = 100;
    @Override
    public void run() {
        while (true) {
            if (change > 0) {
                System.out.println(Thread.currentThread().getName() + "\t\t" + change);
                change--;
            } else {
                break;
            }
 
        }
    }
}
 
控制台 : 
Thread-1    100
Thread-1    99
Thread-1    98
Thread-0    100
Thread-1    97
Thread-0    96
Thread-2    100
Thread-0    94
Thread-1    95
Thread-1    91

注 :

  • 为什么change变量不用static修饰 : 只调用一次new创建了A的一个对象,并作为同一个实参传入到Thread类中.因为只new了一次,所以change只有一份.
  • 为什么会出现三次100 : 与上同.

4.解决方案

必须满足一个线程在操作change时,其他线程必须等待,直到该线程操作完成后,其他线程才可以进来操作change.

5.方式1 : 同步代码块

(1). 格式

synchronized(同步监视器){

    //需要被同步的代码

}

(2). 利用同步监视器来解决继承Thread类带来的线程安全问题.


注 : 为什么该处同步监视器不用this,而是用MulterThread.class呢?


因为创建了三个Thread类对象,this表示调用run方法的实例对象,三个对象都启动线程调用run方法,this有可能是t1,t2,t3,并不唯一.

@Override
    public void run() {
        while(true) {
            synchronized (MulterThread.class){
                if (change > 0) {
                    System.out.println(Thread.currentThread().getName() + "\t\t" + change);
                    change--;
                } else {
                    break;
                }
            }
 
        }
    }

(3). 利用同步监视器来解决实现接口带来的线程安全问题 :

@Override
    public void run() {
        while (true) {
            synchronized (this){
                if (change > 0) {
                    System.out.println(Thread.currentThread().getName() + "\t\t" + change);
                    change--;
                } else {
                    break;
                }
            }
 
        }
    }

说明 :


  • 需要被同步的代码,即为操作共享数据的代码.
  • 共享数据 : 即多个线程可以操作的数据 : 如该处的change.
  • 需要被同步的代码,在被synchronized包裹后,就使得一个线程操作共享数据时,其他线程需等待.
  • 同步监视器 : 哪个线程获得了锁,哪个线程就可以执行被同步的代码.
  • 同步监视器可以由任何对象充当,但必须多个线程共用同一个同步监视器.(即该监视器必须唯一).
  • 继承Thread类 : 同步监视器---->类名.class
  • 实现接口 : 同步监视器------>this

6.同步方法

public synchronized void Xxx(){

    //被同步的代码

}

由于同步方法的同步监视器默认是this,所以更适用于实现Runnable接口的方式.(如果是继承Thread类的方式,this一般不唯一.)

如果该方法是静态同步方法,默认的则是该类

    boolean isFlag = true;
    @Override
    public void run() {
        while (isFlag) {
            show();
        }
    }
    //同步方法
    //默认的同步监视器是this
    public synchronized void show() {
        if (change > 0) {
            System.out.println(Thread.currentThread().getName() + "\t\t" + change);
            change--;
        } else {
            isFlag = false;
        }
    }

7.同步监视器

同步监视器(Synchronized Monitor)是Java中一种内置的同步机制,用于确保多个线程对共享资源的互斥访问。当一个线程进入一个被synchronized修饰的方法或代码块时,它会获取一个同步监视器对象,其他线程必须等待该线程释放监视器才能继续执行。


问题 : 同步监视器不唯一会导致锁不住的问题


因为在Java中,每个对象都有一个内置的锁(也称为监视器锁),当多个线程尝试访问同一个对象的同步方法或同步代码块时,这些线程需要竞争这个锁。如果同步监视器不唯一,那么可能会出现多个线程同时持有不同对象的锁,从而导致锁不住的问题。


相关文章
|
1天前
|
Java 开发者
线程的诞生之路:Java多线程创建方法的抉择与智慧
【6月更文挑战第19天】Java多线程编程中,开发者可选择继承Thread类或实现Runnable接口。继承Thread直接但受限于单继承,适合简单场景;实现Runnable更灵活,支持代码复用,适用于如银行转账这类需多线程处理的复杂任务。在资源管理和任务执行控制上,Runnable接口通常更优。
|
1天前
|
Java
Java 多线程新手必读:线程的创建技巧与陷阱
【6月更文挑战第19天】Java多线程初学者须知:创建线程可通过继承`Thread`或实现`Runnable`接口。继承`Thread`限制单继承,实现`Runnable`更灵活。记得调用`start()`而非`run()`启动线程,避免并发问题时需正确同步共享资源。示例代码展示两种创建方式及未同步导致的问题。
|
1天前
|
Java
揭秘!为何Java多线程中,继承Thread不如实现Runnable?
【6月更文挑战第19天】在Java多线程中,实现`Runnable`比继承`Thread`更佳,因Java单继承限制,`Runnable`可实现接口复用,便于线程池管理,并分离任务与线程,提高灵活性。当需要创建线程或考虑代码复用时,实现`Runnable`是更好的选择。
|
1天前
|
Java 开发者
从菜鸟到大神:Java 多线程创建的两大流派,你属于哪一种?
【6月更文挑战第19天】Java多线程编程中,创建线程有两种主要方式:继承`Thread`类和实现`Runnable`接口。继承`Thread`直接重写`run()`,简单易懂,但限制了单继承。实现`Runnable`接口更灵活,允许多接口实现,利于资源共享和代码组织。新手可能偏好继承,但高手常选`Runnable`以遵循面向对象设计。不断学习和实践,才能在Java多线程领域深化。
|
1天前
|
Java
JAVA多线程深度解析:线程的创建之路,你准备好了吗?
【6月更文挑战第19天】Java多线程编程提升效率,通过继承Thread或实现Runnable接口创建线程。Thread类直接继承启动简单,但限制多继承;Runnable接口实现更灵活,允许类继承其他类。示例代码展示了两种创建线程的方法。面对挑战,掌握多线程,让程序高效运行。
|
1天前
|
安全 Java 调度
Java并发编程:优化多线程应用的性能与安全性
在当今软件开发中,多线程编程已成为不可或缺的一部分,尤其在Java应用程序中更是如此。本文探讨了Java中多线程编程的关键挑战和解决方案,重点介绍了如何通过合理的并发控制和优化策略来提升应用程序的性能和安全性,以及避免常见的并发问题。
10 1
|
1天前
|
Java 开发者
JAVA多线程初学者必看:为何选择继承Thread还是Runnable,这其中有何玄机?
【6月更文挑战第19天】在Java中创建线程,可选择继承Thread类或实现Runnable接口。继承Thread直接运行,但限制了多重继承;实现Runnable更灵活,允许多线程共享资源且利于代码组织。推荐实现Runnable接口,以保持类的继承灵活性和更好的资源管理。
|
1月前
|
安全 Java
java保证线程安全关于锁处理的理解
了解Java中确保线程安全的锁机制:1)全局synchronized方法实现单例模式;2)对Vector/Collections.SynchronizedList/CopyOnWriteArrayList的部分操作加锁;3)ConcurrentHashMap的锁分段技术;4)使用读写锁;5)无锁或低冲突策略,如Disruptor队列。
21 2
|
20天前
|
存储 安全 Java
深入理解Java并发编程:线程安全与锁机制
【5月更文挑战第31天】在Java并发编程中,线程安全和锁机制是两个核心概念。本文将深入探讨这两个概念,包括它们的定义、实现方式以及在实际开发中的应用。通过对线程安全和锁机制的深入理解,可以帮助我们更好地解决并发编程中的问题,提高程序的性能和稳定性。
|
22天前
|
安全 Java API
Java 8中的Stream API:简介与实用指南深入理解Java并发编程:线程安全与锁优化
【5月更文挑战第29天】本文旨在介绍Java 8中引入的Stream API,这是一种用于处理集合的新方法。我们将探讨Stream API的基本概念,以及如何使用它来简化集合操作,提高代码的可读性和效率。 【5月更文挑战第29天】 在Java并发编程中,线程安全和性能优化是两个核心议题。本文将深入探讨如何通过不同的锁机制和同步策略来保证多线程环境下的数据一致性,同时避免常见的并发问题如死锁和竞态条件。文章还将介绍现代Java虚拟机(JVM)针对锁的优化技术,包括锁粗化、锁消除以及轻量级锁等概念,并指导开发者如何合理选择和使用这些技术以提升应用的性能。