多线程（二）Synchronized
synchronized是Java中的关键字，是一种同步锁，按类型可以分为同步方法和同步代码块。
非同步实例方法&同步实例方法：
非同步实例方法:
public class TestSync { public static void main(String[] args) throws InterruptedException { Cls c = new Cls(); new Thread() { @Override public void run() { try { c.method(); } catch (InterruptedException e) { e.printStackTrace(); } } }.start(); new Thread() { @Override public void run() { try { c.method(); } catch (InterruptedException e) { e.printStackTrace(); } } }.start(); } } class Cls { public void method() throws InterruptedException { Thread.sleep(10); System.out.println(Thread.currentThread().getName() + " menthod begin.."); Thread.sleep(10); System.out.println(Thread.currentThread().getName() + " menthod end.."); } }
执行结果（场景：同步方法属于同一个实例对象）：
Thread-0 menthod begin.. Thread-1 menthod begin.. Thread-1 menthod end.. Thread-0 menthod end..
同步实例方法：
public class TestSync { public static void main(String[] args) throws InterruptedException { Cls c = new Cls(); new Thread() { @Override public void run() { try { c.method(); } catch (InterruptedException e) { e.printStackTrace(); } } }.start(); new Thread() { @Override public void run() { try { c.method(); } catch (InterruptedException e) { e.printStackTrace(); } } }.start(); } } class Cls { public synchronized void method() throws InterruptedException { Thread.sleep(10); System.out.println(Thread.currentThread().getName() + " menthod1 begin.."); Thread.sleep(10); System.out.println(Thread.currentThread().getName() + " menthod1 end.."); } }
执行结果：
Thread-0 menthod1 begin.. Thread-0 menthod1 end.. Thread-1 menthod1 begin.. Thread-1 menthod1 end..
同步实例方法&同步静态方法：
同步实例方法（场景：同步方法属于不同的实例对象）：
public class TestSync { public static void main(String[] args) throws InterruptedException { Cls c = new Cls(); new Thread() { @Override public void run() { try { c.method(); } catch (InterruptedException e) { e.printStackTrace(); } } }.start(); Cls c1 = new Cls(); new Thread() { @Override public void run() { try { c1.method(); } catch (InterruptedException e) { e.printStackTrace(); } } }.start(); } } class Cls { public static synchronized void staticMethod() throws InterruptedException { Thread.sleep(10); System.out.println(Thread.currentThread().getName() + " staticMenthod begin.."); Thread.sleep(10); System.out.println(Thread.currentThread().getName() + " staticMenthod end.."); } public synchronized void method() throws InterruptedException { Thread.sleep(10); System.out.println(Thread.currentThread().getName() + " menthod begin.."); Thread.sleep(10); System.out.println(Thread.currentThread().getName() + " menthod end.."); } }
Thread-1 menthod begin.. Thread-0 menthod begin.. Thread-0 menthod end.. Thread-1 menthod end..
同步静态方法：
public class TestSync { public static void main(String[] args) throws InterruptedException { new Thread() { @Override public void run() { try { Cls.staticMethod(); } catch (InterruptedException e) { e.printStackTrace(); } } }.start(); new Thread() { @Override public void run() { try { Cls.staticMethod(); } catch (InterruptedException e) { e.printStackTrace(); } } }.start(); } } class Cls { public static synchronized void staticMethod() throws InterruptedException { Thread.sleep(10); System.out.println(Thread.currentThread().getName() + " staticMenthod begin.."); Thread.sleep(10); System.out.println(Thread.currentThread().getName() + " staticMenthod end.."); } public synchronized void method() throws InterruptedException { Thread.sleep(10); System.out.println(Thread.currentThread().getName() + " menthod begin.."); Thread.sleep(10); System.out.println(Thread.currentThread().getName() + " menthod end.."); } }
执行结果：
Thread-0 staticMenthod begin.. Thread-0 staticMenthod end.. Thread-1 staticMenthod begin.. Thread-1 staticMenthod end..
结论：
- 被锁对象是类的实例对象时，synchronized只在同一实例中作用
- 被锁对象是类对象时，即使new多个实例对象，但他们仍然是属于同一个类，依然会被锁住，即线程之间保证同步关系。
锁机制
public class TestSync { public void lockClass() { synchronized(TestSync.class) { System.out.println("lockClass .."); } } public synchronized void lockObject() { System.out.println("lockObject .."); } }
使用【javap -v TestSync.class】来反编译以上代码，结果如下：
public void lockClass(); descriptor: ()V flags: ACC_PUBLIC Code: stack=2, locals=2, args_size=1 0: ldc #1 // class com/ryj/thread/TestSync 2: dup 3: astore_1 4: monitorenter 5: getstatic #15 // Field java/lang/System.out:Ljava/io/PrintStream; 8: ldc #21 // String lockClass .. 10: invokevirtual #23 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 13: aload_1 14: monitorexit 15: goto 21 18: aload_1 19: monitorexit 20: athrow 21: return public synchronized void lockObject(); descriptor: ()V flags: ACC_PUBLIC, ACC_SYNCHRONIZED Code: stack=2, locals=1, args_size=1 0: getstatic #15 // Field java/lang/System.out:Ljava/io/PrintStream; 3: ldc #35 // String lockObject .. 5: invokevirtual #23 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 8: return
对于同步方法，JVM采用ACC_SYNCHRONIZED标记符来实现同步。 对于同步代码块。JVM采用monitorenter、monitorexit两个指令来实现同步。
方法级的同步是隐式的。同步方法的常量池中会有一个ACC_SYNCHRONIZED标志。当某个线程要访问某个方法的时候，会检查是否有ACC_SYNCHRONIZED，如果有设置，则需要先获得监视器锁，然后开始执行方法，方法执行之后再释放监视器锁。这时如果其他线程来请求执行方法，会因为无法获得监视器锁而被阻断住。值得注意的是，如果在方法执行过程中，发生了异常，并且方法内部并没有处理该异常，那么在异常被抛到方法外面之前监视器锁会被自动释放。
执行monitorenter指令理解为加锁，执行monitorexit理解为释放锁。 每个对象维护着一个记录着被锁次数的计数器。未被锁定的对象的该计数器为0，当一个线程获得锁（执行monitorenter）后，该计数器自增变为 1 ，当同一个线程再次获得该对象的锁的时候，计数器再次自增。当同一个线程释放锁（执行monitorexit指令）的时候，计数器再自减。当计数器为0的时候。锁将被释放，其他线程便可以获得锁。
Java的线程是映射到操作系统原生线程之上的，如果要阻塞或唤醒一个线程就需要操作系统的帮忙，这就要从用户态转换到核心态，因此状态转换需要花费很多的处理器时间，对于代码简单的同步块（如被synchronized修饰的get 或set方法）状态转换消耗的时间有可能比用户代码执行的时间还要长，所以说synchronized是java语言中一个重量级的操纵。
