3.2、synchronized关键字解决竞争的方案

言葉长琴

已于 2022-03-06 03:16:17 修改

阅读量526

点赞数

分类专栏： Java并发编程文章标签：多线程并发 java synchronized

于 2022-03-06 03:04:02 首次发布

本文链接：https://blog.csdn.net/u011569827/article/details/123304857

版权

Java并发编程专栏收录该内容

30 篇文章 0 订阅

订阅专栏

1、synchronized 解决方案

为了避免领截取的竞态条件发生，有多种手段可以达到目的。

阻塞时的解决方案：synchronized，Lock
非阻塞式的解决方案：原子变量
本次使用阻塞式的解决方案：synchronized，来解决上述问题，及俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其他线程想要获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程的上下文切换

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

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

synchronized

语法

synchronized(对象) //线程1、线程2（blocked）
{
	临界区
}
解决
```java
    static int counter = 0;
    static final int times = 5000;
    static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < times; i++) {
                synchronized (lock) {
                    counter++;

                }
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < times; i++) {
                synchronized (lock) {
                    counter--;
                }
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("结果：{}", counter);
    }

输出

2022/03/04-00:37:24.840 [main] c.Test1 - 结果：0

在这里插入图片描述
你可以做这样的对比：

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

用图来表示
在这里插入图片描述

思考

synchronized实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换锁打断。
为了加深理解，请思考下面的问题

如果把synchronized(obj)放在for循环的外面，如何理解？ – 原子性
如果t1synchronized(obj1)而t2synchronized(obj2)会怎样运行？ – 锁对象
如果t1synchronized(obj)而t2没有加会怎么样？如何理解？ --锁对象

面相对象改进

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

@Slf4j(topic = "c.Test1")
public class Test2 {

    static final int times = 5000;


    public static void main(String[] args) throws InterruptedException {
        Room room = new Room();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < times; i++) {
                room.increment();
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < times; i++) {
                room.decrement();

            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("结果：{}", room.get());
    }

}

class Room {
    int value = 0;

    public void increment() {
        synchronized (this) {
            value++;
        }
    }

    public void decrement() {
        synchronized (this) {
            value--;
        }
    }

    public int get() {
        synchronized (this) {
            return value;
        }
    }
}

2、方法上的synchronized

class Test {
	public synchronized void test() {
	}
}
等价于
class Test {
	public void test() {
		synchronized(this) {
		}
	}
}

class Test {
	public synchronized static void test() {
	}
}
等价于
class Test {
	public void test() {
		synchronized(Test.class) {
		}
	}
}

不加synchronized的方法

不加synchronized的方法就好比不遵守规则的人，不老实排队

所谓的“线程八锁”

其实就是考察synchronized锁住的是哪个对象
情况1：12或21

public class Test1 {
    public static void main(String[] args) {
        Number n = new Number();
        new Thread(() -> n.a()).start();
        new Thread(() -> n.b()).start();
    }
}

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

情况2：1s后12，或者2 1s后1

public class Test1 {
    public static void main(String[] args) {
        Number n = new Number();
        new Thread(() -> {
            try {
                n.a();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> n.b()).start();
    }
}

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() throws InterruptedException {
        Thread.sleep(1000);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

情况3：3 1s 12 或 23 1s 1 或 32 1s 1

@Slf4j(topic = "c.Number")
class Number{
 public synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public synchronized void b() {
 log.debug("2");
 }
 public void c() {
 log.debug("3");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
 new Thread(()->{ n1.c(); }).start();
}

情况4：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
 public synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 Number n2 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n2.b(); }).start();
}

情况5：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
 public static synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public synchronized void b() {
 log.debug("2");
 }
 }
public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
}

情况6：1s 后12，或 2 1s后 1

@Slf4j(topic = "c.Number")
class Number{
 public static synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public static synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
}

情况7：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
 public static synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 Number n2 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n2.b(); }).start();
}

情况8：1s 后12，或 2 1s后

class Number{
 public static synchronized void a() {
 sleep(1);
 log.debug("1");
 }
 public static synchronized void b() {
 log.debug("2");
 }
}
public static void main(String[] args) {
 Number n1 = new Number();
 Number n2 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n2.b(); }).start();
}