一、目录
1、多线程启动方式
2、synchronized的基本用法
3、深度解析synchronized
4、同步方法与非同步方法是否能同时调用？
5、同步锁是否可重入（可重入锁）？
6、异常是否会导致锁释放？
7、锁定某对象，对象属性改变是否会影响锁？指定其他对象是否会影响锁？
8、synchronized编程建议
二、多线程启动方式
继承Thread重写run()或者实现Runnable接口。
//实现runnable接口
static class MyThread implements Runnable{
@Override
public void run() { }
} //继承Thread+重写run
static class MThread extends Thread{
@Override
public void run() {
super.run();
}
} //测试方式
public static void main(String[] args) {
new Thread(new MyThread(),"t").start();
new MThread().start();
}
二、synchronized的基本用法
1、实例变量对象作为锁对象
/**
* synchronized 锁对象
* @author qiuyongAaron
*/
public class T1 {
private int count=10;
//利用Object实例对象标记互斥锁，每个线程进行同步代码块的时候，需要先去堆内存object获取锁标记，只有没有被其它线程标记的时候才能获得锁标记。
Object object =new Object();
public void method(){
synchronized(object){
count++;
System.out.println(Thread.currentThread().getName()+":count="+count);
}
}
} /**
*锁定当前对象，原理跟上面一样，只是谈一下应用情况。
@author qiuyongAaron
/
public class T2 {
private int count=10;</span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> method(){
</span><span style="color: #0000ff;">synchronized</span>(<span style="color: #0000ff;">this</span><span style="color: #000000;">){
count</span>++<span style="color: #000000;">;
System.out.println(Thread.currentThread().getName()</span>+":count="+<span style="color: #000000;">count);
}
} </span><span style="color: #008000;">//</span><span style="color: #008000;">该种书写方式等价于上面的method</span>
<span style="color: #0000ff;">public</span> <span style="color: #0000ff;">synchronized</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> cloneMethod(){
count</span>++<span style="color: #000000;">;
System.out.println(Thread.currentThread().getName()</span>+":count="+<span style="color: #000000;">count);
}}
总结：synchronized不是锁定代码块，它是在访问某段代码块的时候，去寻找锁定对象上的标记（实质上就是一个变量增减，这就是这个标记）。以T2为例，T2对象为锁定对象，假设开启5个线程，线程A最先竞争到锁，那么线程A在T2对象上进行标记，相当于标记变量加1。就在这时，其他4个线程竞争到锁以后，发现T2对象标记变量不为0，那么他们就被阻塞，等待线程A释放锁的时候，标记变量会减1使它变为0，其他锁就能竞争到锁。虚拟机：发生就近原则-锁定原则：释放锁先于获得锁，简而言之，只有线程A释放锁（锁定对象标记变量为0），其他线程才能获得锁（锁定对象标记+1）。
2、静态变量对象作为锁对象
/**
* 锁定静态变量
* @author qiuyongAaron
*/
public class T3 {
public static int count=10;</span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">synchronized</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> method(){
count</span>++<span style="color: #000000;">;
System.out.println(Thread.currentThread().getName()</span>+":count="+<span style="color: #000000;">count);
} </span><span style="color: #008000;">//</span><span style="color: #008000;">等价于上述方法</span>
<span style="color: #0000ff;">public</span> <span style="color: #0000ff;">static</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> cloneMethod(){
</span><span style="color: #0000ff;">synchronized</span> (T3.<span style="color: #0000ff;">class</span>) {<span style="color: #008000;">//</span><span style="color: #008000;">这里写this可以吗？</span>
count++<span style="color: #000000;">;
System.out.println(Thread.currentThread().getName()</span>+":count="+<span style="color: #000000;">count);
}
}}
问题：为什么静态变量要写T3.class，不能写this?
回答：这需要了解反射与类加载过程才能透彻解析。类加载过程：类加载-->验证-->准备-->解析-->初始化-->使用卸载，在类加载阶段，将会把静态变量、常量全部加载在堆内存的方法区中，并且会生成Class对象，T3.class就相当于Class对象，然而this是T3对象，而什么时候能够产生T3对象？当应用程序调用new T3()的构造器时候，也就是在初始化阶段才会产生。所以静态变量作为锁定对象只能用T3.class，不能使用this对象。
总结：静态变量在类加载的时候就存入内存，而实例变量是要调用构造器的时候才能加载进内存。所以，T3.class是类加载产生，this是初始化产生，自然标记锁定对象的时候是用T3.class不用this。
三、深度解析synchronized
synchronized定义：互斥锁，保证原子性、可见性。也就是，当线程A获得锁，其他线程全部被阻塞。之前解析过不过多赘述。
多线程不加锁：
//多线程不加锁！
public class T4 {
public static void main(String[] args) {
MyThread t=new MyThread();
Thread t1=new Thread(t,"t1");
Thread t2=new Thread(t,"t2");
t1.start();
t2.start();
} static class MyThread implements Runnable{
private int value =0;
@Override
public void run() { for(int i=0;i<5;i++){
value++;
System.out.println(Thread.currentThread().getName()+":"+this.value);
}
}
}
} //运行结果：每次运行结果都不同
t1:2 t2:2 t1:3 t2:4 t1:5 t2:6 t1:7 t2:8 t1:9 t2:10
多线程加锁：
//多线程加锁！
public class T5 {
public static void main(String[] args) {
MyThread t=new MyThread();
Thread t1=new Thread(t,"t1");
Thread t2=new Thread(t,"t2");
t1.start();
t2.start();
}</span><span style="color: #0000ff;">static</span> <span style="color: #0000ff;">class</span> MyThread <span style="color: #0000ff;">implements</span><span style="color: #000000;"> Runnable{
</span><span style="color: #0000ff;">private</span> <span style="color: #0000ff;">int</span> value =0<span style="color: #000000;">;
@Override
</span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">synchronized</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> run() { </span><span style="color: #0000ff;">for</span>(<span style="color: #0000ff;">int</span> i=0;i<5;i++<span style="color: #000000;">){
value</span>++<span style="color: #000000;">;
System.out.println(Thread.currentThread().getName()</span>+":"+<span style="color: #0000ff;">this</span><span style="color: #000000;">.value);
}
}
}}
运行结果：
t1:1 t1:2 t1:3 t1:4 t1:5 t2:6 t2:7 t2:8 t2:9 t2:10
显然，加了同步互斥锁的例子程序符合我们业务需求，那么想一下这是为什么？
先谈Java内存模型：
分析：在虚拟机中，堆内存用于存储共享数据（实例对象），堆内存也就是这里说的主内存。
每个线程将会在堆内存中开辟一块空间叫做线程的工作内存，附带一块缓存区用于存储共享数据副本。那么，共享数据在堆内存当中，线程通信就是通过主内存为中介，线程在本地内存读并且操作完共享变量操作完毕以后，把值写入主内存。
分析程序1：
- t1从主存中读取共享变量value：0，并且执行完value++后value：1，写入主存。
- t2启动读取主存value：1到工作内存，执行并打印value为2,3。
- t2读取的是它工作内存的值，所以这时t1的本地内存并没有改变还是1，执行打印输入value：2。
- 同样逻辑执行...
- 来看t2：6、t2：8、t1：7、t1：9，为什么？
- 当t2在工作内存操作完共享变量，t2把共享变量为value：6写入主存。
- 就在这时，t1从主存读取共享变量value：6并且value++为7，还没来得及打印。
- t2从主存读取共享变量value：7，value++，打印value：8，并且写入主存。
- 这时，继续之前的操作value++，自然打印的值还是7，再读取主存值value：8
- 这时t1打印value：9，value：10。
分析程序2：
- 在虚拟机的先行发生原则中（happen-before）的锁定原则：对某一个对象加锁的时候，它接锁先于加锁，意思就是必须等线程A锁释放，才能被线程B访问。
- 回到这个小程序，t1启动、t2被阻塞不能访问共享变量。之前，我们谈过java内存模型，假设线t1启动读取共享数据，并且会把共享数据写入到工作内存的缓存中，t1在本地内存操作完，待它操作完不把数据写回主存，这样即便t2被堵塞也没用？所以，虚拟机规定，线程unlock的时候必须把数据刷新到主存，lock的时候必须从主存刷新数据到工作内存。
- 什么意思？最开始主存共享变量value：0，t1获得同步锁，t2被阻塞。t1操作value：1-5，假设t1在本地内存操作完就马上释放锁并不把value写入主存，这时t2获得同步锁，从主存读到的共享变量依然为0，这虚拟机岂能容忍？所以，虚拟机规定，t1必须unlock之前把数据从线程工作内存刷新到主存，t2必须lock以后把数据从主存刷新到线程工作内存。
四、同步方法与非同步方法是否能同时调用？
/**
* 线程是否可以同时调用同步方法与非同步方法？
* @author qiuyongAaron
*/
public class T6 { public synchronized void m1() {
System.out.println(Thread.currentThread().getName() + " m1 start...");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " m1 end");
} public void m2() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " m2 ");
} public static void main(String[] args) {
T6 t = new T6();
new Thread(()->t.m1(),"t1").start();
new Thread(()->t.m2(),"t2").start();
}
}
//运行结果：
t1:start!
t2:start!
t1:end!
总结：显然可以，首先synchronized同步互斥锁是锁定对象，t1锁定的T6对象。线程t1去访问代码块t.m1()的时候会去申请锁，去查看锁定标记是否为0，再决定是否阻塞。然而线程t2访问t.m2()都不用申请锁，所以你锁定标记为什么，与我有什么关系？所以，上述问题当然是成立！
五、同步互斥锁是否可重入（可重入锁）？
/**
* 当锁定同一个对象的时候，锁只是在对象添加标记，加锁一次标记+1，解锁一次标记-1,直到标记为0释放锁。
* 可重入锁
* @author qiuyongAaron
*/
public class T7 {
public synchronized void m1(){
try {
Thread.sleep(5000);
} catch (Exception e) {
e.printStackTrace();
}
m2();
} public synchronized void m2(){
try {
Thread.sleep(5000);
} catch (Exception e) {
e.printStackTrace();
}
}
}
总结：synchronized同步互斥锁，支持可重入。在开篇我们就谈了，申请锁意味着对锁定对象的标记变量值修改，如果是同一个锁定变量，那么没重入一次，锁标记变量+1。如果想锁释放，那么必须释放锁-1，直到标记变量为0，锁才能被释放被其他线程占用。
六、异常是否会导致锁释放？
/**
* 异常将导致锁释放！
* @author qiuyongAaron
*/
public class T9 {</span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">synchronized</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> m1(){
</span><span style="color: #0000ff;">int</span> i=0<span style="color: #000000;">;
System.out.println(Thread.currentThread().getName()</span>+":start!"<span style="color: #000000;">);
</span><span style="color: #0000ff;">while</span>(<span style="color: #0000ff;">true</span><span style="color: #000000;">){
</span><span style="color: #0000ff;">if</span>(i==10<span style="color: #000000;">){
System.out.println(</span>5/0<span style="color: #000000;">);
}
i</span>++<span style="color: #000000;">;
}
} </span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> m2(){
System.out.println(Thread.currentThread().getName()</span>+":start!"<span style="color: #000000;">);
</span><span style="color: #0000ff;">try</span><span style="color: #000000;"> {
Thread.sleep(</span>10000<span style="color: #000000;">);
} </span><span style="color: #0000ff;">catch</span><span style="color: #000000;"> (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()</span>+":end!"<span style="color: #000000;">);
} </span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">static</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> main(String[] args) {
T9 t</span>=<span style="color: #0000ff;">new</span><span style="color: #000000;"> T9();
</span><span style="color: #0000ff;">new</span> Thread(()->t.m1(),"t1"<span style="color: #000000;">).start();
</span><span style="color: #0000ff;">try</span><span style="color: #000000;"> {
TimeUnit.SECONDS.sleep(</span>2<span style="color: #000000;">);
} </span><span style="color: #0000ff;">catch</span><span style="color: #000000;"> (InterruptedException e) {
e.printStackTrace();
}
</span><span style="color: #0000ff;">new</span> Thread(()->t.m2(),"t2"<span style="color: #000000;">).start();
}}
运行结果：
t1:start!
Exception in thread "t1" java.lang.ArithmeticException: / by zero
at com.ccut.aaron.synchronize.T9.m1(T9.java:12)
at com.ccut.aaron.synchronize.T9.lambda$0(T9.java:30)
at java.lang.Thread.run(Thread.java:745)
t2:start!
t2:end!
总结：答案是产生异常将会释放锁，所以在编写代码时候需要处理异常。从例子程序可看出，如果不释放锁的话，t1一直占用锁，而t2不可能获得锁。从运行结果看出，t2获得锁资源，所以证明了原命题。
七、锁定某对象，对象属性改变是否会影响锁？指定其他对象是否会影响锁？
/**
* 锁定对象改变属性无影响，如果锁定对象指定新对象，锁定对象将会改变！
* @author xiaoyongAaron
*/
public class T10 {
Object o=new Object();</span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> m(){
</span><span style="color: #0000ff;">synchronized</span><span style="color: #000000;">(o){
</span><span style="color: #0000ff;">while</span>(<span style="color: #0000ff;">true</span><span style="color: #000000;">){
</span><span style="color: #0000ff;">try</span><span style="color: #000000;"> {
TimeUnit.SECONDS.sleep(</span>1<span style="color: #000000;">);
} </span><span style="color: #0000ff;">catch</span><span style="color: #000000;"> (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}
}
} </span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">static</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> main(String[] args) {
T10 t</span>=<span style="color: #0000ff;">new</span><span style="color: #000000;"> T10(); </span><span style="color: #0000ff;">new</span> Thread(()->t.m(),"t1"<span style="color: #000000;">).start(); </span><span style="color: #0000ff;">try</span><span style="color: #000000;"> {
TimeUnit.SECONDS.sleep(</span>1<span style="color: #000000;">);
} </span><span style="color: #0000ff;">catch</span><span style="color: #000000;"> (InterruptedException e) {
e.printStackTrace();
} t.o</span>=<span style="color: #0000ff;">new</span><span style="color: #000000;"> Object(); </span><span style="color: #0000ff;">new</span> Thread(()->t.m(),"t2"<span style="color: #000000;">).start();
}}
运行结果：
t1 t1 t2
总结：从运行结果看出原命题的答案是，修改锁定变量的属性不会改变锁，锁定变量指定新对象将会报错。看例子程序，假设锁没有转移到新的实例变量，那么t2将会一直被阻塞。
八、synchronized编程建议
1、尽量锁定有共享数据的代码块，这是并发编程的优化中的锁粗化。
2、不要用常量作为锁定对象，因为常量池的常量同时被两个地方引用将会产生很大的问题。
/**
*锁粗化
*@author qiuyongAaron
*/
public void T11{
int count=0;
public synchronized void m(){
for(int i=0;i<10;i++){}
System.out.println("hello world!");
synchronized(this){
count++;
}
}
} /**
*不要使用常量作为锁定对象！！
*他们是同一个锁定对象！！
@author qiuyongAaron
/
public void T11{
String s1 = "Hello";
String s2 = "Hello";</span><span style="color: #0000ff;">void</span><span style="color: #000000;"> m1() {
</span><span style="color: #0000ff;">synchronized</span><span style="color: #000000;">(s1) {}
} </span><span style="color: #0000ff;">void</span><span style="color: #000000;"> m2() {
</span><span style="color: #0000ff;">synchronized</span><span style="color: #000000;">(s2) {}
}}
九、版权声明
作者：邱勇Aaron
出处：http://www.cnblogs.com/qiuyong/
您的支持是对博主深入思考总结的最大鼓励。
本文版权归作者所有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，尊重作者的劳动成果。
参考：深入理解JVM、马士兵并发编程、并发编程实践