并发基础,java线程安全总结

来源:http://www.020tL.com 作者:云顶集团简介 人气:108 发布时间:2019-10-05
摘要:每条线程都有自己的工作内存(WorkingMemory),线程的工作内存中保存了该线程使用到的变量的主内存中的共享变量的副本拷贝。 1. java什么叫线程安全?什么叫不安全? 就是线程同步的意

每条线程都有自己的工作内存(Working Memory),线程的工作内存中保存了该线程使用到的变量的主内存中的共享变量的副本拷贝。

1. java什么叫线程安全?什么叫不安全?

就是线程同步的意思,就是当一个程序对一个线程安全的方法或者语句进行访问的时候,其他的不能再对他进行操作了,必须等到这次访问结束以后才能对这个线程安全的方法进行访问
什么叫线程安全:
如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,
就是线程安全的。
或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。
线程安全问题都是由全局变量及静态变量引起的。
若每个线程中对全局变量、静态变量只有读操作,而无写操作,一般来说,这个全局变量是线程安全的;若有多个线程同时执行写操作,一般都需要考虑线程同步,否则就可能影响线程安全。

 

存在竞争的线程不安全,不存在竞争的线程就是安全的

 

1.线程安全(局部变量)

    public static void test1() {
        int i = 0;
        i++;
        System.out.println(i);
    }

 

  由于i是局部变量,不存在线程安全的问题。100个线程同时访问,每个线程都有自己的i,不会产生线程安全问题。

 

2.servlet线程不安全(全局变量)

云顶集团用户登录 1

  servlet对象只有一个,i也只有一个,存在线程安全问题。

  静态成员变量也会存在线程安全,静态成员在类加载器加载的时候执行,多个对象共享同一个静态成员变量,且静态成员变量不会被释放,Java对象会被JVM自动回收,因此静态成员变量需要谨慎使用。比如一个静态list集合,一个服务器启动后会开启多年,list也会存在多年,如果对象向list中添加数据会导致崩溃(list过大)。

 

2.    浅谈java内存模型
       不同的平台,内存模型是不一样的,但是jvm的内存模型规范是统一的。其实java的多线程并发问题最终都会反映在java的内存模型上,所谓线程安全无 非是要控制多个线程对某个资源的有序访问或修改。总结java的内存模型,要解决两个主要的问题:可见性和有序性。我们都知道计算机有高速缓存的存在,处 理器并不是每次处理数据都是取内存的。JVM定义了自己的内存模型,屏蔽了底层平台内存管理细节,对于java开发人员,要清楚在jvm内存模型的基础 上,如果解决多线程的可见性和有序性。
       那么,何谓可见性? 多个线程之间是不能互相传递数据通信的,它们之间的沟通只能通过共享变量来进行。Java内存模型(JMM)规定了jvm有主内存,主内存是多个线程共享 的。当new一个对象的时候,也是被分配在主内存中,每个线程都有自己的工作内存,工作内存存储了主存的某些对象的副本,当然线程的工作内存大小是有限制 的。当线程操作某个对象时,执行顺序如下:
 (1) 从主存复制变量到当前工作内存 (read and load)
 (2) 执行代码,改变共享变量值 (use and assign)
 (3) 用工作内存数据刷新主存相关内容 (store and write)

JVM规范定义了线程对主存的操作指令:read,load,use,assign,store,write。当一个共享变量在多个线程的工作内存中都有副本时,如果一个线程修改了这个共享变量,那么其他线程应该能够看到这个被修改后的值,这就是多线程的可见性问题。
        那么,什么是有序性呢 ?线程在引用变量时不能直接从主内存中引用,如果线程工作内存中没有该变量,则会从主内存中拷贝一个副本到工作内存中,这个过程为read-load,完 成后线程会引用该副本。当同一线程再度引用该字段时,有可能重新从主存中获取变量副本(read-load-use),也有可能直接引用原来的副本 (use),也就是说 read,load,use顺序可以由JVM实现系统决定。
        线程不能直接为主存中中字段赋值,它会将值指定给工作内存中的变量副本(assign),完成后这个变量副本会同步到主存储区(store- write),至于何时同步过去,根据JVM实现系统决定.有该字段,则会从主内存中将该字段赋值到工作内存中,这个过程为read-load,完成后线 程会引用该变量副本,当同一线程多次重复对字段赋值时,比如:

Java代码  

  1. for(int i=0;i<10;i++)   
  2.  a++;  

 for(int i=0;i<10;i++)

  a++;

 

线程有可能只对工作内存中的副本进行赋值,只到最后一次赋值后才同步到主存储区,所以assign,store,weite顺序可以由JVM实现系统决 定。假设有一个共享变量x,线程a执行x=x+1。从上面的描述中可以知道x=x+1并不是一个原子操作,它的执行过程如下:
1 从主存中读取变量x副本到工作内存
2 给x加1
3 将x加1后的值写回主 存
如果另外一个线程b执行x=x-1,执行过程如下:
1 从主存中读取变量x副本到工作内存
2 给x减1
3 将x减1后的值写回主存
那么显然,最终的x的值是不可靠的。假设x现在为10,线程a加1,线程b减1,从表面上看,似乎最终x还是为10,但是多线程情况下会有这种情况发生:
1:线程a从主存读取x副本到工作内存,工作内存中x值为10
2:线程b从主存读取x副本到工作内存,工作内存中x值为10
3:线程a将工作内存中x加1,工作内存中x值为11
4:线程a将x提交主存中,主存中x为11
5:线程b将工作内存中x值减1,工作内存中x值为9
6:线程b将x提交到中主存中,主存中x为9
同样,x有可能为11,如果x是一个银行账户,线程a存款,线程b扣款,显然这样是有严重问题的,要解决这个问题,必须保证线程a和线程b是有序执行的,并且每个线程执行的加1或减1是一个原子操作。

synchronized关键字
        java用synchronized关键字做为多线程并发环境的执行有序性的保证手段之一。当一段代码会修改共享变量,这一段代码成为互斥区或临界区,为了保证共享变量的正确性,synchronized标示了临界区。典型的用法如下:

Java代码  

  1. synchronized(锁){   
  2.      临界区代码   
  3. }   

synchronized(锁){

     临界区代码

}

 

理论上,每个对象都可以做为锁,但一个对象做为锁时,应该被多个线程共享,这样才显得有意义,在并发环境下,一个没有共享的对象作为锁是没有意义的。假如有这样的代码:

Java代码  

  1. public class ThreadTest{   
  2.   public void test(){   
  3.      Object lock=new Object();   
  4.      synchronized (lock){   
  5.         //do something   
  6.      }   
  7.   }   
  8. }  

public class ThreadTest{

  public void test(){

     Object lock=new Object();

     synchronized (lock){

        //do something

     }

  }

}

 

lock变量作为一个锁存在根本没有意义,因为它根本不是共享对象,每个线程进来都会执行Object lock=new Object();每个线程都有自己的lock,根本不存在锁竞争。
        每个锁对象都有两个队列,一个是就绪队列,一个是阻塞队列,就绪队列存储了将要获得锁的线程,阻塞队列存储了被阻塞的线程,当一个被线程被唤醒 (notify)后,才会进入到就绪队列,等待cpu的调度。当一开始线程a第一次执行account.add方法时,jvm会检查锁对象account 的就绪队列是否已经有线程在等待,如果有则表明account的锁已经被占用了,由于是第一次运行,account的就绪队列为空,所以线程a获得了锁, 执行account.add方法。如果恰好在这个时候,线程b要执行account.withdraw方法,因为线程a已经获得了锁还没有释放,所以线程 b要进入account的就绪队列,等到得到锁后才可以执行。
一个线程执行临界区代码过程如下:
1 获得同步锁
2 清空工作内存
3 从主存拷贝变量副本到工作内存
4 对这些变量计算
5 将变量从工作内存写回到主存
6 释放锁
可见,synchronized既保证了多线程的并发有序性,又保证了多线程的内存可见性。

 

可能 很多人都觉得莫名其妙,说JVM的内存模型,怎么会扯到cpu上去呢?在此,我认为很有必要阐述下,免得很多人看得不明不白的。先抛开java虚拟机不 谈,我们都知道,现在的计算机,cpu在计算的时候,并不总是从内存读取数据,它的数据读取顺序优先级是:寄存器-高速缓存-内存。线程耗费的是CPU, 线程计算的时候,原始的数据来自内存,在计算过程中,有些数据可能被频繁读取,这些数据被存储在寄存器和高速缓存中,当线程计算完后,这些缓存的数据在适 当的时候应该写回内存。当个多个线程同时读写某个内存数据时,就会产生多线程并发问题,涉及到三个特性:原子性,有序性,可见性。在《线程安全总结》这篇 文章中,为了理解方便,我把原子性和有序性统一叫做“多线程执行有序性”。支持多线程的平台都会面临这种问题,运行在多线程平台上支持多线程的语言应该提 供解决该问题的方案。

 

       那么,我们看看JVM,JVM是一个虚拟的计算机,它也会面临多线程并发问题,java程序运行在java虚拟机平台上,java程序员不可能直接去控制 底层线程对寄存器高速缓存内存之间的同步,那么java从语法层面,应该给开发人员提供一种解决方案,这个方案就是诸如 synchronized, volatile,锁机制(如同步块,就绪队列,阻塞队列)等等。这些方案只是语法层面的,但我们要从本质上去理解它,不能仅仅知道一个 synchronized 可以保证同步就完了。   在这里我说的是jvm的内存模型,是动态的,面向多线程并发的,沿袭JSL的“working memory”的说法,只是不想牵扯到太多底层细节,因为《线程安全总结》这篇文章意在说明怎样从语法层面去理解java的线程同步,知道各个关键字的使用场景。

 

      今天有人问我,那java的线程不是有栈吗?难道栈不是工作内存吗?工作内存这四个字得放到具体的场景中描述,方能体现它具体的意义,在描述JVM的线程 同步时,工作内存指的是寄存器和告诉缓存的抽象描述,具体请自行参阅JLS。上面讲的都是动态的内存模型,甚至已经超越了JVM的范围,那么JVM的内存 静态存储是怎么划分的?今天还有人问我,jvm的内存模型不是有eden区吗?也不见你提起。我跟他说,这是两个角度去看的,甚至是两个不同的范围,动态 的线程同步的内存模型,涵盖了cpu,寄存器,高速缓存,内存;JVM的静态内存储模型只是一种对内存的物理划分而已,它只局限在内存,而且只局限在 JVM的内存。那些什么线程栈,eden区都仅仅在JVM内存。

 

      说说JVM的线程栈和有个朋友反复跟我纠结的eden区吧。JVM的内存,被划分了很多的区域:

1.程序计数器
每一个Java线程都有一个程序计数器来用于保存程序执行到当前方法的哪一个指令。
2.线程栈
线程的每个方法被执行的时候,都会同时创建一个帧(Frame)用于存储本地变量表、操作栈、动态链接、方法出入口等信息。每一个方法的调用至完成,就意 味着一个帧在VM栈中的入栈至出栈的过程。如果线程请求的栈深度大于虚拟机所允许的深度,将抛出StackOverflowError异常;如果VM栈可 以动态扩展(VM Spec中允许固定长度的VM栈),当扩展时无法申请到足够内存则抛出OutOfMemoryError异常。
3.本地方法栈
4.堆

每个线程的栈都是该线程私有的,堆则是所有线程共享的。当我们new一个对象时,该对象就被分配到了堆中。但是堆,并不是一个简单的概念,堆区又划分了很 多区域,为什么堆划分成这么多区域,这是为了JVM的内存垃圾收集,似乎越扯越远了,扯到垃圾收集了,现在的jvm的gc都是按代收集,堆区大致被分为三 大块:新生代,旧生代,持久代(虚拟的);新生代又分为eden区,s0区,s1区。新建一个对象时,基本小的对象,生命周期短的对象都会放在新生代的 eden区中,eden区满时,有一个小范围的gc(minor gc),整个新生代满时,会有一个大范围的gc(major gc),将新生代里的部分对象转到旧生代里。
5.方法区
其实就是永久代(Permanent Generation),方法区中存放了每个Class的结构信息,包括常量池、字段描述、方法描述等等。VM Space描述中对这个区域的限制非常宽松,除了和Java堆一样不需要连续的内存,也可以选择固定大小或者可扩展外,甚至可以选择不实现垃圾收集。相对 来说,垃圾收集行为在这个区域是相对比较少发生的,但并不是某些描述那样永久代不会发生GC(至 少对当前主流的商业JVM实现来说是如此),这里的GC主要是对常量池的回收和对类的卸载,虽然回收的“成绩”一般也比较差强人意,尤其是类卸载,条件相 当苛刻。
6.常量池
 Class文件中除了有类的版本、字段、方法、接口等描述等信息外,还有一项信息是常量表(constant_pool table),用于存放编译期已可知的常量,这部分内容将在类加载后进入方法区(永久代)存放。但是Java语言并不要求常量一定只有编译期预置入 Class的常量表的内容才能进入方法区常量池,运行期间也可将新内容放入常量池(最典型的String.intern()方法)。

 

 

3.一个线程不安全的例子

  当我们查看JDK API的时候,总会发现一些类说明写着,线程安全或者线程不安全,比如说StringBuilder中,有这么一句,“将StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步,则建议使用StringBuffer。 ”,那么下面手动创建一个线程不安全的类,然后在多线程中使用这个类,看看有什么效果。

        Count.java:

 

 public class Count {  
    private int num;  
    public void count() {  
        for(int i = 1; i <= 10; i++) {  
            num += i;  
        }  
        System.out.println(Thread.currentThread().getName() + "-" + num);  
    }  
} 

 

  在这个类中的count方法是计算1一直加到10的和,并输出当前线程名和总和,我们期望的是每个线程都会输出55。

ThreadTest.java:

 

 public class ThreadTest {  
    public static void main(String[] args) {  
        Runnable runnable = new Runnable() {  
            Count count = new Count();  
            public void run() {  
                count.count();  
            }  
        };  
        for(int i = 0; i < 10; i++) {  
            new Thread(runnable).start();  
        }  
    }  
} 

 

 

 

 

这里启动了10个线程,看一下输出结果:

 

 Thread-0-55  
Thread-1-110  
Thread-2-165  
Thread-4-220  
Thread-5-275  
Thread-6-330  
Thread-3-385  
Thread-7-440  
Thread-8-495  
Thread-9-550

 

 

 

只有Thread-0线程输出的结果是我们期望的,而输出的是每次都累加的,这里累加的原因以后的博文会说明,那么要想得到我们期望的结果,有几种解决方案:

  1. 将Count中num变成count方法的局部变量(局部变量不存在线程安全问题)

    public class Count {

     public void count() {  
         int num = 0;  
         for(int i = 1; i <= 10; i++) {  
             num += i;  
         }  
         System.out.println(Thread.currentThread().getName() + "-" + num);  
     }  
    

    }

 

  1. 将线程类成员变量拿到run方法中,这时count引用是线程内的局部变量;

    public class ThreadTest4 {

     public static void main(String[] args) {  
         Runnable runnable = new Runnable() {  
             public void run() {  
                 Count count = new Count();  
                 count.count();  
             }  
         };  
         for(int i = 0; i < 10; i++) {  
             new Thread(runnable).start();  
         }  
     }  
    

    }

  2. 每次启动一个线程使用不同的线程类,不推荐。

  上述测试,我们发现,存在成员变量的类用于多线程时是不安全的,不安全体现在这个成员变量可能发生非原子性的操作, 而变量定义在方法内也就是局部变量是线程安全的。想想在使用struts1时,不推荐创建成员变量,因为action是单例的,如果创建了成员变量,就会 存在线程不安全的隐患,而struts2是每一次请求都会创建一个action,就不用考虑线程安全的问题。所以,日常开发中,通常需要考虑成员变量或者 说全局变量在多线程环境下,是否会引发一些问题。

 

计算机硬件架构:

 

云顶集团用户登录 2

CPU乱序

synchronized(锁){
临界区代码
}

线程的工作内存

CPU Registers(寄存器):每个CPU都包含一系列的寄存器,他们是CPU内存的基础,CPU在寄存器上执行的速度远大于在主存上执行的速度。

         当一个VolatileTest对象被多个线程共享,a的值不一定是正确的,因为a=a+count包含了好几步操作,而此时多个线程的执行是无序的,因为没有任何机制来保证多个线程的执行有序性和原子性。volatile存在的意义是,任何线程对a的修改,都会马上被其他线程读取到,因为直接操作主存,没有线程对工作内存和主存的同步。所以,volatile的使用场景是有限的,在有限的一些情形下可以使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全,必须同时满足下面两个条件:

上面讲的都是动态的内存模型,甚至已经超越了JVM的范围。JVM的静态内存储模型

一个写请求只有在M状态,或者E状态的时候才能给被执行,如果是处在S状态的时候,他必须先将该缓存行变成I状态,

synchronized关键字 
        上面说了,java用synchronized关键字做为多线程并发环境的执行有序性的保证手段之一。当一段代码会修改共享变量,这一段代码成为互斥区或临界区,为了保证共享变量的正确性,synchronized标示了临界区。典型的用法如下:

工作内存这四个字得放到具体的场景中描述,方能体现它具体的意义,在描述JVM的线程同步时,工作内存指的是寄存器和高速缓存的抽象描述,具体请自行参阅JLS。

线程和主内存的抽象关系

拿到鸡蛋

Java 内存模型规定了所有变量都存储在主内存(Main Memory)中。工作内存

9.对一个变量执行unlock操作之前,必须先把此变量同步到主内存中(执行store和write操作)

  public volatile int a;

云顶集团用户登录 3

云顶集团用户登录 4

lock变量作为一个锁存在根本没有意义,因为它根本不是共享对象,每个线程进来都会执行Object lock=new Object();每个线程都有自己的lock,根本不存在锁竞争。

JVM的静态内存储模型只是一种对内存的物理划分而已,它只局限在内存,而且只局限在JVM的内存。那些什么线程栈,eden区都仅仅在JVM内存。

2.不允许read和load、store和write操作之一单独出现

拿到鸡蛋

Java 内存模型的组成主内存

3.不允许一个线程丢弃他的最近assign的操作,即变量在工作内存中改变了之后必须同步到主内存中

  }

我们都知道,现在的计算机,cpu在计算的时候,并不总是从内存读取数据,它的数据读取顺序优先级 是:寄存器-高速缓存-内存。线程耗费的是CPU,线程计算的时候,原始的数据来自内存,在计算过程中,有些数据可能被频繁读取,这些数据被存储在寄存器 和高速缓存中,当线程计算完后,这些缓存的数据在适当的时候应该写回内存。当个多个线程同时读写某个内存数据时,就会产生多线程并发问题,涉及到三个特性:原子性,有序性,可见性。那 Java的线程不是有栈吗?难道栈不是工作内存吗?

线程和主内存的抽象关系

public class ThreadTest{
  public void test(){
     Object lock=new Object();
     synchronized (lock){
        //do something
     }
  }
}

动态的线程同步的内存模型,涵盖了CPU,寄存器,高速缓存,内存。

为什么需要CPU cache?:

放入鸡蛋

所谓线程的“工作内存”到底是个什么东西?有的人认为是线程的栈,其实这种理解是不正确的。看看JLS对线程工作内存的描述,线程的working memory只是cpu的寄存器和高速缓存的抽象描述。

所有线程栈和堆会被保存在缓存里面,部分可能会出现在CPU缓存中和CPU内部的寄存器里面

  public void add(int count){

5.一个新的变量只能在主内存中诞生,不允许在工作内存中直接使用一个未被初始化(load或assign)的变量。即就是对一个变量实施use和store操作之前,必须先执行过了load和assign操作

在没有volatile声明时,多线程环境下,a的最终值不一定是正确的,因为this.a=a;涉及到给a赋值和将a同步回主存的步骤,这个顺序可能被打乱。如果用volatile声明了,读取主存副本到工作内存和同步a到主存的步骤,相当于是一个原子操作。所以简单来说,volatile适合这种场景:一个变量被多个线程共享,线程直接给这个变量赋值。这是一种很简单的同步场景,这时候使用volatile的开销将会非常小。

所以cache的出现,是为了缓解CPU和内存之间速度的不匹配问题(结构:cpu->cache->memort)

 

6.assign(赋值):作用于工作内存的变量,它把一个从执行引擎接受到的值赋值给工作内存的变量

1)对变量的写操作不依赖于当前值。
2)该变量没有包含在具有其他变量的不变式中 
volatile只保证了可见性,所以Volatile适合直接赋值的场景,如

处理器为提高运算速度而做出违背代码原有顺序的优化

public synchronized void add(int num) {
     balance = balance + num;
}
public synchronized void withdraw(int num) {
     balance = balance - num;
}

左图为最简单的高速缓存的配置,数据的读取和存储都经过高速缓存,CPU核心与高速缓存有一条特殊的快速通道;主存与高速缓存都连在系统总线上(BUS)这条总线还用于其他组件的通信

 

Heap(堆):java里的堆是一个运行时的数据区,堆是由垃圾回收来负责的,        堆的优势是可以动态的分配内存大小,生存期也不必事先告诉编译器,        因为他是在运行时动态分配内存的,java的垃圾回收器会定时收走不用的数据,        缺点是由于要在运行时动态分配,所有存取速度可能会慢一些Stack(栈):栈的优势是存取速度比堆要快,仅次于计算机里的寄存器,栈的数据是可以共享的,          缺点是存在栈中的数据的大小与生存期必须是确定的,缺乏一些灵活性          栈中主要存放一些基本类型的变量,比如int,short,long,byte,double,float,boolean,char,对象句柄,java内存模型要求调用栈和本地内存变量存放在线程栈(Thread Stack)上,对象存放在堆上。一个本地变量可能存放一个对象的引用,这时引用变量存放在本地栈上,但是对象本身存放在堆上成员变量跟随着对象存放在堆上,而不管是原始类型还是引用类型,静态成员变量跟随着类的定义一起存在在堆上存在堆上的对象,可以被持有这个对象的引用的线程访问如果两个线程同时访问同一个对象的私有变量,这时他们获得的是这个对象的私有拷贝

     临界区代码

每个线程之间共享变量都存放在主内存里面,每个线程都有一个私有的本地内存

浅谈java内存模型 
       不同的平台,内存模型是不一样的,但是jvm的内存模型规范是统一的。其实java的多线程并发问题最终都会反映在java的内存模型上,所谓线程安全无非是要控制多个线程对某个资源的有序访问或修改。总结java的内存模型,要解决两个主要的问题:可见性和有序性。我们都知道计算机有高速缓存的存在,处理器并不是每次处理数据都是取内存的。JVM定义了自己的内存模型,屏蔽了底层平台内存管理细节,对于java开发人员,要清楚在jvm内存模型的基础上,如果解决多线程的可见性和有序性。
       那么,何谓可见性? 多个线程之间是不能互相传递数据通信的,它们之间的沟通只能通过共享变量来进行。Java内存模型(JMM)规定了jvm有主内存,主内存是多个线程共享的。当new一个对象的时候,也是被分配在主内存中,每个线程都有自己的工作内存,工作内存存储了主存的某些对象的副本,当然线程的工作内存大小是有限制的。当线程操作某个对象时,执行顺序如下:
 (1) 从主存复制变量到当前工作内存 (read and load)
 (2) 执行代码,改变共享变量值 (use and assign)
 (3) 用工作内存数据刷新主存相关内容 (store and write)

但是S状态可能是非一致的,如果一个缓存将处于S状态的 缓存行作废了,另一个缓存可能已经独享了该缓存行,

刚才不是说了synchronized的用法是这样的吗:

1.用于保证多个CPU cache之间缓存共享数据的一致

public class VolatileTest{

1.如果要把一个变量从主内存中赋值到工作内存,就需要按顺序得执行read和load操作,如果把变量从工作内存中同步回主内存中,就要按顺序得执行store和write操作,但java内存模型只要求上述操作必须按顺序执行,没有保证必须是连续执行

最近想将java基础的一些东西都整理整理,写下来,这是对知识的总结,也是一种乐趣。已经拟好了提纲,大概分为这几个主题: java线程安全,java垃圾收集,java并发包详细介绍,java profile和jvm性能调优 。慢慢写吧。本人jameswxx原创文章,转载请注明出处,我费了很多心血,多谢了。关于java线程安全,网上有很多资料,我只想从自己的角度总结对这方面的考虑,有时候写东西是很痛苦的,知道一些东西,但想用文字说清楚,却不是那么容易。我认为要认识java线程安全,必须了解两个主要的点:java的内存模型,java的线程同步机制。特别是内存模型,java的线程同步机制很大程度上都是基于内存模型而设定的。后面我还会写java并发包的文章,详细总结如何利用java并发包编写高效安全的多线程并发程序。暂时写得比较仓促,后面会慢慢补充完善。

java内存分配

拿到鸡蛋

8.write(写入):作用于主内存的变量,它把store操作从工作内存中一个变量的值传送到主内存的变量中

import java.util.ArrayList;
import java.util.List;

public class Plate {

    List<Object> eggs = new ArrayList<Object>();

    public synchronized Object getEgg() {
        while(eggs.size() == 0) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }

        Object egg = eggs.get(0);
        eggs.clear();// 清空盘子
        notify();// 唤醒阻塞队列的某线程到就绪队列
        System.out.println("拿到鸡蛋");
        return egg;
    }

    public synchronized void putEgg(Object egg) {
        while(eggs.size() > 0) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        eggs.add(egg);// 往盘子里放鸡蛋
        notify();// 唤醒阻塞队列的某线程到就绪队列
        System.out.println("放入鸡蛋");
    }

    static class AddThread extends Thread{
        private Plate plate;
        private Object egg=new Object();
        public AddThread(Plate plate){
            this.plate=plate;
        }

        public void run(){
            for(int i=0;i<5;i++){
                plate.putEgg(egg);
            }
        }
    }

    static class GetThread extends Thread{
        private Plate plate;
        public GetThread(Plate plate){
            this.plate=plate;
        }

        public void run(){
            for(int i=0;i<5;i++){
                plate.getEgg();
            }
        }
    }

    public static void main(String args[]){
        try {
            Plate plate=new Plate();
            Thread add=new Thread(new AddThread(plate));
            Thread get=new Thread(new GetThread(plate));
            add.start();
            get.start();
            add.join();
            get.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("测试结束");
    }
}

在一个典型的多核系统中,每一个核都会有自己的缓存来共享主存总线,每一个CPU会发出读写(I/O)请求,而缓存的目的是为了减少CPU读写共享主存的次数;

volatile关键字 
       volatile是java提供的一种同步手段,只不过它是轻量级的同步,为什么这么说,因为volatile只能保证多线程的内存可见性,不能保证多线程的执行有序性。而最彻底的同步要保证有序性和可见性,例如synchronized。任何被volatile修饰的变量,都不拷贝副本到工作内存,任何修改都及时写在主存。因此对于Valatile修饰的变量的修改,所有线程马上就能看到,但是volatile不能保证对变量的修改是有序的。什么意思呢?假如有这样的代码:

本地内存中存储了以读或者写共享变量的拷贝的一个副本

}

同步规则

 

2.unlock(解锁):作用于主内存的变量,把一个处于锁定状态的变量释放出来,释放后的变量才可以被其他线程锁定

测试结束

云顶集团用户登录 5

声明一个Plate对象为plate,被线程A和线程B共享,A专门放鸡蛋,B专门拿鸡蛋。假设
1 开始,A调用plate.putEgg方法,此时eggs.size()为0,因此顺利将鸡蛋放到盘子,还执行了notify()方法,唤醒锁的阻塞队列的线程,此时阻塞队列还没有线程。
2 又有一个A线程对象调用plate.putEgg方法,此时eggs.size()不为0,调用wait()方法,自己进入了锁对象的阻塞队列。
3 此时,来了一个B线程对象,调用plate.getEgg方法,eggs.size()不为0,顺利的拿到了一个鸡蛋,还执行了notify()方法,唤醒锁的阻塞队列的线程,此时阻塞队列有一个A线程对象,唤醒后,它进入到就绪队列,就绪队列也就它一个,因此马上得到锁,开始往盘子里放鸡蛋,此时盘子是空的,因此放鸡蛋成功。
4 假设接着来了线程A,就重复2;假设来料线程B,就重复3。 
整个过程都保证了放鸡蛋,拿鸡蛋,放鸡蛋,拿鸡蛋。

同样由于缓存并没有保存该缓存行被COPY的数量,因此没有办法确定是否独享了改缓存行,

站内很多人都问我,所谓线程的“工作内存”到底是个什么东西?有的人认为是线程的栈,其实这种理解是不正确的。看看JLS(java语言规范)对线程工作内存的描述,线程的working memory只是cpu的寄存器和高速缓存的抽象描述。

当运行结束后,会将寄存器中的值刷新回缓存中,并在某个时间点刷新回主存

拿到鸡蛋

                    将运算使用到的数据复制到缓存中,让运算能够快速的执行,当运算结束后,再从缓存同步到内存之中,这样,CPU就不需要等待缓慢的内存读写了

云顶集团用户登录, 

云顶集团用户登录 6

1.程序计数器
每一个Java线程都有一个程序计数器来用于保存程序执行到当前方法的哪一个指令。
2.线程栈
线程的每个方法被执行的时候,都会同时创建一个帧(Frame)用于存储本地变量表、操作栈、动态链接、方法出入口等信息。每一个方法的调用至完成,就意味着一个帧在VM栈中的入栈至出栈的过程。如果线程请求的栈深度大于虚拟机所允许的深度,将抛出StackOverflowError异常;如果VM栈可以动态扩展(VM Spec中允许固定长度的VM栈),当扩展时无法申请到足够内存则抛出OutOfMemoryError异常。
3.本地方法栈
4.堆

每个线程的栈都是该线程私有的,堆则是所有线程共享的。当我们new一个对象时,该对象就被分配到了堆中。但是堆,并不是一个简单的概念,堆区又划分了很多区域,为什么堆划分成这么多区域,这是为了JVM的内存垃圾收集,似乎越扯越远了,扯到垃圾收集了,现在的jvm的gc都是按代收集,堆区大致被分为三大块:新生代,旧生代,持久代(虚拟的);新生代又分为eden区,s0区,s1区。新建一个对象时,基本小的对象,生命周期短的对象都会放在新生代的eden区中,eden区满时,有一个小范围的gc(minor gc),整个新生代满时,会有一个大范围的gc(major gc),将新生代里的部分对象转到旧生代里。
5.方法区 
其实就是永久代(Permanent Generation),方法区中存放了每个Class的结构信息,包括常量池、字段描述、方法描述等等。VM Space描述中对这个区域的限制非常宽松,除了和Java堆一样不需要连续的内存,也可以选择固定大小或者可扩展外,甚至可以选择不实现垃圾收集。相对来说,垃圾收集行为在这个区域是相对比较少发生的,但并不是某些描述那样永久代不会发生GC(至 少对当前主流的商业JVM实现来说是如此),这里的GC主要是对常量池的回收和对类的卸载,虽然回收的“成绩”一般也比较差强人意,尤其是类卸载,条件相当苛刻。
6.常量池
 Class文件中除了有类的版本、字段、方法、接口等描述等信息外,还有一项信息是常量表(constant_pool table),用于存放编译期已可知的常量,这部分内容将在类加载后进入方法区(永久代)存放。但是Java语言并不要求常量一定只有编译期预置入Class的常量表的内容才能进入方法区常量池,运行期间也可将新内容放入常量池(最典型的String.intern()方法)。

缓存一致性(MESI)

      今天有人问我,那java的线程不是有栈吗?难道栈不是工作内存吗?工作内存这四个字得放到具体的场景中描述,方能体现它具体的意义,在描述JVM的线程同步时,工作内存指的是寄存器和告诉缓存的抽象描述,具体请自行参阅JLS。上面讲的都是动态的内存模型,甚至已经超越了JVM的范围,那么JVM的内存静态存储是怎么划分的?今天还有人问我,jvm的内存模型不是有eden区吗?也不见你提起。我跟他说,这是两个角度去看的,甚至是两个不同的范围,动态的线程同步的内存模型,涵盖了cpu,寄存器,高速缓存,内存;JVM的静态内存储模型只是一种对内存的物理划分而已,它只局限在内存,而且只局限在JVM的内存。那些什么线程栈,eden区都仅仅在JVM内存。

      该缓存行中的数据需要在未来的某个时间点(允许其他CPU读取主存相应中的内容之前)写回主存,然后状态变成E(独享)

云顶,        每个锁对象都有两个队列,一个是就绪队列,一个是阻塞队列,就绪队列存储了将要获得锁的线程,阻塞队列存储了被阻塞的线程,当一个被线程被唤醒 (notify)后,才会进入到就绪队列,等待cpu的调度。当一开始线程a第一次执行account.add方法时,jvm会检查锁对象account 的就绪队列是否已经有线程在等待,如果有则表明account的锁已经被占用了,由于是第一次运行,account的就绪队列为空,所以线程a获得了锁,执行account.add方法。如果恰好在这个时候,线程b要执行account.withdraw方法,因为线程a已经获得了锁还没有释放,所以线程 b要进入account的就绪队列,等到得到锁后才可以执行。
一个线程执行临界区代码过程如下:
1 获得同步锁
2 清空工作内存
3 从主存拷贝变量副本到工作内存
4 对这些变量计算
5 将变量从工作内存写回到主存
6 释放锁
可见,synchronized既保证了多线程的并发有序性,又保证了多线程的内存可见性。

从一个更低的层次来说,线程本地内存,他是cpu缓存,寄存器的一个抽象描述,而JVM的静态内存存储模型,

  }

一个处于S状态的缓存行,也必须监听其他缓存使该缓存行无效,或者独享该缓存行的请求,并将缓存行变成无效

        理论上,每个对象都可以做为锁,但一个对象做为锁时,应该被多个线程共享,这样才显得有意义,在并发环境下,一个没有共享的对象作为锁是没有意义的。假如有这样的代码:

但是该缓存缺不会讲该缓存行升迁为E状态,这是因为其他缓存不会广播他们已经作废掉该缓存行的通知,

如果一个线程获得了锁lock,进入了同步块,执行lock.wait(),那么这个线程会进入到lock的阻塞队列。如果调用 lock.notify()则会通知阻塞队列的某个线程进入就绪队列。

                    所以现代计算机都会加入一层读写速度与处理器处理速度接近想通的高级缓存来作为内存与处理器之间的缓冲,

public class Account {   

    private int balance;   

    public Account(int balance) {   
        this.balance = balance;   
    }   

    public int getBalance() {   
        return balance;   
    }   

    public void add(int num) {   
        balance = balance + num;   
    }   

    public void withdraw(int num) {   
        balance = balance - num;   
    }   

    public static void main(String[] args) throws InterruptedException {   
        Account account = new Account(1000);   
        Thread a = new Thread(new AddThread(account, 20), "add");   
        Thread b = new Thread(new WithdrawThread(account, 20), "withdraw");   
        a.start();   
        b.start();   
        a.join();   
        b.join();   
        System.out.println(account.getBalance());   
    }   

    static class AddThread implements Runnable {   
        Account account;   
        int     amount;   

        public AddThread(Account account, int amount) {   
            this.account = account;   
            this.amount = amount;   
        }   

        public void run() {   
            for (int i = 0; i < 200000; i++) {   
                account.add(amount);   
            }   
        }   
    }   

    static class WithdrawThread implements Runnable {   
        Account account;   
        int     amount;   

        public WithdrawThread(Account account, int amount) {   
            this.account = account;   
            this.amount = amount;   
        }   

        public void run() {   
            for (int i = 0; i < 100000; i++) {   
                account.withdraw(amount);   
            }   
        }   
    }   
}  

7.如果一个变量执行lock操作,将会清空工作内存中此变量的值,在执行引擎中使用这个变量前需要重新执行load或assign操作初始化变量的值

public class VolatileTest{

1.时间局部性:如果某个数据被访问,那么在不久的将来他很可能被再次访问

放入鸡蛋

一个缓存除了在Invaild状态,都可以满足CPU 的读请求

 

  E:Exclusive 独享 缓存行只被缓存在该CPU的缓存中,是未被修改过的,与主存的数据是一致的,可以在任何时刻当有其他CPU读取该内存时,变成S(共享)状态,当CPU修改该缓存行的内容时,变成M(被修改)的状态

线程有可能只对工作内存中的副本进行赋值,只到最后一次赋值后才同步到主存储区,所以assign,store,weite顺序可以由JVM实现系统决定。假设有一个共享变量x,线程a执行x=x+1。从上面的描述中可以知道x=x+1并不是一个原子操作,它的执行过程如下:
1 从主存中读取变量x副本到工作内存
2 给x加1
3 将x加1后的值写回主 存
如果另外一个线程b执行x=x-1,执行过程如下:
1 从主存中读取变量x副本到工作内存
2 给x减1
3 将x减1后的值写回主存 
那么显然,最终的x的值是不可靠的。假设x现在为10,线程a加1,线程b减1,从表面上看,似乎最终x还是为10,但是多线程情况下会有这种情况发生:
1:线程a从主存读取x副本到工作内存,工作内存中x值为10
2:线程b从主存读取x副本到工作内存,工作内存中x值为10
3:线程a将工作内存中x加1,工作内存中x值为11
4:线程a将x提交主存中,主存中x为11
5:线程b将工作内存中x值减1,工作内存中x值为9
6:线程b将x提交到中主存中,主存中x为9 
同样,x有可能为11,如果x是一个银行账户,线程a存款,线程b扣款,显然这样是有严重问题的,要解决这个问题,必须保证线程a和线程b是有序执行的,并且每个线程执行的加1或减1是一个原子操作。看看下面代码:

云顶集团用户登录 7

 

7.store(存储):作用于工作内存的变量,把工作内存中的一个变量的值传送到主内存中,以便随后的write的操作

      可能 很多人都觉得莫名其妙,说JVM的内存模型,怎么会扯到cpu上去呢?在此,我认为很有必要阐述下,免得很多人看得不明不白的。先抛开java虚拟机不谈,我们都知道,现在的计算机,cpu在计算的时候,并不总是从内存读取数据,它的数据读取顺序优先级是:寄存器-高速缓存-内存。线程耗费的是CPU,线程计算的时候,原始的数据来自内存,在计算过程中,有些数据可能被频繁读取,这些数据被存储在寄存器和高速缓存中,当线程计算完后,这些缓存的数据在适当的时候应该写回内存。当个多个线程同时读写某个内存数据时,就会产生多线程并发问题,涉及到三个特性:原子性,有序性,可见性。在《线程安全总结》这篇文章中,为了理解方便,我把原子性和有序性统一叫做“多线程执行有序性”。支持多线程的平台都会面临这种问题,运行在多线程平台上支持多线程的语言应该提供解决该问题的方案。

remote read:将内(主)存中的数据读取到缓存中来

放入鸡蛋

在高速缓存出现后不久,系统变得越来越复杂,高速缓存与主存之间的速度差异被拉大,直到加入了另一级缓存,新加入的这级缓存比第一缓存更大,并且更慢,而且经济上不合适,所以有了二级缓存,甚至是三级缓存

执行结果:

  M: Modified 修改,指的是该缓存行只被缓存在该CPU的缓存中,并且是被修改过的,因此他与主存中的数据是不一致的,

 for(int i=0;i<10;i++)

本地内存是java内存模型中抽象的概念,并不是真实存在的(他涵盖了缓存写缓冲区。寄存器,以及其他硬件的优化)

 

因此对于M和E状态,他们的数据总是一致的与缓存行的真正状态总是保持一致的,

放入鸡蛋

他只是一种对内存模型的物理划分而已,只局限在内存,而且只局限在JVM的内存

 

2、B从主内存中读取变量

 

这是一种投机性的优化,因为如果一个CPU想修改一个处于S状态的缓存行,总线需要将所有使用该缓存行的COPY的值变成Invaild状态才可以,而修改E状态的缓存缺不需要使用总显示无

}

一个M状态的缓存行必须时刻监听所有试图读该缓存行相对主存的操作,这种操作必须在缓存该缓存行被写会到主存,并将状态变成S状态之前,被延迟执行

 

1、A将本地内存变量刷新到主内存

  public void setA(int a){

内存模型与硬件架构之间的关联:

       那么,我们看看JVM,JVM是一个虚拟的计算机,它也会面临多线程并发问题,java程序运行在java虚拟机平台上,java程序员不可能直接去控制底层线程对寄存器高速缓存内存之间的同步,那么java从语法层面,应该给开发人员提供一种解决方案,这个方案就是诸如 synchronized, volatile,锁机制(如同步块,就绪队列,阻塞队列)等等。这些方案只是语法层面的,但我们要从本质上去理解它,不能仅仅知道一个 synchronized 可以保证同步就完了。   在这里我说的是jvm的内存模型,是动态的,面向多线程并发的,沿袭JSL的“working memory”的说法,只是不想牵扯到太多底层细节,因为《线程安全总结》这篇文章意在说明怎样从语法层面去理解java的线程同步,知道各个关键字的使用场景。

JAVA内存模型规范:

}

如果线程A和线程B要通信,必须经历两个过程:

 

CPU多级缓存

       a=a+count;

一个处于E状态的缓存行,他要监听其他缓存读缓存行的操作,一旦有,那么他讲变成S状态

  S:Share 共享,意味着该缓存行可能会被多个CPU进行缓存,并且该缓存中的数据与主存数据是一致的,当有一个CPU修改该缓存行时,其他CPU是可以被作废的,变成I(无效的)

  a++;

导致的一个问题,如果我们不做任何处理,在多核的情况下,的实际结果可能和逻辑运行结果大不相同,如果在一个核上执行数据写入操作,并在最后执行一个操作来标记数据已经写入好了,而在另外一个核上通过该标记位判定数据是否已经写入,这时候就可能出现不一致,标记位先被写入,但是实际的操作缺并未完成,这个未完成既有可能是没有计算完成,也有可能是缓存没有被及时刷新到主存之中,使得其他核读到了错误的数据

声明一个盘子,只能放一个鸡蛋

2.CPU多级缓存的乱序执行优化

Object lock=new Object();//声明了一个对象作为锁
   synchronized (lock) {
       balance = balance - num;
       //这里放弃了同步锁,好不容易得到,又放弃了
       lock.wait();
}

这个操作通常作用于广播的方式来完成,这个时候他既不允许不同的CPU同时修改同一个缓存行,即使是修改同一个缓存行中不同端的数据也是不可以的,这里主要解决的是缓存一致性的问题,

      说说JVM的线程栈和有个朋友反复跟我纠结的eden区吧。JVM的内存,被划分了很多的区域:

内存模型与硬件架构之间的关联

放入鸡蛋

remote write:将缓存中的数据写会到主存里面

      this.a=a;

4.不允许一个线程无原因地(没有发生过任何assign操作)把数据从工作内存同步到主内存中

  public volatile int a;

5.use(使用):作用于工作内存的变量,把工作内存中的一个变量值传递给执行引擎

那么对于public synchronized void add(int num)这种情况,意味着什么呢?其实这种情况,锁就是这个方法所在的对象。同理,如果方法是public  static synchronized void add(int num),那么锁就是这个方法所在的class。

3.Java内存模型(Java Memory Model,JMM)

第一次执行结果为10200,第二次执行结果为1060,每次执行的结果都是不确定的,因为线程的执行顺序是不可预见的。这是java同步产生的根源,synchronized关键字保证了多个线程对于同步块是互斥的,synchronized作为一种同步手段,解决java多线程的执行有序性和内存可见性,而volatile关键字之解决多线程的内存可见性问题。后面将会详细介绍。

8.如果一个变量事先没有被lock操作锁定,则不允许他执行unlock操作,也不允许去unlock一个被其他线程锁定的变量

JVM规范定义了线程对主存的操作指令:read,load,use,assign,store,write。当一个共享变量在多个线程的工作内存中都有副本时,如果一个线程修改了这个共享变量,那么其他线程应该能够看到这个被修改后的值,这就是多线程的可见性问题。
        那么,什么是有序性呢 ?线程在引用变量时不能直接从主内存中引用,如果线程工作内存中没有该变量,则会从主内存中拷贝一个副本到工作内存中,这个过程为read-load,完成后线程会引用该副本。当同一线程再度引用该字段时,有可能重新从主存中获取变量副本(read-load-use),也有可能直接引用原来的副本 (use),也就是说 read,load,use顺序可以由JVM实现系统决定。
        线程不能直接为主存中中字段赋值,它会将值指定给工作内存中的变量副本(assign),完成后这个变量副本会同步到主存储区(store- write),至于何时同步过去,根据JVM实现系统决定.有该字段,则会从主内存中将该字段赋值到工作内存中,这个过程为read-load,完成后线程会引用该变量副本,当同一线程多次重复对字段赋值时,比如:

local write:将数据写到本地缓存里面

synchronized(锁){

local read:读本地缓存的数据

生产者/消费者模式 
        生产者/消费者模式其实是一种很经典的线程同步模型,很多时候,并不是光保证多个线程对某共享资源操作的互斥性就够了,往往多个线程之间都是有协作的。
        假设有这样一种情况,有一个桌子,桌子上面有一个盘子,盘子里只能放一颗鸡蛋,A专门往盘子里放鸡蛋,如果盘子里有鸡蛋,则一直等到盘子里没鸡蛋,B专门从盘子里拿鸡蛋,如果盘子里没鸡蛋,则等待直到盘子里有鸡蛋。其实盘子就是一个互斥区,每次往盘子放鸡蛋应该都是互斥的,A的等待其实就是主动放弃锁,B 等待时还要提醒A放鸡蛋。
如何让线程主动释放锁
很简单,调用锁的wait()方法就好。wait方法是从Object来的,所以任意对象都有这个方法。看这个代码片段:

八种同步操作

关于垃圾收集,在此不多说,流到垃圾收集那一章再详细说吧。关于java的同步,其实还有基于CPU原语的比较并交换的非阻塞算法(CAS),不过这个在java的并发包里已经实现了很多,因此关于这点,就留到java并发包那一章介绍吧。后面我会专门写一篇文章,JVM内存与垃圾收集。

运作原理:通常情况下,当一个CPU要读取主存的时候,他会将主存中的数据读取到CPU缓存中,甚至将缓存中的内容读到内部寄存器里面,然后再寄存器执行操作,

拿到鸡蛋

1.lock(锁定):作用于主内存的变量,把一个变量标识变为一条线程独占状态

为了保证银行账户的安全,可以操作账户的方法如下:

MESI

 

3.read(读取):作用于主内存的变量,把一个变量值从主内存传输到线程的工作内存中,以便随后的load动作使用

CPU的频率太快了,快到主存跟不上,这样在处理器时钟周期内,CPU常常需要等待主存,浪费资源,

2.空间局部性:如果某个数据被访问,那么与他相邻的数据很快也可能被访问

  I:Invalid 无效的,代表这个缓存是无效的,可能是有其他CPU修改了该缓存行

云顶集团用户登录 8

2.如何以及何时同步的访问共享变量

6.一个变量在同一时刻只允许一条线程对其进行lock操作,但lock操作可以同时被一条线程重复执行多次,多次执行lock后,只有执行相同次数的unlock操作,变量才会解锁,lock和unlock必须成对出现

4.load(载入):作用于工作内存的变量,它把read操作从主内存中得到的变量值放入工作内存的变量副本中

云顶集团用户登录 9

JAVA内存模型:

CPU Cache(高速缓存):由于计算机的存储设备与处理器的处理设备有着几个数量级的差距,

1.CPU多级缓存

计算机架构图示

云顶集团用户登录 10

CPU cache有什么意义:

CPU:一个计算机一般有多个CPU,一个CPU还会有多核

1.规定了一个线程如何和何时可以看到其他线程修改过后的共享变量的值

主(内)存:一个计算机包含一个主存,所有的CPU都可以访问主存,主存比缓存容量大的多

本文由云顶集团网站发布于云顶集团简介,转载请注明出处:并发基础,java线程安全总结

关键词:

最火资讯