对于Java中synchronized关键字的简单理解
对于Java中synchronized关键字的简单理解
- Synchronized关键字
-
- 对象锁
-
- 实现对象锁的几种方式
- 类锁
-
- 实现类锁的几种方式
- Object.wait()和Object.notify()
-
- Object.wait()
- Object.notify()
- 三线程打印ABC
Synchronized关键字
对象锁
作用于实例对应的内存位置。
一个实例一把锁，多个实例多把锁；
对象锁是针对一个实例（instance）的，它是在该实例对应的某个内存位置声明一个标识，记录该实例拥有锁，所以它只会锁住当前的实例，
而不会对当前对象的其它实例产生影响，当多个线程通过不同实例访问同一个对象锁的时候不会阻塞。
实现对象锁的几种方式
1、synchronized修饰成员方法
/**
* 对象锁-synchronized修饰成员方法
*/
public synchronized void m2 () {
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
2、synchronized修饰this关键字
/**
* 对象锁-synchronized修饰this关键字
*/
public void m3 () {
synchronized (this) {
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3、synchronized修饰成员变量
private Object mLock = new Object();
/**
* 对象锁-synchronized修饰成员变量
*/
public void m6 () {
synchronized (mLock) {
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
当多个线程访问同一个实例的对象锁时，会挨个执行。
访问不同实例的对象锁时则不会，因为不是同一把锁。
public static void main(String[] args) {
MyObject mo1 = new MyObject();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
mo1.m2();
}
}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
mo1.m2();
}
}, "t2");
t1.start();
t2.start();
}
输出"t1"之后过了3秒输出"t2"。
类锁
作用于类
多个对象实例共享同一把锁。
实现类锁的几种方式
1、synchronized修饰静态方法
/**
* 类锁-synchronized修饰静态方法
*/
public synchronized static void m4 () {
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
2、synchronized修饰this.getClass()
/**
* 类锁-synchronized修饰this.getClass()
*/
public void m5 () {
synchronized (this.getClass()) {
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
3、synchronized修饰静态变量
private static Object sLock = new Object();
/**
* 类锁-synchronized修饰静态变量
*/
public void m7 () {
synchronized (sLock) {
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
当多个线程访问同一个对象的不同实例的类锁时，会共享同一把锁，挨个执行。
public static void main(String[] args) {
MyObject mo1 = new MyObject();
MyObject mo2 = new MyObject();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
mo1.m5();
}
}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
mo2.m5();
}
}, "t2");
t1.start();
t2.start();
}
输出"t1"后过了3秒输出"t2"。
Object.wait()和Object.notify()
Object的wait和notify方法，必须在synchronized (Object)代码块内执行。
调用者为synchronized关键字修饰的对象。
Object.wait()
会使当前线程在该Object对象（监视器）上进入Waiting状态，并释放线程持有的作用于Object的锁（监视器锁）。
Object.notify()
调用Object.notify()方法之后，会使在该Object对象上处于Waiting状态的线程进入到Blocked（阻塞并正在等待获取监视器锁）的状态，
当监视器锁被释放之后，Blocked队列中获取到监视器锁的线程会从Waiting状态返回到Runnable状态。
注意：Object.notify()并不会立即释放监视器锁，而是在对应的synchronized代码块执行完毕之后。
三线程打印ABC
要求三个线程各打印10次"A", “B”, “C”，输出结果为有顺序的"ABCABCABCABCABCABCABCABCABCABC"。
/**
* @author yangwei
* @describition TODO
*
*/
public class MyThreadPrinter2 implements Runnable {
private String name;
private Object prev;
private Object self;
public MyThreadPrinter2(String name, Object prev, Object self) {
super();
this.name = name;
this.prev = prev;
this.self = self;
}
@Override
public void run() {
// TODO Auto-generated method stub
int count = 10;
while (count > 0) {
synchronized (prev) {
synchronized (self) {
System.out.print(name);
self.notify();
count--;
}
try {
prev.wait();
} catch (Exception e) {
// TODO: handle exception
}
}
}
}
public static void main(String[] args) throws InterruptedException {
Object a = new Object();
Object b = new Object();
Object c = new Object();
MyThreadPrinter2 A = new MyThreadPrinter2("A", c, a);
MyThreadPrinter2 B = new MyThreadPrinter2("B", a, b);
MyThreadPrinter2 C = new MyThreadPrinter2("C", b, c);
new Thread(A).start();
Thread.sleep(100); // 保证顺序为ABC
new Thread(B).start();
Thread.sleep(100);
new Thread(C).start();
Thread.sleep(100);
}
}
解析：
这里为了方便理解，我用大写的A、B、C标识线程，小写的a、b、c标识对象。
我们依次调用了线程A、B、C的start()方法，中间间隔100毫秒，执行过程是下面这样的。
1、首先是线程A打印"A"、唤醒在对象a上阻塞的线程、count–、使当前线程A在对象c上阻塞；
2、接下来线程B打印"B"、唤醒在对象b上阻塞的线程、count–、使当前线程B在对象a上阻塞；
3、接下来线程C打印"C"、唤醒在对象c上阻塞的线程、count–、是当前线程C在对象b上阻塞；
这个时候线程B和C都是阻塞状态了，线程A是就绪状态，线程A执行后阻塞A唤醒B、线程B执行后阻塞B唤醒C、线程C执行后阻塞C唤醒A，
就这样循环下去就输出了我们想要的结果。
以上见解如有不当之处，请予指正。
所参考内容：
Evankaka：Java多线程学习（吐血超详细总结）
DivineH：Java并发编程之Object.wait()/notify()详解