Java多线程(三):volatile
volatile
volatile是一种轻量同步机制。请看例子
MyThread25类
public class MyThread25 extends Thread{
private boolean isRunning = true;
public boolean isRunning()
{
return isRunning;
}
public void setRunning(boolean isRunning)
{
this.isRunning = isRunning;
}
public void run()
{
System.out.println("进入run了");
while (isRunning == true){}
System.out.println("线程被停止了");
}
public static void main(String[] args) throws InterruptedException {
MyThread25 mt = new MyThread25();
mt.start();
Thread.sleep(1000);
mt.setRunning(false);
System.out.println("已设置为false");
}
}
输出结果如下
进入run了
已设置为false
为什么程序始终不结束?说明mt.setRunning(false);没有起作用。
这里我们说下Java内存模型(JMM)
java虚拟机有自己的内存模型(Java Memory Model,JMM),JMM可以屏蔽掉各种硬件和操作系统的内存访问差异,以实现让java程序在各种平台下都能达到一致的内存访问效果。
JMM定义了线程和主内存之间的抽象关系:共享变量存储在主内存(Main Memory)中,每个线程都有一个私有的本地内存(Local Memory),本地内存保存了被该线程使用到的主内存的副本,线程对变量的所有操作都必须在本地内存中进行,而不能直接读写主内存中的变量。这三者之间的交互关系如下
出现上述运行结果的原因是,主内存isRunning = true, mt.setRunning(false)设置主内存isRunning = false,本地内存中isRunning仍然是true,线程用的是本地内存,所以进入了死循环。
在isRunning前加上volatile
private volatile boolean isRunning = true;
输出结果如下
进入run了
已设置为false
线程被停止了
volatile不能保证原子类线程安全
先看例子
MyThread26_0类,用volatile修饰num
public class MyThread26_0 extends Thread {
public static volatile int num = 0;
//使用CountDownLatch来等待计算线程执行完
static CountDownLatch countDownLatch = new CountDownLatch(30);
@Override
public void run() {
for(int j=0;j<1000;j++){
num++;//自加操作
}
countDownLatch.countDown();
}
public static void main(String[] args) throws InterruptedException {
MyThread26_0[] mt = new MyThread26_0[30];
//开启30个线程进行累加操作
for(int i=0;i<mt.length;i++){
mt[i] = new MyThread26_0();
}
for(int i=0;i<mt.length;i++){
mt[i].start();
}
//等待计算线程执行完
countDownLatch.await();
System.out.println(num);
}
}
输出结果如下
25886
理论上,应该输出30000。原子操作表示一段操作是不可分割的,因为num++不是原子操作,这样会出现线程对过期的num进行自增,此时其他线程已经对num进行了自增。
num++分三步:读取、加一、赋值。
结论:
volatile只会对单个的的变量读写具有原子性,像num++这种复合操作volatile是无法保证其原子性的
解决方法:
用原子类AtomicInteger的incrementAndGet方法自增
public class MyThread26_1 extends Thread {
//使用原子操作类
public static AtomicInteger num = new AtomicInteger(0);
//使用CountDownLatch来等待计算线程执行完
static CountDownLatch countDownLatch = new CountDownLatch(30);
@Override
public void run() {
for(int j=0;j<1000;j++){
num.incrementAndGet();//原子性的num++,通过循环CAS方式
}
countDownLatch.countDown();
}
public static void main(String []args) throws InterruptedException {
MyThread26_1[] mt = new MyThread26_1[30];
//开启30个线程进行累加操作
for(int i=0;i<mt.length;i++){
mt[i] = new MyThread26_1();
}
for(int i=0;i<mt.length;i++){
mt[i].start();
}
//等待计算线程执行完
countDownLatch.await();
System.out.println(num);
}
}
输出结果如下
30000
原子类方法组合使用线程不安全
例子如下
ThreadDomain27类
public class ThreadDomain27 {
public static AtomicInteger aiRef = new AtomicInteger();
public void addNum()
{
System.out.println(Thread.currentThread().getName() + "加了100之后的结果:" + aiRef.addAndGet(100));
aiRef.getAndAdd(1);
}
}
MyThread27类
public class MyThread27 extends Thread{
private ThreadDomain27 td;
public MyThread27(ThreadDomain27 td)
{
this.td = td;
}
public void run()
{
td.addNum();
}
public static void main(String[] args)
{
try
{
ThreadDomain27 td = new ThreadDomain27();
MyThread27[] mt = new MyThread27[5];
for (int i = 0; i < mt.length; i++)
{
mt[i] = new MyThread27(td);
}
for (int i = 0; i < mt.length; i++)
{
mt[i].start();
}
Thread.sleep(1000);
System.out.println(ThreadDomain27.aiRef.get());
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
输出结果如下
Thread-2加了100之后的结果:100
Thread-3加了100之后的结果:200
Thread-0加了100之后的结果:302
Thread-1加了100之后的结果:403
Thread-4加了100之后的结果:504
505
理想的输出结果是100,201,302...,因为addAndGet方法和getAndAdd方法构成的addNum不是原子操作。
解决该问题只需要在addNum加上synchronized关键字。
输出结果如下
Thread-1加了100之后的结果:100
Thread-0加了100之后的结果:201
Thread-2加了100之后的结果:302
Thread-3加了100之后的结果:403
Thread-4加了100之后的结果:504
505
结论:
volatile解决的是变量在多个线程之间的可见性,但是无法保证原子性。
synchronized不仅保障了原子性外,也保障了可见性。
volatile和synchronized比较
先看实例,使用volatile是什么效果
CountDownLatch保证10个线程都能执行完成,当然你也可以在System.out.println(test.inc);之前使用Thread.sleep(xxx)
public class MyThread28 {
//使用CountDownLatch来等待计算线程执行完
static CountDownLatch countDownLatch = new CountDownLatch(10);
public volatile int inc = 0;
public void increase() {
inc++;
}
public static synchronized void main(String[] args) throws InterruptedException {
final MyThread28 test = new MyThread28();
for(int i=0;i<10;i++){
new Thread(){
public void run() {
for(int j=0;j<1000;j++)
test.increase();
countDownLatch.countDown();
}
}.start();
}
countDownLatch.await();
System.out.println(test.inc);
}
}
运行结果如下
9677
每次运行结果都不一致。刚才我已经解释过,这里我再解释一遍。
使用volatile修饰int型变量i,多个线程同时进行i++操作。比如有两个线程A和B对volatile修饰的i进行i++操作,i的初始值是0,A线程执行i++时从本地内存刚读取了i的值0(i++不是原子操作),就切换到B线程了,B线程从本地内存中读取i的值也为0,然后就切换到A线程继续执行i++操作,完成后i就为1了,接着切换到B线程,因为之前已经读取过了,所以继续执行i++操作,最后的结果i就为1了。同理可以解释为什么每次运行结果都是小于10000的数字。
解决方法:
使用synchronized关键字
public class MyThread28 {
//使用CountDownLatch来等待计算线程执行完
static CountDownLatch countDownLatch = new CountDownLatch(10);
public int inc = 0;
public synchronized void increase() {
inc++;
}
public static synchronized void main(String[] args) throws InterruptedException {
final MyThread28 test = new MyThread28();
for(int i=0;i<10;i++){
new Thread(){
public void run() {
for(int j=0;j<1000;j++)
test.increase();
countDownLatch.countDown();
}
}.start();
}
countDownLatch.await();
System.out.println(test.inc);
}
}
输出结果如下
10000
synchronized不管是否是原子操作,它能保证同一时刻只有一个线程获取锁执行同步代码,会阻塞其他线程。
结论:
volatile只能用在变量,synchronized可以在变量、方法上使用。
volatile不会造成线程阻塞,synchronized会造成线程阻塞。
volatile效率比synchronized高。
Java多线程(三):volatile的更多相关文章
- java 多线程三
java 多线程一 java 多线程二 java 多线程三 java 多线程四 注意到 java 多线程一 中 MyThread2 运行结果出现0.-1,那是因为在操作共享数据时没有加锁导致. 加锁的 ...
- java多线程关键字volatile的使用
java多线程关键字volatile的作用是表示多个线程对这个变量共享. 如果是只读的就可以直接用,写数据的时候要注意同步问题. 例子: package com.ming.thread.volatil ...
- 从零开始学习Java多线程(三)
本文主要对Java多线程同步与通信以及相关锁的介绍. 1 .Java多线程安全问题 Java多线程安全问题是实现并发最大的问题,可以说多线程开发其实就是围绕多线程安全问题开发,涉及之深,不是简简单单一 ...
- java多线程三之线程协作与通信实例
多线程的难点主要就是多线程通信协作这一块了,前面笔记二中提到了常见的同步方法,这里主要是进行实例学习了,今天总结了一下3个实例: 1.银行存款与提款多线程实现,使用Lock锁和条件Condition. ...
- Java多线程——<三>简单的线程执行:Executor
一.概述 按照<Java多线程——<一><二>>中所讲,我们要使用线程,目前都是显示的声明Thread,并调用其start()方法.多线程并行,明显我们需要声明多个 ...
- java多线程(三)-Executors实现的几种线程池以及Callable
从java5开始,类库中引入了很多新的管理调度线程的API,最常用的就是Executor(执行器)框架.Executor帮助程序员管理Thread对象,简化了并发编程,它其实就是在 提供了一个中间层, ...
- Java多线程编程——volatile关键字
(本篇主要内容摘自<Java多线程编程核心技术>) volatile关键字的主要作用是保证线程之间变量的可见性. package com.func; public class RunThr ...
- JAVA多线程三种实现方式
JAVA多线程实现方式主要有三种:继承Thread类.实现Runnable接口.使用ExecutorService.Callable.Future实现有返回结果的多线程.其中前两种方式线程执行完后都没 ...
- Java 多线程 三种实现方式
Java多线程实现方式主要有三种:继承Thread类.实现Runnable接口.使用ExecutorService.Callable.Future实现有返回结果的多线程.其中前两种方式线程执行完后都没 ...
- java多线程三种方式
java多线程都有几种方式 有三种: (1)继承Thread类,重写run函数 创建: class xx extends Thread{ public void run(){ Thread.sleep ...
随机推荐
- WPF图形/文字特别效果之一:交叉效果探讨(续)
原文:WPF图形/文字特别效果之一:交叉效果探讨(续) 在"WPF图形/文字特别效果之一:交叉效果探讨"(http://blog.csdn.net/johnsuna/archive ...
- 怎样正确的理解和解决 ORA-01843:not a valid month
今天码代码的时候遇到了这个问题,由于oracle用的比較少,所在查询了一下. 顿时傻眼,有非常多的贴子说是由于nls_date_language的问题,还要改会话级的NLS_DATE_LANGUAGE ...
- [转]Nodejs开发框架Express4.x开发手记
Express: ?web application framework for?Node.js? Express 是一个简洁.灵活的 node.js Web 应用开发框架, 它提供一系列强大的特性,帮 ...
- ASP .NET Views文件夹下面的文件找不到
习惯将页面和它对应的js,css文件放在一个文件夹下,将这些都放在Views文件夹下 运行的时候发现找不到js和css文件 因为在MVC中,是不建议直接去访问Views文件夹的我们建立的ASP ...
- DataContext和ItemSource
一对多的关系DataContext为上下文,绑定数据源ItemSource取上下文中的某属性,会一级一级往上找属性 一般ItemSource的绑定,绑定到Grid/DataGrid一类容器上,底下的控 ...
- WPF ListBox的内容属性Items
<Window x:Class="XamlTest.Window3" xmlns="http://schemas.microsoft.com/winf ...
- js动态创建表格
<!DOCTYPE html><html><head><meta http-equiv="Content-Type" content=&q ...
- IOS开发之iOS深浅拷贝
这里主要侧重于集合类的深浅拷贝,主要事因为工作的时候遇到这个问题. 有不足的地方欢迎指正 首先我们需要有这样的一个前提: [array addObject:obj]; 这样obj的引用计数会增加1,如 ...
- 通通玩blend美工(1)——荧光Button
原文:通通玩blend美工(1)--荧光Button 最近老大出差去了,光做项目也有点烦,写点教程消遣消遣(注:此乃初级教程,所以第一个消遣是本人消遣,第二个是指供各位看官消遣...) 看着各位大虾出 ...
- MYSQL 定时自动执行EVENT
MySQL从5.1开始支持EVENT功能,类似Oracle和MSSQL的定时任务job功能.有了这个功能之后我们就可以让MySQL自动的执行存储过程来实现数据汇总等功能了,不用像以前哪样手动操作完成了 ...