3.java并发编程:线程安全与synchronized

最新推荐文章于 2023-06-09 10:53:19 发布

然而,然而

最新推荐文章于 2023-06-09 10:53:19 发布

阅读量108

点赞数

文章标签： java 安全 jvm 开发语言数据结构

本文链接：https://blog.csdn.net/qq_30635523/article/details/131325727

版权

# ☆什么是线程安全

线程安全就是说多线程访问同一代码，不会产生不确定的结果。

既然是线程安全问题，那么毫无疑问所有的隐患都是出现在多个线程访问的情况下产生的，也就是我们要确保在多条线程访问的时候，我们的程序还能按照我们预期的行为去执行。

当多个线程访问某个方法时，不管你通过怎样的调用方式或者说这些线程如何交替的执行，我们在主程序中不需要去做任何的同步，这个类的结果行为都是我们设想的正确行为，那么我们就可以说这个类是线程安全的。

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。

线程安全问题基本都是由全局变量及静态变量引起的。

若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；

若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

☆基本类型局部变量线程:安全

☆引用类型局部变量线程:未必安全

基本类型的局部变量是线程安全的,但引用类型的局部变量则未必

如果该对象没有逃离方法的作用访问，它是线程安全的

如果该对象逃离方法的作用范围，需要考虑线程安全

基本类型局部变量线程安全分析

public static void test1() { int i = 10; i++; }

每个线程调用 test1() 方法时局部变量 i，会在每个线程的栈帧内存中被创建多份，因此不存在共享

案例1:安全

//结论:是线程安全的 public static void method1(){ //StringBuffer:线程安全的 StringBuffer s1 = new StringBuffer(); //append方法是加锁的方法 s1.append("A"); s1.append("B"); //结果是确定的,s1就是AB } /** 多个线程调用该方法,每个线程都有自己的方法栈,每个方法栈都有自己的s1对象，所以不存在共享。解释：这个例子是线程安全的，s1为局部变量，返回值为void，只能被当前线程操作，是线程安全的。注意：这里返回值为void **/

案例2:不安全

``` //我们在main操作一下 public static void main(String[] args){ StringBuilder s = new StringBuilder();

new Thread(()->{
  s.append("a");
  s.append("b");
}).start();
method2(s);    
System.out.println(s);

}

//结论:是线程不安全的 public static void method2(StringBuiler sBuilder){ //StringBuilder是线程不安全的 sBuilder.append("A"); sBuilder.append("B"); }

//它们会抢s的资源，是线程不安全的,最终结果不确定。 //严格的来说sBuilder不是方法内的局部变量，它是形参的局部变量，形参也会存在局部变量表中 //可能通过参数传递到了其他线程方法中 ```

案例3:不安全

``` //这次不传参数，而是返回s1 //结论：不是线程安全的(有可能存在问题) public static StringBuilder method3(){ StringBuilder s1 = new StringBuilder(); s1.append("A"); s1.append("B"); return s1; }

//引用类型和基本类型不用多说了把 //基本类型包括：byte,short,int,long,char,float,double,Boolean， //引用类型包括：类类型，接口类型和数组。 //因为StringBuilder是类，一返回出去可能被其他位置上的多个线程所调用 ```

案例4:安全

``` //返回String，String有点特殊，因为它具有不变性，是不可变对象. //看源码是String被final声明,并且每次返回的时候返回的是一个新的对象，所以不存在共享一说

//结论：线程安全的 public static String method4(){ StringBuilder s1 = new StringBuilder(); s1.append("A"); s1.append("B"); ... return s1.toString(); }
```

总结

我们要明确一个概念：创建对象不一定在堆空间上创建，还可以在栈上创建

总结：method1和4是安全的，2和3是不安全，所以这道题方法中定义的局部变量不一定线程安全，要看具体使用。

成员变量和静态变量是否线程安全？

如果它们没有共享，则线程安全如果它们被共享了，根据它们的状态是否能够改变，又分两种情况

如果只有读操作，则线程安全,如果有读写操作，则这段代码是临界区，需要考虑线程安全

引用类型成员变量线程安全分析

案例

``` import java.util.ArrayList; class Rextester { ArrayList list = new ArrayList<>(); public void method1(int loopNumber) { for (int i = 0; i < loopNumber; i++) { // { 临界区, 会产生竞态条件 method2(); method3(); // } 临界区 } } private void method2() { list.add("1"); } private void method3() { list.remove(0); }

public static void main(String[] args) {
    Rextester test = new Rextester();
    for (int i = 0; i < 2; i++) {
        new Thread(() -> {
            test.method1(200);
        }
                   , "Thread" + i).start();
    }
}

} ```

``` 其中一种情况是，如果线程2 还未 add，线程1 remove 就会报错：无论哪个线程中的 method2/method3 引用的都是同一个对象中的 list 成员变量

Exception in thread "Thread1" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0 at java.util.ArrayList.rangeCheck(ArrayList.java:657) at java.util.ArrayList.remove(ArrayList.java:496) at cn.itcast.n6.ThreadUnsafe.method3(TestThreadSafe.java:35) at cn.itcast.n6.ThreadUnsafe.method1(TestThreadSafe.java:26) at cn.itcast.n6.TestThreadSafe.lambda$main$0(TestThreadSafe.java:14) at java.lang.Thread.run(Thread.java:748) ```

引用类型成员变量线程安全解决1

将 list 修改为局部变量那么就不会有上述问题了,list是局部变量，每个线程调用时会创建其不同实例，没有共享

☆private & final 修饰符安全意义

方法访问修饰符带来的思考，如果把 method2 和 method3 的方法修改为 public 会不会带来线程安全问题？

情况1：有其它线程调用 method2 和 method3

情况2：在情况1 的基础上，为 ThreadSafe 类添加子类，子类覆盖 method2 或 method3 方法，即

class ThreadSafe { public final void method1(int loopNumber) { ArrayList<String> list = new ArrayList<>(); for (int i = 0; i < loopNumber; i++) { method2(list); method3(list); } } private void method2(ArrayList<String> list) { list.add("1"); } private void method3(ArrayList<String> list) { list.remove(0); } } class ThreadSafeSubClass extends ThreadSafe{ //这里的list可能是成员变量 @Override public void method3(ArrayList<String> list) { new Thread(() -> { list.remove(0); }).start(); } }

从这个例子可以看出 private 或 final 提供【安全】的意义所在，请体会开闭原则中的【闭】。对新增开放对修改关闭。这里的闭指的是对修改关闭,禁止修改。

常见线程安全类

``` String

Integer

StringBuffer

Random

Vector

Hashtable

java.util.concurrent 包下的类 ```

线程不安全的集合变成线程安全的集合

Collections.synchronizedCollection()

这里说它们是线程安全的是指，多个线程调用它们同一个实例的某个方法时，是线程安全的。

它们的每个方法是安全的 ,但注意它们多个方法的组合不一定是安全的，见后面分析

String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象。

线程安全类方法的组合

分析下面代码是否线程安全？

可以类比Mysql的快照读

Hashtable table = new Hashtable(); new Thread(()->{ if( table.get("key") == null) { table.put("key", "value1"); } }).start(); new Thread(()->{ if( table.get("key") == null) { table.put("key", "value2"); } }).start();

线程1抢占到时间片执行table.get("key") == null为true，准备向table里put值。

线程2抢占到时间片执行table.get("key") == null为true，也准备向table里put值。

线程1抢占到时间片put值

线程2抢占到时间片put值

结果线程2覆盖了线程1的值

共享模型之管程

引入问题

两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果是 0 吗？

static int counter = 0; public static void main(String[] args) throws InterruptedException { 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(); t1.join(); t2.join(); log.debug("{}",counter); }

☆自增自减字节码指令

以上的结果可能是正数、负数、零。为什么呢？

因为 Java 中对静态变量的自增，自减并不是原子操作，要彻底理解，必须从字节码来进行分析

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

getstatic i // 获取静态变量i的值 iconst_1 // 准备常量1 iadd // 自增 putstatic i // 将修改后的值存入静态变量i

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

getstatic i // 获取静态变量i的值 iconst_1 // 准备常量1 isub // 自减 putstatic i // 将修改后的值存入静态变量i

而 Java 的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换

如果是单线程以上 8 行代码是顺序执行(不会交错)没有问题：

但多线程下这 8 行代码可能交错运行。可能会出现正负数的情况。

出现负数的情况

原因:线程2做自减操作

1.首先获取静态变量i的值为0

2.准备常量1

3.i自减1,i=-1

4.写入i=-1

在做到第3步的时候,线程1获取到了时间片,执行自增操作。

1.首先获取静态变量i的值为0

2.准备常量1

3.i自增1,i=1

4.写入i=1

当执行完自增操作以后,线程2 的第4步开始执行，执行完毕,写入i=-1。

出现正数的情况

原因:线程2做自增操作

1.首先获取静态变量i的值为0

2.准备常量1

3.i自增1,i=1

4.写入i=1

在做到第3步的时候,线程1获取到了时间片,执行自减操作。

1.首先获取静态变量i的值为0

2.准备常量1

3.i自减1,i=-1

4.写入i=-1

当执行完自增操作以后,线程2 的第4步开始执行，执行完毕,写入i=1

原因:没保证原子性,导致覆盖更新

临界区 Critical Section

一个程序运行多个线程本身是没有问题的问题出在多个线程访问共享资源 ,多个线程读共享资源其实也没有问题在多个线程对共享资源读写操作时发生指令交错，就会出现问题。

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

例如，下面代码中的临界区

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

竞态条件 Race Condition

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

synchronized解决

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

阻塞式的解决方案：synchronized，Lock ,读写锁

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

本次课使用阻塞式的解决方案：synchronized，来解决上述问题，即俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。

这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换

互斥:串行执行

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

互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码。

进程互斥是进程之间的间接制约关系。当一个进程进入临界区使用临界资源时，另一个进程必须等待。

只有当使用临界资源的进程退出临界区后，这个进程才会解除阻塞状态。

同步:等待唤醒

同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点。

等待唤醒就是同步的一种。

进程同步也是进程之间直接的制约关系，是为完成某种任务而建立的两个或多个线程，这个线程需要在某些位置上协调他们的工作次序而等待、传递信息所产生的制约关系。进程间的直接制约关系来源于他们之间的合作。

比如:进程A需要从缓冲区读取进程B产生的信息，当缓冲区为空时，进程B因为读取不到信息而被阻塞。

只有当进程A产生信息放入缓冲区时，进程B才会被唤醒。

synchronized 代码实现

// 线程1，线程2(blocked) synchronized(对象) { //临界区 }

static int counter = 0; static final Object room = new Object(); public static void main(String[] args) throws InterruptedException { 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(); t1.join(); t2.join(); log.debug("{}",counter); }

你可以做这样的类比：

synchronized(对象) 中的对象，可以想象为一个房间(room)，有唯一入口(门)房间只能一次进入一人

进行计算，线程 t1，t2 想象成两个人当线程 t1 执行到 synchronized(room) 时就好比 t1 进入了这个房间，并锁住了门拿走了钥匙，在门内执行 count++ 代码

这时候如果 t2 也运行到了 synchronized(room) 时，它发现门被锁住了，只能在门外等待，发生了上下文切换，阻塞住了这中间即使 t1 的 cpu 时间片不幸用完，被踢出了门外(不要错误理解为锁住了对象就能一直执行下去哦)，这时门还是锁住的，t1 仍拿着钥匙，t2 线程还在阻塞状态进不来，只有下次轮到 t1 自己再次获得时间片时才能开门进入

当 t1 执行完 synchronized{} 块内的代码，这时候才会从 obj 房间出来并解开门上的锁，唤醒 t2 线程把钥

匙给他。t2 线程这时才可以进入 obj 房间，锁住了门拿上钥匙，执行它的 count-- 代码 .

用图来表示:从线程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 static void test() { synchronized(Test.class) { } } }

synchronized 原理

实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断。注意自增，自减并不是原子操作,但是加了synchronized以后,自增自减就是原子性操作了。

问:如果把 synchronized(obj) 放在 for 循环的外面，如何理解？-- 原子性

``` 放在循环外面就是进循环之前判断一次synchronized(){}，能进去的话就进去执行循环。而进循环之后就不再判断synchronized(){}了。在循环里面就是每次执行循环的时候执行到synchronized(){}语句都要进行判断

相当于增加和减去的线程互斥,等一方操作完才会操作另一方 ```

问: t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作？-- 锁对象

不是同一把锁,结果可能仍然不是0。

问: t1 synchronized(obj) 而 t2 没有加会怎么样？如何理解？-- 锁对象

一把加锁一把不加锁,临界区仍然存在,结果仍然可能不是0

面向对象改进

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

class Room { int value = 0; public void increment() { synchronized (this) { value++; } } public void decrement() { synchronized (this) { value--; } } public int get() { synchronized (this) { return value; } } } @Slf4j public class Test1 { public static void main(String[] args) throws InterruptedException { Room room = new Room(); Thread t1 = new Thread(() -> { for (int j = 0; j < 5000; j++) { room.increment(); } } , "t1"); Thread t2 = new Thread(() -> { for (int j = 0; j < 5000; j++) { room.decrement(); } } , "t2"); t1.start(); t2.start(); t1.join(); t2.join(); log.debug("count: {}" , room.get()); } }

# 多线程安全问题的前提

A:有多线程环境

B:有共享数据

C:有多条语句操作共享数据

同步解决线程安全问题

A:同步代码块

锁对象:锁对象

public class Sync { //注意:静态变量,全局唯一 public static Object lock = new Object(); public void sync() { synchronized (lock) { System.out.println("开始"); try { Thread.sleep(5000); } catch (InterruptedException e) { } System.out.println("结束"); } } public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { Sync sync = new Sync(); sync.sync(); } }).start(); new Thread(new Runnable() { @Override public void run() { Sync sync = new Sync(); sync.sync(); } }).start(); } }

现象:打印开始-等待5秒-打印结束-打印开始-等待5秒-打印结束

注意:lock对象是静态变量,全局唯一,这样才能保证2个线程访问sync()加的锁是同一把锁。

如果lock去掉static修饰,现象:2个线程同时打印开始和结束,说明2个线程访问sync()加的锁不是同一把锁

B:同步方法

锁对象:this

public class Sync { Object lock = new Object(); public synchronized void sync() { System.out.println("开始"); try { Thread.sleep(5000); } catch (InterruptedException e) { } System.out.println("结束"); } public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { Sync sync1 = new Sync(); sync.sync1(); } }).start(); new Thread(new Runnable() { @Override public void run() { Sync sync2 = new Sync(); sync.sync2(); } }).start(); } }

现象:一起打印开始,一起打印结束,说明锁的对象不是同1个,锁的对象是sync1和sync2。

所以在使用同步方法时一定要注意要保证加锁的对象是同1个。

C:静态同步方法

锁对象:类的字节码文件对象

public class Sync { public static Object lock = new Object(); public static synchronized void sync() { System.out.println("开始"); try { Thread.sleep(5000); } catch (InterruptedException e) { } System.out.println("结束"); } public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { Sync.sync(); } }).start(); new Thread(new Runnable() { @Override public void run() { Sync.sync(); } }).start(); } }

现象:打印开始-等待5秒-打印结束-打印开始-等待5秒-打印结束

注意:lock对象是静态变量,全局唯一,这样才能保证2个线程访问sync()加的锁是同一把锁。

多线程死锁示例:AB-BA

使用锁或者使用synchronized需要避免死锁。 public class MyLock { public static final Object objA = new Object(); public static final Object objB = new Object(); }

public class DieLock extends Thread { private boolean flag; public DieLock(boolean flag) { this.flag = flag; } @Override public void run() { if (flag) { synchronized (MyLock.objA) { System.out.println("if objA"); synchronized (MyLock.objB) { System.out.println("if objB"); } } } else { synchronized (MyLock.objB) { System.out.println("else objB"); synchronized (MyLock.objA) { System.out.println("else objA"); } } } } }

public class DieLockDemo { public static void main(String[] args) { DieLock dl1 = new DieLock(true); DieLock dl2 = new DieLock(false); dl1.start(); dl2.start(); } }

面试题:线程八锁

@Slf4j(topic = "c.Number") class Number{ public synchronized void a() { 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(); } 12 或 21

``` 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(); new Thread(()->{ n1.a(); }).start(); new Thread(()->{ n1.b(); }).start(); } 1s后 12，或 2 1s后 1

```

``` 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();
}

}
3 1s后 12 或 32 1s后 1 或 23 1s后 1
```

由于3没有加锁，所以3可能出现在任意位置。假如3出现在第1位，那么就是2和1竞争。 -如果1抢到就是3 1s 1 2 -如果2抢到就是3 2 1s 1 假如3出现在第2位，那么就是2和1竞争。 -如果1抢到，会先睡眠1秒,在1秒的时间内肯定会打印3,因此永远不会先打印1。 -如果2抢到就是2 3 1s 1 假如3出现在第3位，那么就是2和1竞争。 -如果1抢到，会先睡眠1秒，因为持有锁所以2也不能执行，所以3不可能出现在第3位,3只能在第一位 -如果2抢到，因为1需要睡眠1秒，肯定没3快，所以3不可能出现在第3位,3只能在第2位

@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(); } 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(); } 2 1s 后 1

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(); } 1s 后12，或 2 1s后 1

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(); } 1s 后12，或 2 1s后 1

然而,然而

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
3.java并发编程:线程安全与synchronized

# ☆什么是线程安全线程安全就是说多线程访问同一代码，不会产生不确定的结果。既然是线程安全问题，那么毫无疑问所有的隐患都是出现在多个线程访问的情况下产生的，也就是我们要确保在多条线程访问的时候，我们的程序还能按照我们预期的行为去执行。当多个线程访问某个方法时，不管你通过怎样的调用方式或者说这些线程如何交替的执行，我们在主程序中不需要去做任何的同步，这个类的结果行为都是我们设想的正确行...
复制链接

扫一扫