线程安全和线程同步Synchronized
来源:互联网 发布:unity3d 引擎 编辑:程序博客网 时间:2024/05/28 11:48
部分转载:
线程安全:http://blog.csdn.net/ghevinn/article/details/37764791
Synchronized: http://blog.csdn.net/ghsau/article/details/7421217
Volatile:http://www.cnblogs.com/aigongsi/archive/2012/04/01/2429166.html
线程安全就是多线程访问时,采用了加锁机制,当一个线程访问该类的某个数据时,进行保护,其他线程不能进行访问直到该线程读取完,其他线程才可使用。不会出现数据不一致或者数据污染。
线程不安全就是不提供数据访问保护,有可能出现多个线程先后更改数据造成所得到的数据是脏数据
1. 概念
如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的。
或者说,一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。
线程安全问题都是由全局变量及静态变量引起的。(这句还未考证,但对全局变量和静态变量操作在多线程模型中会引发线程不安全)
若每个线程中对全局变量、静态变量只有读操作,而无写操作,一般来说,这个全局变量是线程安全的;若有多个线程同时执行写操作,一般都需要考虑线程同步,否则的话就可能影响线程安全。
2. 安全性
比如一个 ArrayList 类,在添加一个元素的时候,它可能会有两步来完成:1. 在 Items[Size] 的位置存放此元素;2. 增大 Size 的值。
在单线程运行的情况下,如果 Size = 0,添加一个元素后,此元素在位置 0,而且 Size=1;
而如果是在多线程情况下,比如有两个线程,线程 A 先将元素存放在位置 0。但是此时 CPU 调度线程A暂停,线程 B 得到运行的机会。线程B也向此 ArrayList 添加元素,因为此时 Size 仍然等于 0 (注意哦,我们假设的是添加一个元素是要两个步骤哦,而线程A仅仅完成了步骤1),所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行,都增加 Size 的值。
那好,我们来看看 ArrayList 的情况,元素实际上只有一个,存放在位置 0,而 Size 却等于 2。这就是“线程不安全”了。
3. 线程同步
3.1 Synchronized(同步)
public class TraditionalThreadSynchronized { public static void main(String[] args) { final Outputter outputter = new Outputter(); // 运行两个线程分别输出名字zhangsan和lisi new Thread() { public void run() { outputter.output("zhangsan"); } }.start(); new Thread() { public void run() { outputter.output("lisi"); } }.start(); }}class Outputter { public void output(String name) { // TODO 为了保证对name的输出不是一个原子操作,这里逐个输出name的每个字符 for(int i = 0; i < name.length(); i++) { System.out.print(name.charAt(i)); // Thread.sleep(10); } }}
运行结果:zhlainsigsan
显然输出的字符串被打乱了,我们期望的输出结果是zhangsanlisi,这就是线程同步问题,我们希望output方法被一个线程完整的执行完之后再切换到下一个线程,Java中使用synchronized保证一段代码在多线程执行时是互斥的,有两种用法:
方法 1: 使用synchronized将需要互斥的代码包含起来,并上一把锁。
{ synchronized (this) { for(int i = 0; i < name.length(); i++) { System.out.print(name.charAt(i)); } }}
这把锁必须是需要互斥的多个线程间的共享对象,像下面的代码是没有意义的。
{ Object lock = new Object(); synchronized (lock) { for(int i = 0; i < name.length(); i++) { System.out.print(name.charAt(i)); } }}
方法2:将synchronized加在需要互斥的方法上。
public synchronized void output(String name) { // TODO 线程输出方法 for(int i = 0; i < name.length(); i++) { System.out.print(name.charAt(i)); }}
这种方式就相当于用this锁住整个方法内的代码块,如果用synchronized加在静态方法上,就相当于用××××.class锁住整个方法内的代码块。使用synchronized在某些情况下会造成死锁,死锁问题以后会说明。使用synchronized修饰的方法或者代码块可以看成是一个 原子操作。
每个锁对象(JLS(java语言规范)中叫monitor)都有两个队列,一个是就绪队列,一个是阻塞队列,就绪队列存储了将要获得锁的线程,阻塞队列存储了被阻塞的线程,当一个线程被唤醒(notify)后,才会进入到就绪队列,等待CPU的调度,反之,当一个线程被wait后,就会进入阻塞队列,等待下一次被唤醒,这个涉及到线程间的通信。看我们的例子,当第一个线程执行输出方法时,获得同步锁,执行输出方法,恰好此时第二个线程也要执行输出方法,但发现同步锁没有被释放,第二个线程就会进入就绪队列,等待锁被释放。一个线程执行互斥代码过程如下:
1. 获得同步锁; 2. 清空工作内存; 3. 从主内存拷贝对象副本到工作内存; 4. 执行代码(计算或者输出等); 5. 刷新主内存数据; 6. 释放同步锁。 所以,synchronized既保证了多线程的并发有序性,又保证了多线程的内存可见性。
#### 3.2 Volatile
用volatile修饰的变量,线程在每次使用变量的时候,都会读取变量修改后的最的值。volatile很容易被误用,用来进行原子性操作。(那应该如何使用呢??)
public class Counter { public static int count = 0; public static void inc() { //这里延迟1毫秒,使得结果明显 try { Thread.sleep(1); } catch (InterruptedException e) { } count++; } public static void main(String[] args) { //同时启动1000个线程,去进行i++计算,看看实际结果 for (int i = 0; i < 1000; i++) { new Thread(new Runnable() { @Override public void run() { Counter.inc(); } }).start(); } //这里每次运行的值都有可能不同,可能为1000 System.out.println("运行结果:Counter.count=" + Counter.count); }}
运行结果:Counter.count=995
实际运算结果每次可能都不一样,本机的结果为:运行结果:Counter.count=995,可以看出,在多线程的环境下,Counter.count并没有期望结果是1000
很多人以为,这个是多线程并发问题,只需要在变量count之前加上volatile就可以避免这个问题,那我们在修改代码看看,看看结果是不是符合我们的期望。
public class Counter { // 在count上使用volatile关键字 public volatile static int count = 0; public static void inc() { //这里延迟1毫秒,使得结果明显 try { Thread.sleep(1); } catch (InterruptedException e) { } count++; } public static void main(String[] args) { //同时启动1000个线程,去进行i++计算,看看实际结果 for (int i = 0; i < 1000; i++) { new Thread(new Runnable() { @Override public void run() { Counter.inc(); } }).start(); } //这里每次运行的值都有可能不同,可能为1000 System.out.println("运行结果:Counter.count=" + Counter.count); }}
运行结果:Counter.count=992
运行结果还是没有我们期望的1000,下面我们分析一下原因
在 java 垃圾回收整理一文中,描述了jvm运行时刻内存的分配。其中有一个内存区域是JVM栈,每一个线程运行时都有一个线程栈,线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候,首先通过对象的引用找到对应在堆内存的变量的值,然后把堆内存变量的具体值load到线程本地内存中,建立一个变量副本,之后线程就不再和对象在堆内存变量值有任何关系,而是直接修改副本变量的值,在修改完之后的某一个时刻(线程退出之前),自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。下面一幅图描述这些交互:
read and load 从主存复制变量到当前工作内存
use and assign 执行代码,改变共享变量值
store and write 用工作内存数据刷新主存相关内容
其中use and assign 可以多次出现
但是这一些操作并不是原子性,也就是 在read load之后,如果主内存count变量发生修改之后,线程工作内存中的值由于已经加载,不会产生对应的变化,所以计算出来的结果会和预期不一样
对于volatile修饰的变量,jvm虚拟机只是保证从主内存加载到线程工作内存的值是当前最新的
例如假如线程1,线程2 在进行read,load 操作中,发现主内存中count的值都是5,那么都会加载这个最新的值
在线程1堆count进行修改之后,会write到主内存中,主内存中的count变量就会变为6
线程2由于已经进行read,load操作,在进行运算之后,也会更新主内存count的变量值为6
导致两个线程及时用volatile关键字修改之后,还是会存在并发的情况。(所以volatile用来干啥?:( )
- 线程安全和线程同步Synchronized
- synchronized 线程同步安全
- 线程安全,线程同步,synchronized
- java并发编程:线程安全-线程同步-synchronized和lock
- Synchronized和线程安全
- 线程同步和线程安全
- 线程同步和线程安全
- 线程同步和线程安全
- Java线程-----------线程安全与不安全与线程同步synchronized和volatile
- Java线程-----------线程安全与不安全与线程同步synchronized和volatile
- 线程同步和安全
- 线程同步synchronized和volatile
- 线程同步synchronized和volatile
- 线程同步synchronized和volatile
- 线程同步synchronized和volatile
- 线程同步:synchronized和Lock
- 线程同步synchronized和volatile
- 线程LOCK机制和synchronized线程同步
- jQuery 怎么实现点击页面其他地方隐藏菜单?
- 深入理解java虚拟机(三):String.intern()-字符串常量池
- Python:时间模块:time和datetime
- 小白笔记----------------判断一个数是不是某个数的次方
- Android——《第一行代码》
- 线程安全和线程同步Synchronized
- c++ 在windwos上创建盘符,并且,监控盘符里面任一文件的变动事件
- RecyclerView has no adapter, skip layout
- android-----我眼中的Binder
- javascript针对DOM的应用(一)
- [尺取法] poj 3061 Subsequence
- HDU-5363 Key Set 【快速幂取模+递推】
- factory model
- cocos2dx.3.x之重要类分析(4)——Layer