java多线程(二)——锁机制synchronized(同步方法)
synchronized
Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然可以访问该object中的非加锁代码块。
——以上来源百度百科
一、方法内的变量为线程安全
“非线程安全”的问题存在于“实例变量”中，如果是方法内部的私有变量，则不会存在“非线程安全”问题，所得结果就是“线程安全”的了。
MyService类
package com.mythread.www.day8.testSyn.ep1;
public class MyService {
public void add(String name) {
try {
int num = 0;
if (name.equals("a")) {
num = 100;
System.out.println("a is over");
Thread.sleep(1000);
} else {
num = 200;
System.out.println("b is over");
}
System.out.println(name + " num = " + num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程类A
package com.mythread.www.day8.testSyn.ep1;
public class ThreadA extends Thread {
private MyService service;
public ThreadA(MyService service) {
super();
this.service = service;
}
@Override
public void run() {
service.add("a");
}
}
线程类B
package com.mythread.www.day8.testSyn.ep1;
public class ThreadB extends Thread {
private MyService service;
public ThreadB(MyService service) {
super();
this.service = service;
}
@Override
public void run() {
service.add("b");
}
}
运行类
package com.mythread.www.day8.testSyn.ep1;
public class Run {
public static void main(String[] args) {
MyService service = new MyService();
ThreadA threadA = new ThreadA(service);
threadA.start();
ThreadB threadB = new ThreadB(service);
threadB.start();
}
}
结果
a is over
b is over
b num = 200
a num = 100
从运行结果来看，方法中的变量不存在非线程安全的问题，永远都是线程安全的，这事方法内部的变量是私有的特性造成的。
二、实例变量非线程安全
MyService类
package com.mythread.www.day8.testSyn.ep1;
public class MyService {
private int num = 0;
public void add(String name) {
try {
if (name.equals("a")) {
num = 100;
System.out.println("a is over");
Thread.sleep(1000);
} else {
num = 200;
System.out.println("b is over");
}
System.out.println(name + " num = " + num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程类和运行类同上，运行结果
a is over
b is over
b num = 200
a num = 200
产生这个结果的原因是两个线程同事访问同一个没有同步的方法，如果两个对象同时操作对象中的实例变量，可能会造成非线程安全的问题
最简单的解决方案是在方法的前面加个synchronized同步锁
MyService类
package com.mythread.www.day8.testSyn.ep1;
public class MyService {
private int num = 0;
synchronized public void add(String name) {
try {
if (name.equals("a")) {
num = 100;
System.out.println("a is over");
Thread.sleep(1000);
} else {
num = 200;
System.out.println("b is over");
}
System.out.println(name + " num = " + num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程类和运行类同上，运行结果
a is over
a num = 100
b is over
b num = 200
在两个线程访问同一个对象中的同步方法时一定是线程安全的，上面的代码由于时同步访问，所以先打印出a，然后在打印出b
改一下运行类，其他类同上
package com.mythread.www.day8.testSyn.ep1;
public class Run {
public static void main(String[] args) {
MyService serviceA = new MyService();
MyService serviceB = new MyService();
ThreadA threadA = new ThreadA(serviceA);
threadA.start();
ThreadB threadB = new ThreadB(serviceB);
threadB.start();
}
}
结果
a is over
b is over
b num = 200
a num = 100
这是两个线程分别访问同一个类的两个不同实例的相同名称的同步方法，效果却是以异步的形式来执行的。
因为创建了两个业务对象，在系统中产生了两个锁，所以运行结果是异步的。
关键字synchronized所取得的锁都是对象锁，而不是把一段代码或者方法当作锁。
My Service类
package com.mythread.www.day8.testSyn.ep1;
public class MyService {
synchronized public void methodA() {
try {
System.out.println("begin methodA threadName = " + Thread.currentThread().getName());
Thread.sleep(3000);
System.out.println("end methodA time = " + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void methodB() {
try {
System.out.println("begin methodB threadName = " + Thread.currentThread().getName());
Thread.sleep(3000);
System.out.println("end methodB time = " + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程类A
package com.mythread.www.day8.testSyn.ep1;
public class ThreadA extends Thread {
private MyService service;
public ThreadA(MyService service) {
super();
this.service = service;
}
@Override
public void run() {
service.methodA();
}
}
线程类B
package com.mythread.www.day8.testSyn.ep1;
public class ThreadB extends Thread {
private MyService service;
public ThreadB(MyService service) {
super();
this.service = service;
}
@Override
public void run() {
service.methodB();
}
}
运行类
package com.mythread.www.day8.testSyn.ep1;
public class Run {
public static void main(String[] args) {
MyService service = new MyService();
ThreadA threadA = new ThreadA(service);
threadA.start();
ThreadB threadB = new ThreadB(service);
threadB.start();
}
}
结果
begin methodA threadName = Thread-1
begin methodB threadName = Thread-2
end methodB time = 1458400534384
end methodA time = 1458400534384
在My Service的methodB前面也加上关键字synchronized
My Service类
package com.mythread.www.day8.testSyn.ep1;
public class MyService {
synchronized public void methodA() {
try {
System.out.println("begin methodA threadName = " + Thread.currentThread().getName());
Thread.sleep(3000);
System.out.println("end methodA time = " + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
synchronized public void methodB() {
try {
System.out.println("begin methodB threadName = " + Thread.currentThread().getName());
Thread.sleep(3000);
System.out.println("end methodB time = " + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
结果
begin methodA threadName = Thread-1
end methodA time = 1458400619034
begin methodB threadName = Thread-2
end methodB time = 1458400622035
对比上面两次代码的运行结果。
在第一次运行时，当A线程先持有My Service的同步锁时，B线程可以已异步的方式去调用My Service对象中的非synchronized方法。
在第二次运行时，当A线程先持有My Service的同步锁时，当B想调用My Service对象中的synchronized，则需要先等A释放对象锁。
所以，synchronized锁住的时对象，而不是其他的一些东西。
三、synchronized锁重入
当一个线程获得一个对象锁后，再次请求此对象锁时是可以再次获得此对象锁的
My Service类
package com.mythread.www.day8.testSyn.ep1;
public class MyService {
synchronized public void methodA() {
System.out.println("methodA");
methodB();
}
synchronized public void methodB() {
System.out.println("methodB");
methodC();
}
synchronized public void methodC() {
System.out.println("methodC");
}
}
线程类
package com.mythread.www.day8.testSyn.ep1;
public class MyThread extends Thread {
@Override
public void run() {
MyService myService = new MyService();
myService.methodA();
}
}
运行类
package com.mythread.www.day8.testSyn.ep1;
public class Run {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
}
}
结果
methodA
methodB
methodC
自己还可以重新获得自己的内部锁，如果不可以的话，上面的这个Demo则会造成死锁现象
Main类
package com.weishiyao.learn.day4.testThread;
public class Main {
public int i = 10;
synchronized public void operateIMainMethod() {
try {
i--;
System.out.println("main print i=" + i);
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Sub类
package com.weishiyao.learn.day4.testThread;
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 (Exception e) {
e.printStackTrace();
}
}
}
线程类
package com.weishiyao.learn.day4.testThread;
public class MyThread extends Thread{
@Override
public void run() {
Sub sub = new Sub();
sub.operateISubMethod();
}
}
运行类
package com.weishiyao.learn.day4.testThread;
public class Run {
public static void main(String[] args) {
MyThread t = new MyThread();
t.run();
}
}
结果
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
当存在父子类继承关系时，子类完全可以通过父类“可重入锁”调用父类的同步方法
java多线程(二)——锁机制synchronized(同步方法)的更多相关文章
- java多线程(三)——锁机制synchronized(同步语句块)
用关键字synchronized声明方法在某些情况下是有弊端的,比如A线程调用同步方法之行一个长时间的任务,那么B线程必须等待比较长的时间,在这样的情况下可以使用synchronized同步语句快来解 ...
- JAVA多线程与锁机制
JAVA多线程与锁机制 1 关于Synchronized和lock synchronized是Java的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码 ...
- Java多线程的同步机制(synchronized)
一段synchronized的代码被一个线程执行之前,他要先拿到执行这段代码的权限,在 java里边就是拿到某个同步对象的锁(一个对象只有一把锁): 如果这个时候同步对象的锁被其他线程拿走了,他(这个 ...
- 【转载】Java中的锁机制 synchronized & 偏向锁 & 轻量级锁 & 重量级锁 & 各自优缺点及场景 & AtomicReference
参考文章: http://blog.csdn.net/chen77716/article/details/6618779 目前在Java中存在两种锁机制:synchronized和Lock,Lock接 ...
- java的锁机制——synchronized
一段synchronized的代码被一个线程执行之前,他要先拿到执行这段代码的权限,在java里边就是拿到某个同步对象的锁(一个对象只有一把锁): 如果这个时候同步对象的锁被其他线程拿走了,他(这个线 ...
- Java 多线程：锁（二）
Java 多线程:锁(二) 作者:Grey 原文地址: 博客园:Java 多线程:锁(二) CSDN:Java 多线程:锁(二) AtomicLong VS LongAddr VS Synchroni ...
- 深入浅出Java并发包—锁机制(二)
接上文<深入浅出Java并发包—锁机制(一) > 2.Sync.FairSync.TryAcquire(公平锁) 我们直接来看代码 protected final boolean tr ...
- JAVA中关于锁机制
本文转自 http://blog.csdn.net/yangzhijun_cau/article/details/6432216 一段synchronized的代码被一个线程执行之前,他要先拿到执行这 ...
- 深入浅出Java并发包—锁机制(三)
接上文<深入浅出Java并发包—锁机制(二)> 由锁衍生的下一个对象是条件变量,这个对象的存在很大程度上是为了解决Object.wait/notify/notifyAll难以使用的问题. ...
随机推荐
- 学习之路三十六：SQL知识总结 - [游标||字符串分割]
好久没有写文章了,今天把前不久项目用到的SQL知识总结一下. 一丶字符串分割 SQL内置函数中是没有Split分割函数的,所以需要自己去实现,不多说,上代码: )) RETURNS @result T ...
- Swift 自动布局框架-SnapKit
官方网址:http://snapkit.io/ Github: https://github.com/SnapKit/SnapKit SnapKit is a DSL to make Auto Lay ...
- 关于mvc、webapi中get、post、put、delete的参数
webapi中post提交的数据必须是一个类,get提交的数量无所谓 多种参数get时,参数名不能相同: 在能通过c#的校验的前提下,参数名.参数数量不能全完相同 public string Get( ...
- 严重: Exception starting filter struts2解决方法！
转自:http://blog.knowsky.com/260578.htm 问题出现: 严重: Exception starting filter struts2java.lang.ClassNotF ...
- c++ 状态模式（state）
/************************************************************************/ /* 状态模式 */ /************* ...
- wireshark解密本地https流量笔记
此方式支持firefox,chrome 建立path变量 SSLKEYLOGFILE=c:\ssl.key 重启firefox chrome,访问https网站会自动生成ssl session key ...
- 十一、EnterpriseFrameWork框架的分层与系统业务的结合
上章详细讲了EnterpriseFrameWork框架中的每个分层,这都是从技术层面来说明,也就是我们知道怎么来建一个控制器或一个业务对象,但开发过程中应该建一个什么样的控制器或业务对象了?本章的主要 ...
- Docker练习例子:基于 VNCServer + noVNC 构建 Docker 桌面系统
0. 安装docker 这一步略,网上有好多教程,一般出现装不上的原因,也就是网速问题了,这个我也很难帮你. 1. 下载指定的镜像images docker pull dorowu/ubuntu-de ...
- 使用Python画ROC曲线以及AUC值
from:http://kubicode.me/2016/09/19/Machine%20Learning/AUC-Calculation-by-Python/ AUC介绍 AUC(Area Unde ...
- 字体文件放入CDN服务器中，跨域问题（IIS版）
Font from origin 'http:/XXXX' has been blocked from loading by Cross-Origin Resource Sharing policy: ...