前言
最近在看并发编程艺术这本书，对看书的一些笔记及个人工作中的总结。
在多线程并发编程中synchronized一直是元老级角色，很多人都会称呼它为重量级锁。但是在jdk1.6各种优化之后，有些情况它并不那么重了。
synchronized可以在任意对象及方法上加锁，而加锁的这段代码称为"互斥区"或"临界区"
对象锁
/**
* 对象锁
*/
public class SynchronizedTest1 extends Thread {
private int count = 5;
// synchronized加锁
public synchronized void run() {
count--;
System.out.println(this.currentThread().getName() + " count = " + count);
}
public static void main(String[] args) {
SynchronizedTest1 myThread = new SynchronizedTest1();
Thread t1 = new Thread(myThread, "t1");
Thread t2 = new Thread(myThread, "t2");
Thread t3 = new Thread(myThread, "t3");
Thread t4 = new Thread(myThread, "t4");
Thread t5 = new Thread(myThread, "t5");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
结果：
t1 count = 4
t5 count = 3
t4 count = 2
t3 count = 1
t2 count = 0
总结：
当多个线程访问SynchronizedTest1的run方法时，以排队的方式进行处理（这里排队是按照CPU分配的先后顺序而定的），一个线程想要执行synchronized修饰的方法里的代码：首先是尝试获得锁，如果拿到锁，执行synchronized代码体内容，拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁。（也就是会有锁竞争的问题）。
弊处：就是导致cpu的使用频率过高，更严重的情况导致宕机，我们应该在开发中避免多个线程抢一把锁的问题。
多个线程多个锁
public class SynchronizedTest2 {
private int num = 0;
public synchronized void printNum(String tag) {
try {
if (tag.equals("a")) {
num = 100;
System.out.println("tag a, set num over!");
Thread.sleep(2000);
} else {
num = 200;
System.out.println("tag b, set num over!");
}
System.out.println("tag " + tag + ", num = " + num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//注意观察run方法输出顺序
public static void main(String[] args) {
//俩个不同的对象,所以执行printNum方法的时候就是二把锁，一个对象一把锁，所以二者互相不影响
final SynchronizedTest2 test1 = new SynchronizedTest2();
final SynchronizedTest2 test2 = new SynchronizedTest2();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
test1.printNum("a");
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
test2.printNum("b");
}
});
t1.start();
t2.start();
}
}
结果：
tag a, set num over!
tag b, set num over!
tag b, num = 200
tag a, num = 100
总结：
俩个不同的对象,所以执行printNum方法的时候就是二把锁，一个对象一把锁，所以二者互相不影响。
类级锁
synchronized修饰静态方法
public class SynchronizedTest3 {
private static int num = 0;
//synchronized修饰静态关键字
public static synchronized void printNum(String tag) {
try {
if (tag.equals("a")) {
num = 100;
System.out.println("tag a, set num over!");
Thread.sleep(2500);
} else {
num = 200;
System.out.println("tag b, set num over!");
}
System.out.println("tag " + tag + ", num = " + num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 注意观察run方法输出顺序
public static void main(String[] args) {
final SynchronizedTest3 m1 = new SynchronizedTest3();
final SynchronizedTest3 m2 = new SynchronizedTest3();
Thread t1 = new Thread(() -> m1.printNum("a"));
Thread t2 = new Thread(() -> m2.printNum("b"));
t1.start();
t2.start();
}
}
tag a, set num over!
tag a, num = 100
tag b, set num over!
tag b, num = 200
结果：
synchronized修饰的静态方法的锁，表示锁定.class类，类一级别的锁（独占.class类）。
实际工作中为了降低锁的力度，synchronized修饰代码块，从而达到更好的性能。锁是synchronized括号里配置的对象。
同步代码块
//使用synchronized修饰代码块，
public class SynchronizedTest4 {
private Object obj = new Object();
public void test() throws Exception{
System.out.println(Thread.currentThread().getName()+":1111");
Thread.sleep(10000);
synchronized (obj){
System.out.println(Thread.currentThread().getName()+":22222");
}
System.out.println(Thread.currentThread().getName()+":33333");
}
public static void main(String[] args) {
final SynchronizedTest4 test4 = new SynchronizedTest4();
new Thread(() -> {
try {
test4.test();
} catch (Exception e) {
e.printStackTrace();
}
},"t1").start();
new Thread(() -> {
try {
test4.test();
} catch (Exception e) {
e.printStackTrace();
}
},"t2").start();
}
}
结果：
t1:1111
t2:1111
t1:22222
t2:22222
t2:33333
t1:33333
总结：
java中的每一个对象都可以作为锁：
- 对于普通同步方法，锁的是当前实列对象。
- 对于静态同步方法，锁的是当前类的Class对象。
- 对于同步方法块，锁是Synchonized括号里配置的对象。
当一个线程试图访问同步代码块时，它首先必须要得到锁，退出或抛出异常时必须释放锁。
从JVM规范中可以看到Synchonized在JVM里的实现原理，JVM基于进入和退出Monitor对象来实现方法同步和代码块同步，但两者的实现细节不一样。代码块同步是使用monitorenter（监视器锁）和monitorexit指令实现的，而方法同步是使用另外一种方式实现的，同步方法中依靠方法修饰符上的 ACC_SYNCHRONIZED 实现。细节在JVM规范里并没有详细说明。但是，方法的同步同样可以使用这两个指令来实现。
monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处，JVM要保证每个monitorenter必须有对应的monitorexit与之配对。任何对象都有一个monitor与之关联，当且一个monitor被持有后，它将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor的所有权，即尝试获得对象的锁。
