synchronized关键字小结（一）
1. synchronized同步方法
1) synchronized修饰方法，表示方法是同步的，当某线程进入并拿到当前整个对象的锁时
a. 其他synchronized方法排队等锁
b. 非synchronized方法可异步执行
示例代码（折叠）
package com.khlin.thread;
public class SynchronizedTest {
public static void main(String[] args) {
Service service = new Service();
/**
* A B 两个方法是同步的，因此访问A时候，要等A方法执行完，A线程释放锁，B线程才能拿到锁从而访问B方法。
* 而C方法并不是同步的，可以异步执行
*/
ThreadA threadA = new ThreadA(service);
threadA.start();
ThreadB threadB = new ThreadB(service);
threadB.start();
ThreadC threadC = new ThreadC(service);
threadC.start();
}
}
class ThreadA extends Thread {
private Service service;
public ThreadA(Service service) {
this.service = service;
}
public void run() {
super.run();
service.printA();
}
}
class ThreadB extends Thread {
private Service service;
public ThreadB(Service service) {
this.service = service;
}
public void run() {
super.run();
service.printB();
}
}
class ThreadC extends Thread {
private Service service;
public ThreadC(Service service) {
this.service = service;
}
public void run() {
super.run();
service.printC();
}
}
class Service {
public synchronized void printA() {
System.out.println("enter printA. thread name: "
+ Thread.currentThread().getName());
try {
Thread.sleep(3000L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("leaving printA. thread name: "
+ Thread.currentThread().getName());
}
public synchronized void printB() {
System.out.println("enter printB. thread name: "
+ Thread.currentThread().getName());
System.out.println("leaving printB. thread name: "
+ Thread.currentThread().getName());
}
public void printC() {
System.out.println("enter printC. thread name: "
+ Thread.currentThread().getName());
System.out.println("leaving printC. thread name: "
+ Thread.currentThread().getName());
}
}
synchronized方法
运行结果：
2) 拥有锁重入的功能，当一个线程获得一个对象锁之后 ，再次请求此对象锁的时候是可以再次获得的。
示例代码，修改上面示例代码，在A方法后面调用B方法，可以再次获得锁，运行结果：
3) 重写方法后，synchronized关键字并不继承。但没有被重写的方法，仍然是同步的。
package com.khlin.thread;
public class SynchronizedTest {
public static void main(String[] args) {
/**
* 子类方法的实现若调用了父类的同步方法，一样有效
*/
SubService service = new SubService();
/**
* A B 两个方法是同步的，因此访问A时候，要等A方法执行完，A线程释放锁，B线程才能拿到锁从而访问B方法。
* 而C方法并不是同步的，可以异步执行
*/
ThreadA threadA = new ThreadA(service);
threadA.setName("threadA");
threadA.start();
ThreadB threadB = new ThreadB(service);
threadB.setName("threadB");
threadB.start();
ThreadC threadC = new ThreadC(service);
threadC.setName("threadC");
threadC.start();
}
}
class ThreadA extends Thread {
private Service service;
public ThreadA(Service service) {
this.service = service;
}
public void run() {
super.run();
service.printA();
// service.printB();
}
}
class ThreadB extends Thread {
private Service service;
public ThreadB(Service service) {
this.service = service;
}
public void run() {
super.run();
service.printB();
}
}
class ThreadC extends Thread {
private Service service;
public ThreadC(Service service) {
this.service = service;
}
public void run() {
super.run();
service.printC();
}
}
class Service {
public synchronized void printA() {
System.out.println("enter printA. thread name: "
+ Thread.currentThread().getName());
try {
Thread.sleep(3000L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("leaving printA. thread name: "
+ Thread.currentThread().getName());
// printB();
}
public synchronized void printB() {
System.out.println("enter printB. thread name: "
+ Thread.currentThread().getName());
System.out.println("leaving printB. thread name: "
+ Thread.currentThread().getName());
}
public void printC() {
System.out.println("enter printC. thread name: "
+ Thread.currentThread().getName());
System.out.println("leaving printC. thread name: "
+ Thread.currentThread().getName());
}
}
class SubService extends Service {
public void printSubA() {
System.out.println("enter printSubA. thread name: "
+ Thread.currentThread().getName());
printA();
System.out.println("leaving printSubA. thread name: "
+ Thread.currentThread().getName());
}
}
运行结果和1)是一样的。
2. synchronized同步代码块
同步代码块，通过synchronized(一个对象)的写法，把一个代码块变成同步的。
其中，括号里待同步的对象，也可以使用this关键字，指向当前对象，这时与synchronized方法效果是一样的。
1) 被同步的对象是this的情况
与synchronized方法效果一样，示例代码：
package com.khlin.thread;
public class SynchronizedTestSecond {
public static void main(String[] args) {
ServiceSecond service = new ServiceSecond();
ThreadAA threadAA = new ThreadAA(service);
threadAA.setName("ThreadAA");
threadAA.start();
try {
Thread.sleep(500L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ThreadBB threadBB = new ThreadBB(service);
threadBB.setName("ThreadBB");
threadBB.start();
}
}
class ServiceSecond {
public void methodA() {
String threadName = Thread.currentThread().getName();
synchronized (this) {
System.out.println("invoke methodA. " + threadName);
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("finish invoking methodA. " + threadName);
}
}
public synchronized void methodB() {
String threadName = Thread.currentThread().getName();
System.out.println("invoke methodB. " + threadName);
System.out.println("finish invoking methodA. " + threadName);
}
}
class ThreadAA extends Thread {
ServiceSecond service = new ServiceSecond();
public ThreadAA(ServiceSecond service) {
this.service = service;
}
public void run() {
service.methodA();
}
}
class ThreadBB extends Thread {
ServiceSecond service = new ServiceSecond();
public ThreadBB(ServiceSecond service) {
this.service = service;
}
public void run() {
service.methodB();
}
}
运行结果：
2) 被同步的对象非this的情况
假设synchronized(x)，此时，访问x对象里的同步方法，是同步访问的。
而访问主对象的同步方法，不受同步影响，属于异步。
让我们把上面的代码改为，synchronized(operation)，锁住另一个对象。
package com.khlin.thread;
public class SynchronizedTestSecond {
public static void main(String[] args) {
ServiceSecond service = new ServiceSecond();
/**
* 锁住了operation对象，该对象的同步方法必须等待锁
* 而methodB并不属于该对象，ServiceSecond对象的锁，其实线程AA并没有获取，所以线程BB可以异步访问methodB方法。
*/
ThreadAA threadAA = new ThreadAA(service);
threadAA.setName("ThreadAA");
threadAA.start();
try {
Thread.sleep(500L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ThreadBB threadBB = new ThreadBB(service);
threadBB.setName("ThreadBB");
threadBB.start();
}
}
class ServiceSecond {
private ServiceOperation operation = new ServiceOperation();
public void methodA() {
String threadName = Thread.currentThread().getName();
synchronized (operation) {
System.out.println("invoke methodA. " + threadName);
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("finish invoking methodA. " + threadName);
}
}
public synchronized void methodB() {
String threadName = Thread.currentThread().getName();
System.out.println("invoke methodB. " + threadName);
System.out.println("finish invoking methodB. " + threadName);
}
}
class ServiceOperation {
public synchronized void methodOperation() {
System.out.println("this is operation method.");
}
}
class ThreadAA extends Thread {
ServiceSecond service = new ServiceSecond();
public ThreadAA(ServiceSecond service) {
this.service = service;
}
public void run() {
service.methodA();
}
}
class ThreadBB extends Thread {
ServiceSecond service = new ServiceSecond();
public ThreadBB(ServiceSecond service) {
this.service = service;
}
public void run() {
service.methodB();
}
}
运行结果：
因为线程BB在访问methodB的时候，service对象的锁并没有被占用着，所以可以直接占用并调用方法。
3. 静态方法的synchronized方法和synchronized(class)方法
这是对类加锁，注意，在java中，类是一种特殊的对象。
原理与上述的非静态方法同步是一样的，不再赘述。
示例代码：
package com.khlin.thread;
public class SynchronizedStatic {
public static void main(String[] args) {
ThreadAAA threadAAA = new ThreadAAA();
threadAAA.setName("ThreadAAA");
threadAAA.start();
try {
Thread.sleep(500L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ThreadBBB threadBBB = new ThreadBBB();
threadBBB.setName("ThreadBBB");
threadBBB.start();
}
}
class StaticService {
public synchronized static void methodA()
{
String threadname = Thread.currentThread().getName();
System.out.println("invoking methodA. " + threadname);
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("finish methodA. " + threadname);
}
public synchronized static void methodB()
{
String threadname = Thread.currentThread().getName();
System.out.println("invoking methodB. " + threadname);
System.out.println("finish methodB. " + threadname);
}
}
class ThreadAAA extends Thread {
public void run() {
StaticService.methodA();
}
}
class ThreadBBB extends Thread {
public void run() {
StaticService.methodB();
}
}
运行结果：
synchronized关键字小结（一）的更多相关文章
- 深入理解java中的synchronized关键字
synchronized 关键字,代表这个方法加锁,相当于不管哪一个线程A每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程B(或者C D等),有的话要等正在使用这个方法的线程B(或者C D ...
- Java的synchronized关键字：同步机制总结
JAVA中synchronized关键字能够作为函数的修饰符,也可作为函数内的语句,也就是平时说的同步方法和同步语句块.搞清楚synchronized锁定的是哪个对象,就能帮助我们设计更安全的多线程程 ...
- synchronized关键字以及实例锁 类锁
Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码. 一.当两个并发线程访问同一个对象object中的这个synchronized(this ...
- synchronized关键字简介 多线程中篇（十一）
前面说过,Java对象都有与之关联的一个内部锁和监视器 内部锁是一种排它锁,能够保障原子性.可见性.有序性 从Java语言层面上说,内部锁使用synchronized关键字实现 synchronize ...
- java synchronized关键字浅析
synchronized这个关键字想必学Java的人都应该知道. 直接上例子: 方法级别实例 public class AtomicInteger { private int index; publi ...
- Java:synchronized关键字引出的多种锁
前言 Java 中的 synchronized关键字可以在多线程环境下用来作为线程安全的同步锁.本文不讨论 synchronized 的具体使用,而是研究下synchronized底层的锁机制,以及这 ...
- 线程中synchronized关键字和lock接口的异同
一.synchronized关键字 1.可以用来修饰代码块 synchronized (this) { // 同步的关键字 this 表示当前线程对象 if (num == 0) { break; } ...
- 从JAVA看C#中volatile和synchronized关键字的作用
最近一直在想C#中 volatile关键字到底是用来干什么的?查了很多.NET的文章都是说用volatile修饰的变量可以让多线程同时修改,这是什么鬼... 然后查到了下面这篇JAVA中关于volat ...
- Java多线程系列--“基础篇”04之 synchronized关键字
概要 本章,会对synchronized关键字进行介绍.涉及到的内容包括:1. synchronized原理2. synchronized基本规则3. synchronized方法 和 synchro ...
随机推荐
- WPF中不规则窗体与WindowsFormsHost控件的兼容问题完美解决方案
首先先得瑟一下,有关WPF中不规则窗体与WindowsFormsHost控件不兼容的问题,网上给出的解决方案不能满足所有的情况,是有特定条件的,比如 WPF中不规则窗体与WebBrowser控件的兼 ...
- struts1.3异常处理机制
当Struts的控制器捕获到异常时,在异常处理块中,创建描述异常信息的ActionMessage对象,并放入ActionMessages对象中.然后把ActionMessages对象存放到一定范围内( ...
- HDU 4746 Mophues 莫比乌斯反演
分析: http://blog.csdn.net/acdreamers/article/details/12871643 分析参见这一篇 http://wenku.baidu.com/view/fbe ...
- FIRST集和FOLLOW集
省略号代表其他相关产生式得出的终结符号,一开始的时候,省略号里面是没有的 求FIRST集 情况壹 如果A只在→的右边出现,那么FIRST(A)={A},例子M→α,FIRST(α)={α} 情况 ...
- （3）I2C总线的字节格式，时钟同步和仲裁
字节格式 发送到SDA线上的每个字节必须是8位.每次传输的字节数量是不受限制的.每个字节后必须跟着一个ACK应答位.数据从最高有效位(MSB)开始传输.如果从机要执行一些功能后才能接收或者发送新的完整 ...
- ssh，telnet远程AIX以及数据传输问题
(1)telnet远程 输入:telnet 目标IP 输入用户名,密码 进入远程机器 (2)AIX默认安装ftp,使用ftp传输数据 ftp 目标IP地址 输入用户名,密码(远程服务器的) 或者输入f ...
- 使用CPU探查器优化XAML程序
如果您正在开发一个使用 XAML (是否是 c + +. C# 或 VB) 的 Windows 商店应用程序,还有一个好的机会来提高应用程序的性能.为了帮助完成这一点,我们所有在售的能够应用开发 Wi ...
- test-from
title header1 hahhahjl header2 adfkljasd $$a^2$$ point 1 point 2 | table1 | table2 | | ---- | ---- | ...
- linux内核系列(二)内核数据结构之链表
双向链表 传统链表与linu内核链表的区别图: 图一 图二 从上图中看出在传统链表中各种不同链表间没有通用性,因为各个数据域不同,而在linux内核中巧妙将链表结构内嵌到数据域结构中使得不同结构之间能 ...
- Nyoj42 一笔画问题 （欧拉道路）
http://acm.nyist.net/JudgeOnline/problem.php?pid=42题目链接 #include <cstdio> #include <cstring ...