线程基础知识系列(三）线程的同步

2022-08-07 22:19:59

本文的主要内容

  1. 何谓线程安全？

  2. 何谓共享可变变量？

  3. 认识synchronized关键字

  4. 认识Lock

  5. synchronized vs Lock


1.何谓线程安全

多线程是把双刃剑，带来高效的同时，也带来了安全隐患。什么是线程安全？众说一次，很多版本的说辞。引用《Java并发编程实战》书中的定义，如下：当多线程访问时，永远都能表现正确的行为。延伸解读下“何谓正确性”。正确性就是不管是多线程访问，还是单线程访问，影响的结果是一致的。可以将单线程的正确性形容为“所见即所知”。借助下面的例子解释下。

SysnExampleV1.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package com.threadexample.sysn;
import java.util.Random;
import java.util.concurrent.TimeUnit;
public class SysnExampleV1 {
   static class Task implements  Runnable{
        private Integer count=0;
        private int cycleSize;
        public Task(int cycleSize) {
            this.cycleSize=cycleSize;
        }
        @Override
        public void run() {
            for(int i=0;i<cycleSize;i++){
                this.count++;
            }
        }
       private void doSomething(){
           final Random random =new Random();
           try {
               TimeUnit.MILLISECONDS.sleep(random.nextInt(10));
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
 
       public int getCount(){
           return this.count;
       }
    }
    public static void main(String[] args) throws InterruptedException {
        Task task = new Task(1000);
        Thread t1=new Thread(task);
        Thread t2=new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("计数(线程数*循环数)="+task.getCount());
    }
}

Task 类维护一个实例变量count,作为计数器。每循环一次计数加1.一共启用2个线程，每个线程循环1000次。为了保证线程完整执行调用线程的join()，最后的预期效果：2*1000=2000.

测试结果如下（而且结果经常变化）

1
计数(线程数*循环数)=1958

根据“所见即所知”，2个线程，每个循环1000次，当然是2000了。可结果不是2000.说明Task类不是线程安全的。

简单剖析下原因： 问题出在this.count++，这个操作是符合操作。

使用自带的javap -v SysnExampleV1$Task.class 命令查看字节码文件 ,可以很容易找到原因。

1
2
3
4
5
6
7
8
9
10
11
12
13
     ...
       42: getfield      #3                  // Field count:Ljava/lang/Integer;
       45: astore        4
       47: aload_3
       48: aload_3
       49: getfield      #3                  // Field count:Ljava/lang/Integer;
       52: invokevirtual #12                 // Method java/lang/Integer.intValue:()I
       55: iconst_1
       56: iadd
       57: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       60: dup_x1
       61: putfield      #3                  // Field count:Ljava/lang/Integer;
       ...

简单的一个自增操作，被分解为

  1. 获取当前c的值；

  2. 对获取到的值加1；

  3. 把递增后的值写回到c；

既然是复合操作，一个线程更新了数据，还没有保存到共享缓存，另外一个线程这时候读取数据，就会存在拿到过期数据的情况。简单演示下，假设count c初始化为0，

线程A：获取c；
线程B：获取c；
线程A：对获取的值加1，结果为1；
线程B：对获取的值加1，结果为1；
线程A：结果写回到c,c现在是1；
线程B：结果写回到c,c现在是1；

按正常理解，B应该写回2才正确。

接下来如何解决这个问题呢。其实很简单。就是用synchronized处理。在介绍synchronized之前，先简单说一下共享变量。

2.何谓共享可变变量

要编写线程安全的代码，其核心在于对状态访问操作的管理上，特别是对共享的和可变的状态的访问。“共享”意味着可以由多个线程同时访问，而”可变“意味着变量的值在其生命周期内可以发生变化。根据不同分类，简单介绍几种变量

局部变量

局部变量存储在线程自己的栈中。也就是说，局部变量永远也不会被多个线程共享。所以，基础类型的局部变量是线程安全的。下面是基础类型的局部变量的一个例子：

1
2
3
4
5
6
public void someMethod(){
   
  long threadSafeInt = 0;
 
  threadSafeInt++;
}

局部的对象引用

对象的局部引用和基础类型的局部变量不太一样。尽管引用本身没有被共享，但引用所指的对象并没有存储在线程的栈内。所有的对象都存在共享堆中。所以存在变量逸出现象。关于逸出的相关知识，可以参考《JAVA并发编程实战》3.2节“发布与逸出”。

1
2
3
4
5
6
7
8
9
10
11
public void someMethod(){
   
  LocalObject localObject = new LocalObject();
 
  localObject.callMethod();
  method2(localObject);
}
 
public void method2(LocalObject localObject){
  localObject.setValue("value");
}

样例中LocalObject对象没有被方法返回，也没有被传递给someMethod()方法外的对象。每个执行someMethod()的线程都会创 建自己的LocalObject对象，并赋值给localObject引用。因此，这里的LocalObject是线程安全的。事实上，整个 someMethod()都是线程安全的。即使将LocalObject作为参数传给同一个类的其它方法或其它类的方法时，它仍然是线程安全的。当然，如 果LocalObject通过某些方法被传给了别的线程，那它就不再是线程安全的了。

对象成员

对象成员存储在堆上。如果两个线程同时更新同一个对象的同一个成员，那这个代码就不是线程安全的。下面是一个样例：

1
2
3
4
5
6
7
public class NotThreadSafe{
    StringBuilder builder = new StringBuilder();
     
    public add(String text){
        this.builder.append(text);
    }  
}

如果两个线程同时调用同一个NotThreadSafe实例上的add()方法，就会有竞态条件问题.这时候如果多线程访问对象成语变量，线程就不是线程安全的，所以需要使用java提供的加锁机制进行保护了。目前在Java中存在两种锁机制：synchronized和Lock，Lock接口及其实现类是JDK5增加的内容，其作者是大名鼎鼎的并发专家Doug Lea。本文并不比较synchronized与Lock孰优孰劣。

3.认识synchronized关键字

synchronized是java的一个关键字。java提供了2个同步机制，同步方法和同步块。同步块要关联一个保护的对象，同步方法关联的是this对象。受同步保护的代码块，一次只允许一个线程进入，至于JVM底层又是如何实现synchronized的。

同步机制的建立是基于其内部一个叫内部锁或者监视锁的实体。（在Java API规范中通常被称为监视器。）内部锁在同步机制中起到两方面的作用：对一个对象的排他性访问；建立一种happens-before关系，而这种关系正是可见性问题的关键所在。

每个对象都有一个与之关联的内部锁。通常当一个线程需要排他性的访问一个对象的域时，首先需要请求该对象的内部锁，当访问结束时释放内部锁。在线程 获得内部锁到释放内部锁的这段时间里，我们说线程拥有这个内部锁。那么当一个线程拥有一个内部锁时，其他线程将无法获得该内部锁。其他线程如果去尝试获得 该内部锁，则会被阻塞。

当线程释放一个内部锁时，该操作和对该锁的后续请求间将建立happens-before关系。

更多的原理解释，可以参考深入JVM锁机制之一：synchronized和相关Java memory model知识。

  1. 使用synchronized块保护方法

    代码块1.1

1
2
3
4
5
6
7
public void run() {
    synchronized (this){
        for(int i=0;i<cycleSize;i++){
            this.count++;
        }
    }
}

或者

代码块1.2

1
2
3
4
5
6
7
public void run() {
        for(int i=0;i<cycleSize;i++){
            synchronized (this){
            this.count++;
            }
        }
    }

两个方法的区别是synchronized块的保护范围区别，结果是一样的，前者保护的范围大一些，但上下文切换少一些；后者与之相反。具体哪个形式更好，具体要看保护的代码块逻辑了。

   2.将方法用synchronized声明

代码块2.1

1
2
3
4
5
public synchronized void run() {
        for(int i=0;i<cycleSize;i++){
            this.count++;
        }
    }

这种方式，保护效果与代码块1.1达到的效果是一样的。

3.在类级别synchronized 进行保护

代码块3.1

1
2
3
4
5
6
7
public  void run() {
    synchronized (SysnExampleV2.class) {
        for (int i = 0; i < cycleSize; i++) {
            this.count++;
        }
    }
}

这种方式是4种种最差的。因为它的保护范围最高，并发性最差。此种情景，不适合此种方式。类级别的加锁，一般使用在单例模式（双重校验锁）。一句话，要判断同步代码块的合理大小，需要在各种设计需求之间进行权衡，包括安全性，简单性和性能。

synchronized不能修饰构造函数。

4.认识Lock

 与synchronized不同，要手动创建锁，释放锁，获取锁。如下

1
2
3
Lock lock = new ReentrantLock(); 
lock.lock(); //critical section 
lock.unlock();

SysnExampleV3.java， 展示了Lock的用法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package com.threadexample.sysn;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class SysnExampleV3 {
   static class Task implements  Runnable{
       private final Lock lock = new ReentrantLock();
        private Integer count=0;
        private int cycleSize;
        public   Task(int cycleSize) {
            this.cycleSize=cycleSize;
        }
        @Override
        public void run() {
            for(int i=0;i<cycleSize;i++){
                try {
                    if(lock.tryLock(10, TimeUnit.SECONDS)){
                        this.count++;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
 
            }
        }
        //一般这样实现
        /*
                public void run() {
                    for(int i=0;i<cycleSize;i++){
                        lock.lock();  // block until condition holds
                        try {
                            this.count++;
                        } finally {
                            lock.unlock();
                        }
                    }
                }*/
 
       public int getCount(){
           return this.count;
       }
    }
    public static void main(String[] args) throws InterruptedException {
        Task task = new Task(1000);
        Task task2 = new Task(1000);
        Thread t1=new Thread(task);
        Thread t2=new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("计数(线程数*循环数)="+task.getCount());
    }
}

锁像synchronized同步块一样，是一种线程同步机制，但比Java中的synchronized同步块更复杂。java提供了以下的锁。

线程基础知识系列(三）线程的同步

这几种锁的区别与原理，本文不做深入探讨。

5.synchronized vs Lock

  1. synchronized同步块 不提供超时功能，Lock提供了超时功能，使用Lock.tryLock(long timeout, TimeUnit timeUnit)

  2. synchronized同步块，使用简单快捷，这一点也造成了它的滥用。可以配合使用wait(),notify()。lock属于JUC的一部分。

  3. synchronized造成的线程阻塞，可以被dump，而lock造成的线程阻塞不能dump。

  4. synchronized是托管给JVM执行的，而lock是java写的控制锁的代码。在Java1.5中，synchronize是性能低效的。因为这是一个重量级操作，需要调用操作接口，导致有可能加锁消耗的系统时间比加锁以外的操作还多。相比之下使用Java提供的Lock对象，性能更高一些。但是到了Java1.6，发生了变化。synchronize在语义上很清晰，可以进行很多优化，有适应自旋，锁消除，锁粗化，轻量级锁，偏向锁等等。导致在Java1.6上synchronize的性能并不比Lock差。官方也表示，他们也更支持synchronize，在未来的版本中还有优化余地。

  5. lock有公平锁，非公平锁之分。synchronized只有非公平

  6. synchronized原始采用的是CPU悲观锁机制，即线程获得的是独占锁；Lock用的是乐观锁方式。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁实现的机制就是CAS操作（Compare and Swap）。

  7. lock额外提供了Conditon



本文转自 randy_shandong 51CTO博客，原文链接：http://blog.51cto.com/dba10g/1793815，如需转载请自行联系原作者
上一篇：Android 使用dagger2进行依赖注入(基础篇）


下一篇：WiFi未来趋势如何？如何搭上物联网这条大船？