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 ...
随机推荐
- c语言实用功能库函数#include<stdlib.h>
实用函数<stdlib.h> 在头文件<stdlib.h>中说明了用于数值转换.内存分配以及具有其他相似任务的函数. 1 atof #include <stdlib.h& ...
- ACM ICPC Asia Regional 2011 Kuala Lumpur C题
看了逆波兰表达式之后,发现真是强悍的数据结构,栈的应用怎么感觉一辈子也学不完了呢 后缀表达式即逆波兰表达式,就是将所有的运算符按照一定的等级全部都安排到数字的后面去,实现正确的运算法则. OK,代码要 ...
- 转 脸书pop动画的五个步骤
http://blog.csdn.net/u013741809/article/details/38511741 5 Steps For Using Facebook Pop // 1. Pick ...
- .net文件压缩和解压及中文文件夹名称乱码问题
/**************************注释区域内为引用http://www.cnblogs.com/zhaozhan/archive/2012/05/28/2520701.html的博 ...
- [新]最近用unity5弄的一些渲染
Unity Separable Bokeh Depth-of-Field Hexagonal Blur Unity3d Realtime Dynamic Clouds Rendering hemisp ...
- 排列的学习（java）
1.无重复排列 2.有重复排列 3,下一个排列 package 生成排列; public class Main { static int count=0; //a中保存原来的排列,lev表示选定第几个 ...
- 动态加载JS脚本的4种方法
实现OPOA(One Page One Application)时,必须使用动态加载js. 也就是在用户选择某个菜单项后,再动态加载对应的全部js到客户端. 动态加载js的情况很多啊,比如解决ajax ...
- Ubuntu14.04安装Oracle12C
原文:http://www.techienote.com/2014/04/how-to-install-oracle-12c-enterprise-edition-database-ubuntu-13 ...
- iOS设计模式之生成器
iOS设计模式之生成器 1.生成器模式的定义 (1): 将一个复杂的对象的构件与它的表示分离,使得相同的构建过程能够创建不同的表示 (2): 生成器模式除了客户之外还包括一个Director(指导者) ...
- 路冉的JavaScript学习笔记-2015年2月5日
1.为Js原始值创建临时对象,并进行属性引用 var s="text"; s.len=4;//这里Js调用new String(s)的方法创建了一个临时对象,用来属性引用 cons ...