【Java基础-并发编程】-共享资源并发问题以及synchronized解决方案

花果水莲

已于 2023-08-02 10:52:03 修改

阅读量993

点赞数

分类专栏： java基础文章标签： java

于 2023-06-13 20:51:22 首次发布

本文链接：https://blog.csdn.net/weixin_51725434/article/details/131196115

版权

java基础专栏收录该内容

14 篇文章 0 订阅

订阅专栏

文章讨论了在Java中，多线程访问共享资源可能导致的问题，如非原子操作导致的不确定性。通过分析i++的字节码，揭示了竞态条件的概念。文章提出了解决方案——使用synchronized关键字实现互斥访问，确保临界区的原子性，防止竞态条件发生。通过类比解释了synchronized如何工作，并展示了在方法上使用synchronized的不同形式。

摘要由CSDN通过智能技术生成

一、共享资源带来的问题

class ThreadProblem{
    static int counter = 0;
    public static void testThread(){
        Thread t1 = new Thread(()-> {
            for (int i = 0; i < 5000; i++) {
               counter++;
            }
        },"t1");

        Thread t2 = new Thread(()-> {
            for (int i = 0; i < 5000; i++) {
                counter--;
            }
        },"t2");

        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(counter);
    }

}

1.1 问题分析

以上的结果可能是整数、负数、零。为什么呢？因为java中对静态变量的自增自减并不是原子操作，要彻底理解，必须从字节码进行分析。

例如对于i++而言(i为静态变量)，实际会产生如下的JVM字节码指令：

getstatic i //获取静态变量i的值

iconst_1 //准备变量1

1add //自增

putstatic //把修改后的值存入静态变量i

在多线程下这8行代码(8行代码指i++,i--的JVM字节码)可能交错运行：

1.2 临界区 Critical Section

一个程序运行多个线程本身没有问题的
问题出在铎哥线程访问共享资源

多个线程读共享资源其实也没有问题
在多个线程对共享资源读写操作时发生指令交错，就会出现问题

一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

static int counter = 0;
static void increment(){
    //临界区
    counter++;
}

1.3 竞态条件 Race Condition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件。

二、synchronized解决方案

2.1 应用之互斥

为了避免临界区的竞态条件发生，有多种手段可以达到目的。

阻塞式的解决方案：synchronized,Lock
非阻塞式的解决方案：原子变量

本篇文章使用阻塞式的解决方案：synchronized,来解决竞态条件的发生，即俗称的【对象锁】，它采用互斥的方式让同一个时刻至多只有线程能持有【对象锁】，其他线程再想获取这个【对象锁】就会被阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心上下文切换。

注意：

虽然java中互斥和同步都可以采用synchronized关键字来完成，但他们还是有区别的：

互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码
同步是由于线程执行的先后顺序不同，需要一个线程等待其他线程运行到某个点

2.2 synchronized语法

synchronized(对象){//对象可以使任意的，但要保证操作同一个【共享资源】使用同一个对象

临界区

}

class ThreadSynchronized{
    static int counter = 0;
    static Object room = new Object();
    public static void testSynchronized(){
        Thread t1 = new Thread(()-> {
            for (int i = 0; i < 5000; i++) {
                synchronized(room){
                    counter++;
                }
            }
        },"t1");

        Thread t2 = new Thread(()-> {
            for (int i = 0; i < 5000; i++) {
                synchronized(room) {
                    counter--;
                }
            }
        },"t2");

        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(counter);
    }
}

2.3 synchronized的理解

做一个类比：

synchronized(对象) 中的对象，可以想象成一个房间(room),有唯一的入口(门)，房间只能一次进入一人进行计算，线程t1,t2想象成两个人。
当线程t1执行到synchronized(room)时就好比t1进入了这个房间，并锁住了门拿走了钥匙，在门内执行counter++代码。
这时候如果t2也运行到了synchronized(room)时，它发现门被锁住了，只能在门外等待，发生了上下文切换，阻塞住了。
这中间即使t1的cpu时间片不幸用完，被踢出了门外(不要错误的理解为锁住了对象就能一直执行下去哦)，这时门还是被锁住的，t1仍然拿着钥匙，t2线程还在阻塞状态进不来，只有下次CPU时间片分配给t1，t1再次获得时间片才能开门进入。
当t1执行完synchronized(room)块内的代码，这时候才会从obj房间出来，并揭开门上的锁，唤醒t2等其他线程，其他某个线程拿到钥匙才可以进入obj房间，锁住门拿着钥匙，执行它的counter--代码。

2.4 synchronized总结

synchronized实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断。

2.5 锁对象面向对象的改进

把需要保护的共享变量放入一个类

class Room{
    private int value=0;
    public void increment(){
        synchronized (this){
            value++;
        }
    }
    public void decrement(){
        synchronized (this){
            value--;
        }
    }
    public int get(){
        synchronized (this){
            return value;
        }
    }
}

三、方法上的synchronized

public synchronized void decrement(){
     value--;
}
相当于，锁对象是this对象
public void decrement(){
    synchronized (this){
        value--;
    }
}

public synchronized static void decrement(){
     value--;
}
相当于，锁对象是类对象
public void decrement(){
    synchronized (Room.class){
        value--;
    }
}