Java多线程中线程安全问题

简介: Java多线程中的线程安全问题主要涉及多线程环境下对共享资源的访问可能导致的数据损坏或不一致。线程安全的核心在于确保在多线程调度顺序不确定的情况下,代码的执行结果始终正确。常见原因包括线程调度随机性、共享数据修改以及原子性问题。解决线程安全问题通常需要采用同步机制,如使用synchronized关键字或Lock接口,以确保同一时间只有一个线程能够访问特定资源,从而保持数据的一致性和正确性。
上一篇传送门: 专治Java底子差,线程操作篇(1)

三、线程安全

3.1 线程安全问题

我们前面的操作线程与线程间都是互不干扰,各自执行,不会存在线程安全问题。当多条线程操作同一个资源时,发生写的操作时,就会产生线程安全问题;

我们来举一个案例,从广州开往南昌的票数共有100张票,售票窗口分别有“广州南站”、“广州北站”、“广州站”等。

  • 定义卖票任务:
package com.dfbz.demo01_线程安全问题引入;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Ticket implements Runnable {
    //票数
    private Integer ticket = 1000;
    @Override
    public void run() {
        while (true) {
            if (ticket <= 0) {
                break;      //票卖完了
            }
            System.out.println(Thread.currentThread().getName() + "正在卖第: " + (1001 - ticket) + "张票");
            ticket--;
        }
    }
}
  • 测试类:
package com.dfbz.demo01_线程安全问题引入;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_卖票案例 {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        //开启三个窗口,买票
        Thread t1 = new Thread(ticket, "广州南站");
        Thread t3 = new Thread(ticket, "广州北站");
        Thread t2 = new Thread(ticket, "广州站");
        t1.start();
        t2.start();
        t3.start();
    }
}

查看运行结果:

发现程序出现了两个问题:

  1. 有的票卖了多次
  2. 卖票顺序不一致

分析卖了多次票:

分析卖票顺序不一致:

3.2 线程同步

当我们使用多个线程访问同一资源的时候,且多个线程中对资源有写的操作,就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题,Java中提供了同步机制(synchronized)来解决。

根据案例简述:窗口1线程操作的时候,窗口2和窗口3线程只能在外等着,窗口1操作结束,窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候,其他线程不能修改该资源,等待修改完毕同步之后,才能去抢夺CPU资源,完成对应的操作,保证了数据的同步性,解决了线程不安全的现象。

Java中提供了三种方式完成同步操作:

  1. 同步代码块。
  2. 同步方法。
  3. 锁机制。

3.2.1 同步代码块

1)同步代码块改造买票案例

  • 同步代码块synchronized关键字可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。

语法:

synchronized(同步锁){
     需要同步操作的代码
}

同步锁

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁;

  1. 锁对象可以是任意类型。
  2. 多个线程对象 要使用同一把锁。
注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。

使用同步代码块改造代码:

package com.dfbz.demo01_线程安全问题引入;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Ticket implements Runnable {
    //票数
    private Integer ticket = 1000;
    //锁对象
    private Object obj = new Object();
    
    @Override
    public void run() {
        while (true) {
            // 加上同步代码块,把需要同步的代码放入代码块中,同步代码块中的锁对象必须保证一致!
            synchronized (obj) {
                if (ticket <= 0) {
                    break;      // 票卖完了
                }
                System.out.println(Thread.currentThread().getName() + "正在卖第: " + (1001 - ticket) + "张票");
                ticket--;
            }
        }
    }
}

2)同步代码块案例

案例:要么输出"犯我中华者",要么输出"虽远必诛"

package com.dfbz.demo02_线程安全;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_同步代码块小案例 {
    public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    synchronized (String.class) {
                        System.out.print("我");
                        System.out.print("是");
                        System.out.print("中");
                        System.out.print("国");
                        System.out.print("人");
                        System.out.println();
                    }
                }
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    synchronized (String.class) {
                        System.out.print("犯");
                        System.out.print("我");
                        System.out.print("中");
                        System.out.print("华");
                        System.out.print("者");
                        System.out.println();
                    }
                }
            }
        }.start();
    }
}

3)字节码对象

在使用同步代码块时,必须保证锁对象是同一个,才能实现线程的同步,不能使用不同的对象来锁不同的代码块;那么有什么对象只会存在一份的吗?答:任何类的字节码对象;

任何类的字节码对象都只会存在一次,在类加载的时候由JVM创建的;因此字节码锁也称为万能锁;

  • 获取一个类的字节码对象有三种方式:
package com.dfbz.demo02_线程安全;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02_字节码对象 {
    public static void main(String[] args) throws ClassNotFoundException {
        
        // 获取字节码对象的1种方式
        Class<String> c1 = String.class;
        // 获取字节码对象的2种方式
        String str = new String();
        Class<? extends String> c2 = str.getClass();
        // 获取字节码对象的3种方式
        Class<?> c3 = Class.forName("java.lang.String");
        System.out.println(c1 == c2);           // true
        System.out.println(c1 == c3);           // true
    }
}
Tips:以上三种方式都是获取JVM创建的字节码对象,而不是创建一个字节码对象,所有类的字节码对象都是在类加载的时候由JVM创建的;
  • 使用字节码对象来作为锁对象:
package com.dfbz.demo02_线程安全;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo03_使用字节码对象作为锁 {
    public static void main(String[] args) {
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                synchronized (Object.class) {           // 使用字节码对象作为锁对象
                    System.out.print("犯");
                    System.out.print("我");
                    System.out.print("中");
                    System.out.print("华");
                    System.out.print("者");
                    System.out.println();
                }
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                synchronized (Object.class) {           // 使用字节码对象作为锁对象
                    System.out.print("虽");
                    System.out.print("远");
                    System.out.print("必");
                    System.out.print("诛");
                    System.out.println();
                }
            }
        }).start();
    }
}

3.2.2 同步方法

1)普通同步方法

  • 同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
注意:同步方法也是有锁对象的,对于静态方法的锁对象的当前类的字节码对象(.class),对于非静态的方法的锁对象是this;

语法:

public synchronized void method(){
           可能会产生线程安全问题的代码
}

使用同步方法:

package com.dfbz.demo02_线程安全;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo04_同步方法 {
    public static void main(String[] args) {
        Shower shower = new Shower();
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    shower.print1();
                }
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    shower.print2();
                }
            }
        }.start();
    }
}
class Shower {
    // 普通方法的锁对象是this
    public synchronized void print1() {
        System.out.print("犯");
        System.out.print("我");
        System.out.print("中");
        System.out.print("华");
        System.out.print("者");
        System.out.println();
    }
    public void print2() {
        synchronized (this) {
            System.out.print("虽");
            System.out.print("远");
            System.out.print("必");
            System.out.print("诛");
            System.out.println();
        }
    }
}

2)静态同步方法

普通同步方法的锁对象是当前对象的引用(this),静态同步方法的锁对象是当前类的字节码对象;

  • 示例代码:
package com.dfbz.demo02_线程安全;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo05_静态同步方法 {
    public static void main(String[] args) {
        Print print = new Print();
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    print.print1();
                }
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    print.print2();
                }
            }
        }.start();
    }
}
class Print{
    // 静态同步方法的锁对象是当前类的字节码对象
    public static synchronized void print1() {
        System.out.print("犯");
        System.out.print("我");
        System.out.print("中");
        System.out.print("华");
        System.out.print("者");
        System.out.println();
    }
    public void print2() {
        synchronized (Print.class) {
            System.out.print("虽");
            System.out.print("远");
            System.out.print("必");
            System.out.print("诛");
            System.out.println();
        }
    }
}

3.2.3 Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,它是用于管理和控制线程之间共享资源的同步机制之一。 与传统的synchronized关键字相比,Lock接口提供了更细粒度的控制,例如公平性、可重入性等。此外,Lock接口还支持中断锁的获取和超时获取,这是synchronized关键字所不具备的功能。

Lock加锁与释放锁方法化了,如下:

  • public void lock():加同步锁。
  • public void unlock():释放同步锁。

示例代码:

package com.dfbz.demo02_线程安全;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo06_lock锁 {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    lock.lock();
                    System.out.print("我");
                    System.out.print("是");
                    System.out.print("中");
                    System.out.print("国");
                    System.out.print("人");
                    System.out.println();
                    lock.unlock();
                }
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    lock.lock();
                    System.out.print("犯");
                    System.out.print("我");
                    System.out.print("中");
                    System.out.print("华");
                    System.out.print("者");
                    System.out.println();
                    lock.unlock();
                }
            }
        }.start();
    }
}

3.2.4 线程死锁

多线程同步的时候,如果同步代码嵌套,使用相同锁,就有可能出现死锁;

  • 分析:

  • 示例代码:
package com.dfbz.demo02_线程安全;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo07_线程死锁 {
    public static void main(String[] args) {
        String s1 = "s1";
        String s2 = "s2";
        new Thread() {
            public void run() {
                while (true) {
                    synchronized (s1) {
                        // ①线程1先获取到s1锁
                        System.out.println(this.getName() + "s1");
                        synchronized (s2) {     // ③线程1继续执行,被锁阻塞
                            System.out.println(this.getName() + "s2");
                        }
                    }
                }
            }
        }.start();
        new Thread() {
            public void run() {
                while (true) {
                    synchronized (s2) {
                        // ②线程2获取到s2锁
                        System.out.println(this.getName() + "s2");
                        synchronized (s1) {     // ④线程2继续执行,被锁阻塞(死锁)
                            System.out.println(this.getName() + "s1");
                        }
                    }
                }
            }
        }.start();
    }
}

3.3 集合的线程安全问题

3.3.1 线程安全与不安全集合

我们前面学习集合的时候发现集合存在由线程安全集合和线程不安全集合;线程安全效率低,安全性高;反之,线程不安全效率高,安全性低,线程不安全的集合有:Vector,Stack,Hashtable等;

  • 查看Vector和Hashtable等源代码:

线程安全集合中的方法大部分都加上了synchronized关键字来保证线程的同步;

  • 线程不安全集合:

3.3.2 线程不安全集合测试

  • 数据覆盖问题:
package com.dfbz.demo03_集合与线程安全问题;
import java.util.ArrayList;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_测试ArrayList线程不安全问题 {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<>();
        for (int j = 0; j < 200; ++j) {
            new Thread(() -> {
                for (int i = 0; i < 100; i++) {
                    arr.add("1");
                    try {
                        // 让线程安全问题更加突出
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

运行代码,发现出现数组下标越界异常:

分析ArrayList源码:

①假设此时size为9(集合已经存储了9个元素,本次是来存储第10个元素),size+1并没有大于数组的默认长度(10),并没有造成数组的扩容

②等待代码将集合的9下标赋值后,size++还没来得及运算,CPU的执行权就被其他的线程抢走了,此时size仍旧为9,但此时集合中已经存储了10个元素了;

③等到其他线程来执行ensureCapacityInternal(9+1)--->ensureCapacityInternal--->ensureExplicitCapacity发现10-10还是小于0,依旧不扩容

④代码执行elementData[size++]=e时(还没执行),线程执行权又回到了第一条线程,size++,变为10

⑤然后线程执行权又变回执行elementData[size++]=e这段代码时的那个线程,出现了elementData[10]=e,出现数组下标越界;

Tips:HashMap同样会出现这个问题,将集合换成Vector或者Stack等线程安全集合可以解决这些问题;或者使用JDK提供的其他线程同步集合也可以解决这些问题;
相关文章
|
2天前
|
安全 算法 Java
Java 中的并发控制:锁与线程安全
在 Java 的并发编程领域,理解并正确使用锁机制是实现线程安全的关键。本文深入探讨了 Java 中各种锁的概念、用途以及它们如何帮助开发者管理并发状态。从内置的同步关键字到显式的 Lock 接口,再到原子变量和并发集合,本文旨在为读者提供一个全面的锁和线程安全的知识框架。通过具体示例和最佳实践,我们展示了如何在多线程环境中保持数据的一致性和完整性,同时避免常见的并发问题,如死锁和竞态条件。无论你是 Java 并发编程的新手还是有经验的开发者,这篇文章都将帮助你更好地理解和应用 Java 的并发控制机制。
|
7天前
|
安全 Java 开发者
Java并发编程中的线程安全性与性能优化
在Java编程中,处理并发问题是至关重要的。本文探讨了Java中线程安全性的概念及其在性能优化中的重要性。通过深入分析多线程环境下的共享资源访问问题,结合常见的并发控制手段和性能优化技巧,帮助开发者更好地理解和应对Java程序中的并发挑战。 【7月更文挑战第14天】
|
7天前
|
监控 Java API
Java并发编程之线程池深度解析
【7月更文挑战第14天】在Java并发编程领域,线程池是提升性能、管理资源的关键工具。本文将深入探讨线程池的核心概念、内部工作原理以及如何有效使用线程池来处理并发任务,旨在为读者提供一套完整的线程池使用和优化策略。
|
10天前
|
存储 安全 算法
深入理解Java并发编程:线程安全与性能优化
【5月更文挑战第72天】 在现代软件开发中,尤其是Java应用开发领域,并发编程是一个无法回避的重要话题。随着多核处理器的普及,合理利用并发机制对于提高软件性能、响应速度和资源利用率具有重要意义。本文旨在探讨Java并发编程的核心概念、线程安全的策略以及性能优化技巧,帮助开发者构建高效且可靠的并发应用。通过实例分析和理论阐述,我们将揭示在高并发环境下如何平衡线程安全与系统性能之间的关系,并提出一系列最佳实践方法。
|
9天前
|
Java 调度
java中线程的6种状态
java中线程的6种状态
|
9天前
|
算法 Java 开发者
Java中的多线程编程技巧与实践
在现代软件开发中,多线程编程成为提升应用程序性能和响应能力的关键技术之一。本文将深入探讨Java语言中多线程编程的基础概念、常见问题及其解决方案,帮助开发者更好地理解和应用多线程技术。 【7月更文挑战第12天】
10 0
|
9天前
|
缓存 Linux 编译器
【Linux】多线程——线程概念|进程VS线程|线程控制(下)
【Linux】多线程——线程概念|进程VS线程|线程控制(下)
21 0
|
9天前
|
存储 Linux 调度
【Linux】多线程——线程概念|进程VS线程|线程控制(上)
【Linux】多线程——线程概念|进程VS线程|线程控制(上)
27 0
|
11天前
|
设计模式 安全 Java
Java面试题:设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题,Java内存模型定义了线程如何与内存交互,包括原子性、可见性、有序性,并发框架提供了更高层次的并发任务处理能力
Java面试题:设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题,Java内存模型定义了线程如何与内存交互,包括原子性、可见性、有序性,并发框架提供了更高层次的并发任务处理能力
27 1
|
11天前
|
设计模式 存储 安全
Java面试题:设计一个线程安全的单例类并解释其内存占用情况?使用Java多线程工具类实现一个高效的线程池,并解释其背后的原理。结合观察者模式与Java并发框架,设计一个可扩展的事件处理系统
Java面试题:设计一个线程安全的单例类并解释其内存占用情况?使用Java多线程工具类实现一个高效的线程池,并解释其背后的原理。结合观察者模式与Java并发框架,设计一个可扩展的事件处理系统
22 1