日常开发过程中:关键字 synchronized和volatile 经常使用,下面我们详细分析一下:
一、synchronized :
内置锁
线程开始运行,拥有自己的栈空间,就如同一个脚本一样,按照既定的代码 一步一步地执行,直到终止。但是,每个运行中的线程,如果仅仅是孤立地运行, 那么没有一点儿价值,或者说价值很少,如果多个线程能够相互配合完成工作, 包括数据之间的共享,协同处理事情。这将会带来巨大的价值。 Java 支持多个线程同时访问一个对象或者对象的成员变量,关键字 synchronized 可以修饰方法或者以同步块的形式来进行使用,它主要确保多个线 程在同一个时刻,只能有一个线程处于方法或者同步块中,它保证了线程对变量 访问的可见性和排他性,又称为内置锁机制。
1、对象锁和类锁:
对象锁是用于对象实例方法,或者一个对象实例上的,类锁是用于类的静态 方法或者一个类的 class
对象上的。我们知道,类的对象实例可以有很多个,但 是每个类只有一个 class
对象,所以不同对象实例的对象锁是互不干扰的,但是 每个类只有一个类锁。 但是有一点必须注意的是,其实类锁只是一个概念上的东西,并不是真实存 在的,类锁其实锁的是每个类的对应的 class
对象。类锁和对象锁之间也是互不 干扰的。对象锁和类锁,以及锁 static
变量之间的运行情况,请参考如下代码。 使用方式:
/**
*类说明:synchronized关键字的使用方法
*/
public class SynTest {
private long count =0;
private Object obj = new Object();//作为一个锁
public long getCount() {
return count;
}
public void setCount(long count) {
this.count = count;
}
/*用在同步块上*/
public void incCount(){
synchronized (obj){//对象锁
count++;
}
}
/*用在方法上*/
public synchronized void incCount2(){
count++;
}
/*用在同步块上,但是锁的是当前类的对象实例*/
public void incCount3(){
synchronized (this){//类锁
count++;
}
}
//线程
private static class Count extends Thread{
private SynTest simplOper;
public Count(SynTest simplOper) {
this.simplOper = simplOper;
}
@Override
public void run() {
for(int i=0;i<10000;i++){
// simplOper.incCount();//count = count+10000
// simplOper.incCount2();//count = count+10000
simplOper.incCount3();//count = count+10000
}
}
}
public static void main(String[] args) throws InterruptedException {
SynTest simplOper = new SynTest();
//启动两个线程
Count count1 = new Count(simplOper);
Count count2 = new Count(simplOper);
count1.start();
count2.start();
Thread.sleep(50);
System.out.println(simplOper.count);//20000
}
}
2、错误加锁方式:
private Integer i;
private Object o = new Object();
public Worker(Integer i) {
this.i=i;
}
@Override
public void run() {
synchronized (i) {//这种参数加锁方式是错误的,本质上是返回了一个新的 Integer 对象。也就是每个线程实际加锁的是不同的 Integer 对象;换成 o 对象就OK了
//业务代码
}
因此,加锁尽量是一个object类型的标准对象
二、volatile
,最轻量的同步机制
1、volatile
保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某 个变量的值,这新值对其他线程来说是立即可见的。参见代码:
/**
* 类说明:演示Volatile的提供的可见性
*/
public class VolatileCase {
// private volatile static boolean ready;
private static boolean ready;
private static int number;
//
private static class PrintThread extends Thread{
@Override
public void run() {
System.out.println("PrintThread is running.......");
while(!ready);//如果不加 volatile,会无限循环
System.out.println("number = "+number);
}
}
public static void main(String[] args) {
new PrintThread().start();
SleepTools.second(1);
number = 51;
ready = true;
SleepTools.second(5);
System.out.println("main is ended!");
}
}
不加 volatile 修饰ready :
加上
volatile 修饰:
![](https://i-blog.csdnimg.cn/blog_migrate/42285121f12596e9e5e1bb818f2267a8.png)
不加
volatile
时,子线程无法感知主线程修改了
ready
的值,从而不会退出循环, 而加了 volatile
后,子线程可以感知主线程修改了
ready
的值,迅速退出循环。 但是 volatile
不能保证数据在多个线程下同时写时的线程安全,参见代码:
public class NotSafe {
private long count =0; //不能保证可见性
// private volatile long count =0;//能保证可见性
public long getCount() {
return count;
}
public void setCount(long count) {
this.count = count;
}
//count进行累加
public void incCount(){
count++;
}
//线程
private static class Count extends Thread{
private NotSafe simplOper;
public Count(NotSafe simplOper) {
this.simplOper = simplOper;
}
@Override
public void run() {
for(int i=0;i<10000;i++){
simplOper.incCount();
}
}
}
public static void main(String[] args) throws InterruptedException {
NotSafe simplOper = new NotSafe();
//启动两个线程
Count count1 = new Count(simplOper);
Count count2 = new Count(simplOper);
count1.start();
count2.start();
Thread.sleep(50);
System.out.println(simplOper.count);//20000?
}
}
加上volatile 修饰也不能得到2000,说明不能保证原子性:
volatile
最适用的场景:一个线程写,多个线程读;不适合多写多读。这俩关键字使用分析到此结束,以后有机会我们分析一下源码,敬请期待!