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

分手后的思念是犯贱 2023-10-12 15:11 69阅读 0赞

## 一、共享资源带来的问题 ##

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

![52d4b77d59cb4412b33dfdcf87096bd3.png][]

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

![74762d08142042aca289c973249807e4.png][]

### 1.2 临界区 Critical Section ###

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

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

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

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--代码。

![e4badc272540492581f68831bcb2f920.png][]

### ![fa0231b163834b1b9e1869462ad2a341.png][] 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--;
        }
    }

[52d4b77d59cb4412b33dfdcf87096bd3.png]: https://img-blog.csdnimg.cn/52d4b77d59cb4412b33dfdcf87096bd3.png
[74762d08142042aca289c973249807e4.png]: https://img-blog.csdnimg.cn/74762d08142042aca289c973249807e4.png
[e4badc272540492581f68831bcb2f920.png]: https://img-blog.csdnimg.cn/e4badc272540492581f68831bcb2f920.png
[fa0231b163834b1b9e1869462ad2a341.png]: https://img-blog.csdnimg.cn/fa0231b163834b1b9e1869462ad2a341.png