synchronized同步方法
“非线程安全”其实会在多个线程对同一个对象中的实例变量进行并发访问的时候产生,产生的后果是脏读,也就是取到的数据是被更改过的。而“线程安全”就是以获得的实例变量的值是经过同步处理的,不会出现脏读的现象。
1、方法内的变量是线程安全的
“非线程安全”问题存在于“实例变量中”,如果是方法内的私有变量,则不存在“非线程安全”问题,所得结果也就是“线程安全”了。
package selfThread; /**
* Created by liping.sang on 2017/1/17 0017.
*/
public class HasSelfPrivateNum {
public void addI(String username){
try{
int num=0;
if(username.equals("a")){
num=100;
System.out.println("a set over");
Thread.sleep(2000);
}else {
num=200;
System.out.println("b set over");
}
System.out.println(username + " num = "+num);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
package selfThread; /**
* Created by liping.sang on 2017/1/17 0017.
*/
public class ThreadA extends Thread {
private HasSelfPrivateNum numRef; public ThreadA( HasSelfPrivateNum numRef) {
super();
this.numRef = numRef;
}
public void run(){
super.run();
numRef.addI("a");
}
}
package selfThread; /**
* Created by Administrator on 2017/1/17 0017.
*/
public class ThreadB extends Thread{
private HasSelfPrivateNum numRef; public ThreadB(HasSelfPrivateNum numRef) {
super();
this.numRef = numRef;
}
public void run(){
super.run();
numRef.addI("b");
}
}
package selfThread; /**
* Created by liping.sang on 2017/1/17 0017.
*/
public class Run {
public static void main(String [] args){
HasSelfPrivateNum numRef = new HasSelfPrivateNum();
ThreadA athread = new ThreadA(numRef);
athread.start();
ThreadB bthread = new ThreadB(numRef);
bthread.start();
}
}
b set over
b num = 200
a set over
a num = 100
可见,方法中的变量不存在非线性安全的问题,永远都是非线程安全的,这是方法内部的变量是私有的特性造成的。
2、实例变量非线程安全
如果多个线程共同访问一个对象中的实例变量,则有可能出现“非线程安全”问题。
package service; public class HasSelfPrivateNum { private int num = 0; synchronized public void addI(String username) {
try {
if (username.equals("a")) {
num = 100;
System.out.println("a set over!");
Thread.sleep(2000);
} else {
num = 200;
System.out.println("b set over!");
}
System.out.println(username + " num=" + num);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} }
package extthread; import service.HasSelfPrivateNum; public class ThreadA extends Thread { private HasSelfPrivateNum numRef; public ThreadA(HasSelfPrivateNum numRef) {
super();
this.numRef = numRef;
} @Override
public void run() {
super.run();
numRef.addI("a");
} }
package extthread; import service.HasSelfPrivateNum; public class ThreadB extends Thread { private HasSelfPrivateNum numRef; public ThreadB(HasSelfPrivateNum numRef) {
super();
this.numRef = numRef;
} @Override
public void run() {
super.run();
numRef.addI("b");
} }
package test; import service.HasSelfPrivateNum;
import extthread.ThreadA;
import extthread.ThreadB; public class Run { public static void main(String[] args) { HasSelfPrivateNum numRef = new HasSelfPrivateNum(); ThreadA athread = new ThreadA(numRef);
athread.start(); ThreadB bthread = new ThreadB(numRef);
bthread.start(); } }
a set over !
b set over !
b num = 200
a num =200
此时是两个线程同时访问一个没有同步的方法,如果两个线程同时操作对象中的实例变量,则有可能出现“非线程安全”问题,
只要在public void addI(String username)方法前加关键字synchronized即可 。
在两个线程访问同一个对象中的同步方法时一定是线程安全的。
3、多个对象多个锁
package service; public class HasSelfPrivateNum { private int num = 0; synchronized public void addI(String username) {
try {
if (username.equals("a")) {
num = 100;
System.out.println("a set over!");
Thread.sleep(2000);
} else {
num = 200;
System.out.println("b set over!");
}
System.out.println(username + " num=" + num);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} }
package extthread; import service.HasSelfPrivateNum; public class ThreadA extends Thread { private HasSelfPrivateNum numRef; public ThreadA(HasSelfPrivateNum numRef) {
super();
this.numRef = numRef;
} @Override
public void run() {
super.run();
numRef.addI("a");
} }
package extthread; import service.HasSelfPrivateNum; public class ThreadB extends Thread { private HasSelfPrivateNum numRef; public ThreadB(HasSelfPrivateNum numRef) {
super();
this.numRef = numRef;
} @Override
public void run() {
super.run();
numRef.addI("b");
} }
package test; import service.HasSelfPrivateNum;
import extthread.ThreadA;
import extthread.ThreadB; public class Run { public static void main(String[] args) { HasSelfPrivateNum numRef1 = new HasSelfPrivateNum();
HasSelfPrivateNum numRef2 = new HasSelfPrivateNum(); ThreadA athread = new ThreadA(numRef1);
athread.start(); ThreadB bthread = new ThreadB(numRef2);
bthread.start(); } }
a set over !
b set over !
b num =200
a num =100
两个线程分别访问同一个类的两个不同实例的相同名称的同步方法 ,效果却是以异步的方式运行,上面,创建了两个业务对象,在系统中产生了两个锁,所以运行结果是异步的,结果是先打印b在打印a,
虽然在HasSelfPrivateNum中使用了synchronized关键字但却是异步的交叉的,这是因为关键字synchronized取得的锁都是对象锁,而不是把一段代码或方法(函数)当做锁,所以在示例中,哪个线程先止血带synchronized关键字的方法,哪个线程就持有该方法所属对象的锁Lock,那么其他线程只能呈等待状态,前提是多个线程访问的是同一个对象,但如果多个线程访问的是多个对象,则JVM会创建多个锁。上面示例中创建了两个类的对象,所以就会产生2个锁。
4、synchronized方法与锁对象
package extobject; public class MyObject { synchronized public void methodA() {
try {
System.out.println("begin methodA threadName="
+ Thread.currentThread().getName());
Thread.sleep(5000);
System.out.println("end");
} catch (InterruptedException e) {
e.printStackTrace();
}
} }
package extthread; import extobject.MyObject; public class ThreadA extends Thread { private MyObject object; public ThreadA(MyObject object) {
super();
this.object = object;
} @Override
public void run() {
super.run();
object.methodA();
} }
package extthread; import extobject.MyObject; public class ThreadB extends Thread { private MyObject object; public ThreadB(MyObject object) {
super();
this.object = object;
} @Override
public void run() {
super.run();
object.methodA();
}
}
package test.run; import extobject.MyObject;
import extthread.ThreadA;
import extthread.ThreadB; public class Run { public static void main(String[] args) {
MyObject object = new MyObject();
ThreadA a = new ThreadA(object);
a.setName("A");
ThreadB b = new ThreadB(object);
b.setName("B"); a.start();
b.start();
} }
此时结果为:
begin methodA threadName = A
begin methodB threadName = B
end
end
如果修改MyObject
package extobject; public class MyObject { synchronized public void methodA() {
try {
System.out.println("begin methodA threadName="
+ Thread.currentThread().getName());
Thread.sleep(5000);
System.out.println("end");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
synchronized public void methodB() {
try {
System.out.println("begin methodB threadName="
+ Thread.currentThread().getName()+"begin time=" +System.currentTimeMills());
Thread.sleep(5000);
System.out.println("end");
} catch (InterruptedException e) {
e.printStackTrace();
}
} }
在ThreadB中修改run方法中修改为Object.methodB();
1)A线程先持有object对象的Lock锁,B线程可以以异步的方式调用object对象中的非synchronized类型的方法
2)A线程先持有object对象的Lock锁,B线程如果在这时调用object对象中的synchronized类型的方法则需等待,也就是同步。
5、脏读
在上面的例子中为了避免数据出现交叉的情况,使用synchronized关键字来同步,虽然在赋值时进行了同步,但是在取值时可能出现一些想不到的意外,这种情况就是脏读,发送脏读的情况是在读取实例变量时,此值已经被其他线程更改过了。
package entity; public class PublicVar { public String username = "A";
public String password = "AA"; synchronized public void setValue(String username, String password) {
try {
this.username = username;
Thread.sleep(5000);
this.password = password; System.out.println("setValue method thread name="
+ Thread.currentThread().getName() + " username="
+ username + " password=" + password);
} catch (InterruptedException e) {
e.printStackTrace();
}
} synchronized public void getValue() {
System.out.println("getValue method thread name="
+ Thread.currentThread().getName() + " username=" + username
+ " password=" + password);
}
}
package extthread; import entity.PublicVar; public class ThreadA extends Thread { private PublicVar publicVar; public ThreadA(PublicVar publicVar) {
super();
this.publicVar = publicVar;
} @Override
public void run() {
super.run();
publicVar.setValue("B", "BB");
}
}
package test; import entity.PublicVar;
import extthread.ThreadA; public class Test { public static void main(String[] args) {
try {
PublicVar publicVarRef = new PublicVar();
ThreadA thread = new ThreadA(publicVarRef);
thread.start(); Thread.sleep(200);//打印结果受此值的影响 publicVarRef.getValue();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }
}
脏读结果:
getValue method thread name=main username=B password=AA
getValue method thread name=main username=B password=BB
出现脏读是因为public void getValue()方法不是同步的,所以可以在任意的时候进行调用,解决办法方然就是加上同步synchronized关键字。
通过上述我们可以知道脏读是通过synchronized关键字解决的,而且还要知道:当A线程进入anyObject对象加入synchronized关键字的X方法时,A线程就获得了X方法锁,更精确地讲,是获得了对象的锁,所以在其他线程必须等A线程执行网之后才能调用X方法,但B线程可以随意调用其他非synchronized同步方法。
当A线程调用anyObject对象加入synchronized关键字修饰的X方法时,A线程就获得了X方法所在的对象的锁,所以其他线程必须等A线程执行完毕后才可以调用X方法,而B线程如果调用声明了synchronized关键字的非X方法时,必须等A线程将X方法执行完。也就是释放对象锁后才可以调用,这时A线程已经执行了一个完整的 任务,也就是说username和password这两个实例变量已经同时被赋值,不存在脏读的基本环境。
脏读一定会出现操作实例变量的情况下,这就是不同线程“争抢”实例变量的结果。
6、synchronized锁重入
关键字synchronized拥有锁重入的功能,也就是在使用synchronized时,当一个线程得到一个对象锁后,再次请求此对象锁时是可以再次得到该对象的锁的,这也证明在一个synchronized方法/块的内部调用奔雷的其他synchronized方法/块时,是永远可以得到锁的。
package myservice; public class Service { synchronized public void service1() {
System.out.println("service1");
service2();
} synchronized public void service2() {
System.out.println("service2");
service3();
} synchronized public void service3() {
System.out.println("service3");
} }
package extthread; import myservice.Service; public class MyThread extends Thread {
@Override
public void run() {
Service service = new Service();
service.service1();
} }
package test; import extthread.MyThread; public class Run {
public static void main(String[] args) {
MyThread t = new MyThread();
t.start();
}
}
结果:
service1
service2
service3
可重入锁的概念是:自己可以再次获得自己的内部锁。比如有1条线程获得了某个对象的锁,此时这个对象锁还没有释放,当其再次想要获取这个对象锁的时候还是可以获取的,如果不可重入的话,会造成死锁。
可重入锁也支持在父子类继承的环境中。
package extthread; import myservice.Main;
import myservice.Sub; public class MyThread extends Thread {
@Override
public void run() {
Sub sub = new Sub();
sub.operateISubMethod();
} }
package myservice; public class Main { public int i = 10; synchronized public void operateIMainMethod() {
try {
i--;
System.out.println("main print i=" + i);
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} }
package myservice; public class Sub extends Main { synchronized public void operateISubMethod() {
try {
while (i > 0) {
i--;
System.out.println("sub print i=" + i);
Thread.sleep(100);
this.operateIMainMethod();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
} }
package test; import extthread.MyThread; public class Run {
public static void main(String[] args) {
MyThread t = new MyThread();
t.start();
}
}
结果:
sub print i=9
main print i=8
sub print i=7
main print i=6
sub print i=5
main print i=4
sub print i=3
main print i=2
sub print i=1
main print i=0
7、出现异常时,锁自动释放
synchronized同步方法的更多相关文章
- synchronized同步方法《二》
1.synchronized方法和锁对象 (1).验证线程锁的是对象 代码如下: 1.1创建一个MyObject类: package edu.ymm.about_thread4; public cla ...
- 四、java多线程核心技术——synchronized同步方法与synchronized同步快
一.synchronized同步方法 论:"线程安全"与"非线程安全"是多线程的经典问题.synchronized()方法就是解决非线程安全的. 1.方法内的变 ...
- java多线程(二)——锁机制synchronized(同步方法)
synchronized Java语言的关键字,可用来给对象和方法或者代码块加锁,当它锁定一个方法或者一个代码块的时候,同一时刻最多只有一个线程执行这段代码.当两个并发线程访问同一个对象object中 ...
- 深入理解使用synchronized同步方法和同步代码块的区别
一.代码块和方法之间的区别 首先需要知道代码块和方法有什么区别: 构造器和方法块,构造器可以重载也就是说明在创建对象时可以按照不同的构造器来创建,那么构造器是属于对象,而代码块呢他是给所有的对象初始化 ...
- synchronized同步方法《一》
1.方法内的变量为线程安全 "非线程安全"问题存在于"实例变量"中,如果是方法内部的私有变量,则不存在"非线程安全"问题,所得结果也就是&q ...
- 二十二 synchronized同步方法
一 Synchronized锁: 1 synchronized取得的锁都是对象锁,而不是把一段代码或方法加锁. synchronized是给该方法的实例对象加锁.如果多个线程访问的是同一个对象 的s ...
- synchronized同步方法和同步代码块的区别
同步方法默认使用this或者当前类做为锁. 同步代码块可以选择以什么来加锁,比同步方法更精确,我们可以选择只有会在同步发生同步问题的代码加锁,而并不是整个方法. 同步方法使用synchronized修 ...
- 58、synchronized同步方法
线程安全问题 先看下面代码出现的问题: 定义一个Task类,里面有一个成员变量和一个有boolean类型参数的方法,方法内部会根据传入参数修改成员变量的值. package com.sutaoyu.T ...
- java synchronized静态同步方法与非静态同步方法,同步语句块
摘自:http://topmanopensource.iteye.com/blog/1738178 进行多线程编程,同步控制是非常重要的,而同步控制就涉及到了锁. 对代码进行同步控制我们可以选择同步方 ...
随机推荐
- 关于listView的item失去焦点不能点击 Item中包含Button 导致抢占焦点
今天发现一个问题.listView的item点击以后进入到下一个页面,下个页面有个返回按钮,直接返回回去以后点击事件不能触发,滑动或者重新打开这个listView,就可以达到原来的效果.后来发现是因为 ...
- Spark MLlib回归算法------线性回归、逻辑回归、SVM和ALS
Spark MLlib回归算法------线性回归.逻辑回归.SVM和ALS 1.线性回归: (1)模型的建立: 回归正则化方法(Lasso,Ridge和ElasticNet)在高维和数据集变量之间多 ...
- WPF教程四:布局之DockPanel面板
DockPanel:停靠面板 DockPanel定义一个区域,在此区域中,您可以使子元素通过描点的形式排列,这些对象位于 Children 属性中.停靠面板类似于WinForm中控件的Dock属性.D ...
- Bars, rectangles with bases on x-axis
Usage geom_bar(mapping = NULL, data = NULL, stat = "bin", position = "stack", .. ...
- ggplot2——简介
ggplot2是R语言最为强大的作图软件包,强于其自成一派的数据可视化理念.当熟悉了ggplot2的基本套路后,数据可视化工作将变得非常轻松而有条理. 本文主要对ggplot2的可视化理念及开发套路做 ...
- 关于Cocos2d-x中物理世界的物体乱跳的问题的解决
这是电脑短时间内帧率低,无法满足游戏配置的帧率引起的. 解决方法: 第一种: 1.打开AppDelegate.cpp文件 2.把director->setAnimationInterval(1. ...
- Spring 4 官方文档学习(十一)Web MVC 框架
介绍Spring Web MVC 框架 Spring Web MVC的特性 其他MVC实现的可插拔性 DispatcherServlet 在WebApplicationContext中的特殊的bean ...
- Spring Tools Suite (STS) 简介
首先,sts是一个定制版的Eclipse,专为Spring开发定制的,方便创建调试运行维护Spring应用. 官方页面.下载地址(3.8.1 win x64). 其次,没什么好介绍的,用一下就明白了. ...
- (转)获取android源码时repo的错误
获取android源码时repo的错误 今天用repo获取android源码:../bin/repo init -u git://android.git.kernel.org/platform/man ...
- javascript -- 判断是否为某个数据类型
为何不用其他方法,因为下面的写法考虑了各种兼容性.判断是否为数组isArray = function (source) { return '[object Array]' == Object.p ...