java线程安全— synchronized和volatile

java线程安全— synchronized和volatile

package threadsafe;



public class TranditionalThreadSynchronized {
	public static void main(String[] args)
	{
		final Outputter output = new Outputter();
		
		new Thread()
		{
			public void run()
			{
				output.output("zhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsan");
			}
		}.start();
		
		new Thread()
		{
			public void run()
			{
				output.output("lisi");
			}
		}.start();
	}
}


class Outputter
{
	public void output(String name)
	{
		for(int i = 0; i < name.length(); i++)
		{
			System.out.print(name.charAt(i));
		}
	}
}
zhangsanzhangsanzlihangsanzhangsasinzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsanzhangsan

  之所以用这个多的“zhangsan”,只用一个“lisi”,是为了防止如果只使用一个“zhangsan”,可能cpu的计算能力很强,会在执行完第一个线程之后,程序还没有

来得及进行到第二个线程,此时可能会造成一种错觉:先执行第一个线程,再执行第二个线程,其实在这里不是这样子的,如果cpu的运算能力不强,可能会出现类似于“zhlainsigsan”的输出效果。

一、使用synchronized关键字

  我们希望output方法被一个线程完整的执行完之后再切换到下一个线程,Java中使用synchronized保证一段代码在多线程执行时是互斥的,有两种用法:

1.使用synchronized将需要互斥的代码包含起来,并上一把锁。

package threadsafe;



public class TranditionalThreadSynchronized {
	public static void main(String[] args)
	{
		final Outputter output = new Outputter();
		
		new Thread()
		{
			public void run()
			{
				output.output("zhangsan");
			}
		}.start();
		
		new Thread()
		{
			public void run()
			{
				output.output("lisi");
			}
		}.start();
	}
}


class Outputter
{
	public void output(String name)
	{
		synchronized(this)
		{
			for(int i = 0; i < name.length(); i++)
			{
				System.out.print(name.charAt(i));
			}
		}
	}
}

  在这里,使用synchronized将需要互斥的代码块包含起来了,加了一把锁。

{  
    synchronized (this) {  
        for(int i = 0; i < name.length(); i++) {  
            System.out.print(name.charAt(i));  
        }  
    }  
}  

2.将synchronized加在需要互斥的方法上。

class Outputter
{
	public synchronized void output(String name)
	{
			for(int i = 0; i < name.length(); i++)
			{
				System.out.print(name.charAt(i));
			}
	}
}

synchronized修饰的方法或者代码块可以看成是一个原子操作

        每个锁对象(JLS中叫monitor)都有两个队列,一个是就绪队列,一个是阻塞队列,就绪队列存储了将要获得锁的线程,阻塞队列存储了被阻塞的线程,当一个线程被唤醒(notify)后,才会进入到就绪队列,等待CPU的调度,反之,当一个线程被wait后,就会进入阻塞队列,等待下一次被唤醒,当第一个线程执行输出方法时,获得同步锁,执行输出方法,恰好此时第二个线程也要执行输出方法,但发现同步锁没有被释放,第二个线程就会进入就绪队列,等待锁被释放。

    1. 获得同步锁;

        2. 清空工作内存;

        3. 从主内存拷贝对象副本到工作内存;

        4. 执行代码(计算或者输出等);

        5. 刷新主内存数据;

        6. 释放同步锁。

synchronized既保证了多线程的并发有序性,又保证了多线程的内存可见性。

二、使用volatile关键字(在共享变量前加上)

一个变量可以被volatile修饰,在这种情况下内存模型(主内存和线程工作内存)确保所有线程可以看到一致的变量值。

class Test {  
    static int i = 0, j = 0;  
    static synchronized void one() {  
        i++;  
        j++;  
    }  
    static synchronized void two() {  
        System.out.println("i=" + i + " j=" + j);  
    }  
}  

  这时one方法和two方法再也不会并发的执行了,i和j的值在主内存中会一直保持一致,并且two方法输出的也是一致的。

  另外的同步机制就是在共享变量之前加上volatile

class Test {  
    static volatile int i = 0, j = 0;  
    static void one() {  
        i++;  
        j++;  
    }  
    static void two() {  
        System.out.println("i=" + i + " j=" + j);  
    }  
}  

  但是加上volatile可以将共享变量i和j的改变直接响应到主内存中,这样保证了主内存中i和j的值一致性,然而在执行two方法时,在two方法获取到i的值和获取到j的值中间的这段时间,one方法也许被执行了好多次,导致j的值会大于i的值。所以volatile可以保证内存可见性,不能保证并发有序性。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏ios 技术积累

ios内存管理-内存管理范围

1、栈区(stack) — 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。 2、堆区(heap) — 一般由程序员分配释放,若程序员不释放...

1242
来自专栏阿杜的世界

什么是classloader和双亲委派

772
来自专栏mwangblog

bash中的变量

1288
来自专栏积累沉淀

Python快速学习第十一天--Python多线程

Python中使用线程有三种方式: 方法一:函数式 调用thread模块中的start_new_thread()函数来产生新线程。语法如下: thread...

2279
来自专栏技巅

GlusterFS之内存池(mem-pool)使用实例分析

1806
来自专栏七夜安全博客

无线安全专题_破解篇03--打造个人字典

1184
来自专栏猿人谷

unix共享内存要点

共享内存优点:     1.在进程之间不通过内核传递数据,即不通过系统调用拷贝数据,达到快速,高效的数据传输。     2.随内核持续     *nix的共享内...

18210
来自专栏决胜机器学习

PHP实用功能——modern PHP读书笔记(一)

PHP实用功能——modern PHP读书笔记 (原创内容,转载请注明来源,谢谢) 一、命名空间 1、命名空间按照虚拟的层次结构组织PHP代码,类似操作系统的目...

4295
来自专栏武军超python专栏

2018-7-16python中四种组合数据类型和pycharm的安装和使用

集合(set) discard删除数据时如果集合里面没有那个数据什么也不做,集合相减可以直接用-,+*/都不能用

1625
来自专栏Python小屋

Python快速计算Fibonacci数列中第n项的方法

from time import time from functools import lru_cache def fibo1(n): '''递归法''' ...

3237

扫码关注云+社区

领取腾讯云代金券