我们知道,在java中,每个对象都持有一把对象锁,这是在java语言层实现的机制(不同于java.util.concurrent包的lock),因此不需要显式去释放锁。
当我们谈到synchronized这个关键字,大伙第一时间想到的,可能就是:当资源共享时,访问(修改)该资源的所有方法都要加上锁(synchronized),才能保证数据不会出错(数据不一致);
Java提供了专门的机制去避免了同一个数据对象被多个线程同时访问,这套机制就是 synchronized 关键字,它包括两种用法:synchronized 方法和 synchronized 块。
1. synchronized 方法:通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如:
public synchronized void foo(int i);
2. synchronized 块:通过 synchronized关键字来声明synchronized 块。语法如下:
synchronized(syncObject) {
// 允许访问控制的代码
// 其中的代码块必须获得对象syncObject的锁才能执行
}
如果方法A和方法B都对同一个对象加了synchronized,并且在方法A中调用了方法B;假设有某个线程T调用方法A,线程T也不需要在A调用方法B时等待该 对象锁 释放从而在方法B中又持有该对象的锁,因为synchronized 不是方法级的,而是线程级的;因此,线程T在A方法的时候,就已经获得了那个对象的锁了。
而我们这里所要探讨的,就是synchronized块的参数;而synchronized 块里的代码必须要获得对象 syncObject (可以是类实例或类)的锁方能执行。
首先我们来模拟两个线程,逐个字母输出某个字符串:
package com.gdut.thread;
public class SynchronizedTest {
public static void main(String[] args) {
new SynchronizedTest().init();
}
public void init() {
final Outputer outputer = new Outputer();
// 第一个线程
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
try {
Thread.sleep(5);
} catch (Exception e) {
e.printStackTrace();
}
// 输出某个字符串
// 在这个匿名类里,我们需要把outputer变量定义为final
outputer.output("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
}
}
}).start();
// 第二个线程
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
try {
Thread.sleep(50);
} catch (Exception e) {
e.printStackTrace();
}
// 输出某个字符串
// 在这个匿名类里,我们需要把outputer变量定义为final
outputer.output("5555555555555555555");
}
}
}).start();
} // end of init
class Outputer {
public void output(String name) {
int length = name.length();
for(int i=0; i<length; i++) {
// 逐个字母输出
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}
上面这段程序是线程不安全的,我们来看看它的部分输出:
对此,我们有一种比较省事的做法,直接在Output类的output方法加上关键字synchronized,即:public synchronized void output(String name) { }
我们也还有另外一种方法,就是synchronized块,而这里便涉及到synchronized块里面的参数;
通俗一点的说法就是:
当A线程执行到synchronized块的时候,A会去检查参数对象的锁有没有给其他线程拿走,如果没拿走,则线程A拿走该对象的锁,并且在线程A执行unlock前不允许其他线程执行该对象锁的所有synchronied块。
但是下面这段代码同样是线程不安全的,原因就在synchronized块的参数name是一个局部变量,也就是说,当A,B两个线程执行到这的时候,都会去执行synchronized块里面的代码!
class Outputer {
public void output(String name) {
int length = name.length();
synchronized(name) {
for(int i=0; i<length; i++) {
// 逐个字母输出
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}
运行结果:
把参数对象改成" this " 或者是Outputer类的成员变量str,都可以解决这个问题:
class Outputer {
// String str = "";
public void output(String name) {
int length = name.length();
// synchronized(str) {
// 这里的"this"表示调用该方法的那个对象,即init方法的 final Outputer outputer = new Outputer();
// 如果A,B线程各自new Outputer()对象,这样又是不同步的了!
synchronized(this) {
for(int i=0; i<length; i++) {
// 逐个字母输出
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}
===============================
接下来,我们继续看一下下面的这个例子:
package com.gdut.thread;
public class SynchronizedTest {
public static void main(String[] args) {
new SynchronizedTest().init();
}
public void init() {
final Outputer outputer = new Outputer();
// 第一个线程
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
// 输出某个字符串
// 调用的是output_1
outputer.output_1("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
}
}
}).start();
// 第二个线程
new Thread(new Runnable() {
@Override
public void run() {
while(true) {
try {
Thread.sleep(10);
} catch (Exception e) {
e.printStackTrace();
}
// 输出某个字符串
// 调用的是output_2
outputer.output_2("5555555555555555555");
}
}
}).start();
} // end of init
static class Outputer {
public void output_1(String name) {
int length = name.length();
synchronized (this) {
for(int i=0; i<length; i++) {
// 逐个字母输出
System.out.print(name.charAt(i));
}
System.out.println();
}
}
public static synchronized void output_2(String name) {
int length = name.length();
for(int i=0; i<length; i++) {
// 逐个字母输出
System.out.print(name.charAt(i));
}
System.out.println();
}
}
}
output_1和output_2的区别是:前者是synchronized块,而后者是static方法!输出的结果同样是有问题的,如下:
也就是说,和static方法关联的对象,并不是this,而是某个Class类!(这里的的Class为:java.lang.Class)把output_1方法稍做修改,即可:
public void output_1(String name) {
int length = name.length();
// 参数对象为Outputer.class
synchronized (Outputer.class) {
for(int i=0; i<length; i++) {
// 逐个字母输出
System.out.print(name.charAt(i));
}
System.out.println();
}
}
这样同步的问题又解决了!!
在最后,建议大伙都学习一下java.util.concurrent包里面的相关知识!