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 ...
随机推荐
- BZOJ_4326_[NOIP2015]_运输计划_(二分+LCA_树链剖分/Tarjan+差分)
描述 http://www.lydsy.com/JudgeOnline/problem.php?id=4326 给出一棵带有边权的树,以及一系列任务,任务是从树上的u点走到v点,代价为u到v路径上的权 ...
- 数据结构：二级指针与Stack的数组实现
[简介] Stack,栈结构,即传统的LIFO,后进先出,常用的实现方法有数组法和链表法两种.如果看过我上一篇文章<数据结构:二级指针与不含表头的单链表>,一定会看到其中的关键在于,利用v ...
- 在windows下创建基于github的hexo静态博客
最近边上的人都突然买起了域名搭起了个人网站,渣渣的我介于期末没事干也跟风搭了个静态博客.虽说博客基本不更新T T,嘛嘛回归正题. 首先准备工作: 1)安装nodejs 2)安装msysgit(虽然现在 ...
- leetcode之Palindrome Partitioning
方法一:DFS递归,判断每一个是否为回文数 1,首先要有一个判断字符串是否是回文的函数.容易实现,字符串从两边同时往中间走,看字符是否相同; 2,深度优先搜索思想对字符串进行遍历.得到结果.例如,s ...
- HDU FatMouse's Speed 基本DP
题意:要求找到的体重递增,速度递减的老鼠,并且输出最长的长度数,而且输出各自的序列数.Special Judge 思路:先按体重由小到大排序,再找最长速度递减序列. 转移方程:mou[i].w> ...
- SSDT – Error SQL70001 This statement is not recognized in this context-摘自网络
March 28, 2013 — arcanecode One of the most common errors I get asked about when using SQL Server Da ...
- proftpd的示例配置文件
# This is a basic ProFTPD configuration file (rename it to # 'proftpd.conf' for actual use. It estab ...
- A Tour of Go The new function
The expression new(T) allocates a zeroed T value and returns a pointer to it. var t *T = new(T) or t ...
- Golang项目目录结构组织
其实golang的工程管理还是挺简单的,完全使用目录结构还有package名来推导工程结构和构建顺序. 当然,首先要说的是环境变量$GOPATH,项目构建全靠它.这么说吧,想要构建一个项目,就要将这个 ...
- 8-18-Exercise
8-18-小练 A.HDU 1172 猜数字 采用枚举~[赤果果的暴力~] 代码: #include <iostream> #include <cstdio> #inclu ...