未加星标

Java synchronized关键字用法

字体大小 | |
[系统(linux) 所属分类 系统(linux) | 发布者 店小二04 | 时间 20161001 | 作者 红领巾 ] 0人收藏点击收藏

本篇随笔主要介绍 java 中 synchronized 关键字常用法,主要有以下四个方面:

1、实例方法同步

2、静态方法同步

3、实例方法中同步块

4、静态方法中同步块

我觉得在学习synchronized关键字之前,我们首先需要知道以下一点:Java 中每个实例对象对应一把锁且每个实例对象只有一把锁,synchronized 关键字是通过对相应的实例对象加锁来实现同步功能的。

一、实例方法中使用 synchronized 加锁

实例方法中默认被加锁的对象是调用此方法的实例对象。

class ImmutableValue {
public synchronized void comeIn() throws InterruptedException{
System.out.println(Thread.currentThread().getName() + ": start");
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName() + ": finish");
}
public void synchronized comeInIn() throws InterruptedException {
System.out.println(Thread.currentThread().getName() + ": start");
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName() + ": finish");
}
}
public class TestImmutableValue {
public static void main(String[] args) {
ImmutableValue im = new ImmutableValue();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
im.comeIn();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
im.comeInIn();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}, "t2");
t1.start();
t2.start();
}
}

在上面的代码中创建了两个线程并分别命名为 t1, t2。调用了同一个对象 im 的两个同步方法 comeIn 和 comeInIn, 执行结果如下:

Java synchronized关键字用法

在 t1 线程开始执行后,即使 t1 线程睡眠了5s,线程 t2 中的 comeInIn 方法仍然没有得到执行。这是因为 t1 线程先执行的 comeIn 方法,持有了对象 im 的锁,且 comeIn 方法并没有执行完,对象 im 的锁没有被释放,所以 comeInIn 方法无法对对象 im 加锁,就无法继续执行,只能等到 t1 线程中的 comeIn 方法执行完毕,释放对象 im 的锁,comeInIn 方法才能继续执行。

但是如果 t1 线程调用的是对象 im 的 comeIn 方法,而 t2 线程调用的是我们声明的另外一个 ImmutableValue 对象 im2 对象的 comeInIn 方法,则这两个方法的执行是互不影响的。因为 t1 线程的 comeIn 方法要获得 im 对象的锁,而 t2 线程要获得的是 im2 对象的锁,两个锁并不是同一个锁(Java中每个实例对象都有且只有一个锁),所以这两个方法执行互不影响。

二、静态方法中使用 synchronized 加锁

静态方法中默认被加锁的对象是此静态方法所在类的 class 对象。

class staticMethodSynchronized {
public static synchronized void method1() throws InterruptedException {
System.out.println(Thread.currentThread().getName() + ": start");
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName() + ": finish");
}
public static synchronized void method2() throws InterruptedException {
System.out.println(Thread.currentThread().getName() + ": start");
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName() + ": finish");
}
}
public class TestStaticClassSynchronized {
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
staticMethodSynchronized.method1();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
staticMethodSynchronized.method2();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}, "t2");
t1.start();
t2.start();
}
}

在上述代码中创建了两个线程并命名为 t1,t2。 t1,t2 线程调用了 staticMethodSynchronized 类的两个静态同步方法 method1 和 method2。执行结果如下:

Java synchronized关键字用法

在 t1 线程开始执行后,即使 t1 线程睡眠了5s,线程 t2 中的 method2 方法仍然没有得到执行。这是因为 t1 线程先执行的 method1 方法,持有了staticMethodSynchronized 类对象的锁,且 method1 方法并没有执行完,staticMethodSynchronized 类对象的锁没有被释放,所以 comeInIn 方法无法对staticMethodSynchronized 类对象加锁,就无法继续执行,只能等到 t1 线程中的 method1 方法执行完毕,释放 staticMethodSynchronized 类对象的锁,method2 方法才能继续执行。

三、实例方法中使用 synchronized 关键字制造同步块

同步块中默认被加锁的对象是此同步块括号声明中包含的对象。

class ImmutableValue {
public synchronized void comeIn() throws InterruptedException{
System.out.println(Thread.currentThread().getName() + ": start");
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName() + ": finish");
}
public void comeInIn() throws InterruptedException {
System.out.println(Thread.currentThread().getName() + ": start");
synchronized(this) {

}
System.out.println(Thread.currentThread().getName() + ": finish");
}
}
public class TestImmutableValue {
public static void main(String[] args) {
ImmutableValue im = new ImmutableValue();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
im.comeIn();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
im.comeInIn();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}, "t2");
t1.start();
t2.start();
}
}

由以上代码可以看到: 在 comeInIn 方法中,运用 synchronized(this) 制造同步块,要执行同步块内的代码,就必须获得 this 对象的锁(调用 comeInIn 方法的对象)。

执行结果可能为:

Java synchronized关键字用法

由此执行结果可见:t1 线程先执行了 comeIn 方法,获得了对象 im 的锁,之后由于 t1 线程进入睡眠状态,t2 线程得到运行,开始执行 comeInIn 方法,当执行到同步代码块时发现对象 im 已被加锁,无法继续执行。t1 线程睡眠结束之后继续执行,结束后释放对象 im 的锁,t2 线程才能继续执行。

四、静态方法中使用 synchronized 关键字制造同步块

同步块中默认被加锁的对象是此同步块括号声明中包含的对象。

class staticMethodSynchronized {
private static final Object OBJ = new Object();
public static void method1() throws InterruptedException {
System.out.println(Thread.currentThread().getName() + ": start");
synchronized(OBJ) {
System.out.println(Thread.currentThread().getName() + ": 获得锁");
System.out.println(Thread.currentThread().getName() + ": 释放锁");
}
System.out.println(Thread.currentThread().getName() + ": finish");
}
public static void method2() throws InterruptedException {
System.out.println(Thread.currentThread().getName() + ": start");
synchronized(OBJ) {
System.out.println(Thread.currentThread().getName() + ": 获得锁");
System.out.println(Thread.currentThread().getName() + ": 释放锁");
}
System.out.println(Thread.currentThread().getName() + ": finish");
}
}
public class TestStaticClassSynchronized {
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
staticMethodSynchronized.method1();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
staticMethodSynchronized.method2();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}, "t2");
t1.start();
t2.start();
}
}

在上述代码中,两个静态方法中的同步块都要获得对象 OBJ 的锁才能继续向下执行,执行结果可能如下:

Java synchronized关键字用法

若 t1 线程先获得锁,则必须等到 t1 释放锁之后,t2 线程中同步代码块及其之后的代码才能继续执行,t2 线程先获得锁,t1 线程同理。

总之,我认为我们只需抓住一点:Java 中每个实例对象对应一把锁且每个实例对象只有一把锁,synchronized 关键字是通过对相应的实例对象加锁来实现同步功能的(静态方法为对相应的 class 对象加锁)。在执行 synchronized 方法或 synchronized 同步块之前,我们只需判断其需要获得的对象的锁是否可获得,就可判断此方法或同步块是否可得到执行。

本文地址:http://www.linuxidc.com/Linux/2016-10/135733.htm


Java synchronized关键字用法

本文系统(linux)相关术语:linux系统 鸟哥的linux私房菜 linux命令大全 linux操作系统

主题: JavaLinux
分页:12
转载请注明
本文标题:Java synchronized关键字用法
本站链接:http://www.codesec.net/view/483434.html
分享请点击:


1.凡CodeSecTeam转载的文章,均出自其它媒体或其他官网介绍,目的在于传递更多的信息,并不代表本站赞同其观点和其真实性负责;
2.转载的文章仅代表原创作者观点,与本站无关。其原创性以及文中陈述文字和内容未经本站证实,本站对该文以及其中全部或者部分内容、文字的真实性、完整性、及时性,不作出任何保证或承若;
3.如本站转载稿涉及版权等问题,请作者及时联系本站,我们会及时处理。
登录后可拥有收藏文章、关注作者等权限...
技术大类 技术大类 | 系统(linux) | 评论(0) | 阅读(30)