JavaSE 线程同步之synchronized

关于线程同步机制：

一、为什么会引入线程同步机制和synchronized 

引入线程可以最高效地利用CPU这个稀缺的资源，最大程度地利用CPU。当一个线程释放CPU的占有去执行I/O时，由另一个thread会占有CPU 。

另外，当定义完多个thread后，thread开始start()后，就再也不能控制线程的发展了。线程启动后就不受限制了，因此会出现一些问题。例如对银行的账户余额来说，两个线程如果同时进入到对账户余额扣除操作的程序块中，会导致问题。 因而不同线程Thread应该有种同步的机制。

二、synchronized的理解

首先，most importantly。

Java中每一个对象都有唯一的一个锁（对象锁），当一个thread访问synchronized方法时，就是对该对象上锁。此时其他的thread都不能再访问该对象上的所有synchronized方法了（因为这个对象的锁已经被之前的thread拿到了，不能重复对该对象上锁！）。直到之前的那个线程thread执行方法完毕（或抛出了异常），将该对象的锁释放掉了，其他thread才能接着对该对象上锁。 注意：以上强调的上锁都是针对对象obj  

三、static静态的synchronized的陷阱

如果某个synchronized方法是静态static的，那么当线程访问该方法时，它锁的不再是synchronized方法所在的对象！而是synchronized方法所在的类所对应的Class对象

因此无论一个类生成多少个实例对象，这些对象都会对应唯一的一个Class 对象。

四、synchronized block块

Object obj=new Object();synchronized (obj) {/*logic implement*/}

synchronized块较synchronized方法来说，较为细粒度。对关键部分进行synchronized即可。

ok，总结以上4点，后续再补充

————————————————————————————————————————————————————————————————————

下面以一个实例实现下synchronized的操作：

package com.syncronized.java;public class TestThread {public static void main(String[] args) {Exampl example = new Exampl();myThread th = new myThread(example);// myThread2 th2=new myThread2(new Example());myThread2 th2 = new myThread2(example); //它们操作的都是同一个实例对象th.start();th2.start();}}class Exampl {public synchronized void execute() {for (int i = 1; i < 20; i++) {try {Thread.sleep((int) (Math.random() * 1000));} catch (InterruptedException e) {e.printStackTrace();}System.out.println("welcome: " + i);}}public synchronized void execute2() {for (int i = 1; i < 20; i++) {try {Thread.sleep((int) (Math.random() * 1000));} catch (InterruptedException e) {e.printStackTrace();}System.out.println("hello: " + i);}}}class myThread extends Thread {private Exampl example = null;public myThread(Exampl exam) {example = exam;}@Overridepublic void run() {example.execute();}}class myThread2 extends Thread {private Exampl example = null;public myThread2(Exampl exam) {example = exam;}@Overridepublic void run() {example.execute2();}}

核心部分注解： 定义了2个线程th和th2 ，它们操作的都是同一个实例对象（example）。 因而当一个线程th执行synchronized定义的execute()方法，获得了该实例对象example的锁后，th2不能在进入到synchronized定义execute2()方法体中了。th2会进入到lock pool锁池中等待，直到th执行完19次循环后释放了example这个实例对象的锁后，th2会acquire lock，接着执行execute2方法,把19次循环执行完。

输出为：

思考1： 在原版的基础上修改，若去掉

public synchronized void execute() {

中的synchronized声明后，再执行，会发生什么呢？

答： 会乱序 ，因为th2获得对象的锁，但th的execute方法不需要获得锁就可以执行，所以th的循环和th2的循环会交叉执行：

输出为：

思考2： 在原版的基础上修改，若把

myThread2 th2 = new myThread2(example); 

换成：

myThread2 th2=new myThread2(new Example());

再执行。会发生什么？

答：会乱序。 因为th和th2 操作的是不同的实例对象！ 是对2个不同的实例对象上锁。

输出：

思考3，在原版的基础上修改，若把两个方法execute和execute2都声明为static 静态，

public synchronized static void execute()public synchronized static void execute2()

再执行，会发生什么？

答： 不会乱序。 因为th访问execute方法，是对该方法所在类的Class对象 上锁，也就是Exampl类的Class对象上锁（注意，每一个类都有唯一的一个Class对象，如Object.class，详细见我的CSDN反射部分的总结）， 而th2访问synchronized修饰的execute2()方法时，发现Exampl类的Class对象的锁已经被拿走了，因而th2只能进入 Lock Pool中等待了，直到th释放Exampl类的Class对象的锁。

输出：

——————————————————————————————————————————————————————————————————

okay 以上大致罗列了运用到synchronized声明的几种情况，就这样。