你所知道的synchronized关键字

原理

在Java中，每一个对象有且仅有一个同步锁。这也意味着，同步锁是依赖于对象而存在的。 当我们调用某个对象的synchronized方法的时候，就获取到了该对象的同步锁。如：synchronized(e)就获取到了"e这个对象"的同步锁。 不同线程对同步锁的访问是互斥的，在某个时间点，对象的同步锁只能被一个线程获取到。通过同步锁，我们可以在多线程中实现对“对象/方法”的互斥访问。比如：有两个访问同一个同步锁的线程A和线程B，在某一时刻，线程A获取到这个同步锁并执行一些操作；而此时，线程B也企图获取同步锁，那么线程B就会获取失败，进入等待状态，直到线程A释放了同步锁资源之后线程B才能获取到同步锁进行运行。

规则

当一个线程访问某对象的synchronized方法或者synchronized代码块时，其他线程对该对象的synchronized方法或者synchronized代码块的访问将被阻塞当一个线程访问某对象的synchronized方法或者代码块时，其他线程依然可以访问该对象的非同步代码块当一个线程访问某对象的synchronized方法或者代码块时，其他线程对该对象的其他synchronized方法或者synchronized代码块访问将被阻塞

如：

//1、当一个线程访问某对象的synchronized方法或者synchronized代码块时，其他线程对该对象的synchronized方法或者synchronized代码块的访问将被阻塞 class MyRunnable implements Runnable{ @Override public void run(){ synchronized(this){ try{ for(int i=0;i<5;i++){ Thread.sleep(100);//睡眠100ms System.out.println(Thread.currentThread.getName()+"loop"+i); } }catch(InterruptedException ie){ } } } }; public class Demo_01{ public static void main(String[] args){ Runnable demo=new MyRunnable();//新建Runnable对象 Thread t1=new Thread(demo,"t1"); Thread t2=new Thread(Demo,"t2"); t1.start(); t2.start(); } }

执行结果：

t1 loop 0 t1 loop 1 t1 loop 2 t1 loop 3 t1 loop 4 t2 loop 0 t2 loop 1 t2 loop 2 t2 loop 3 t2 loop 4

结果说明： run方法中存在synchronized代码块，而且t1和t2都时基于demo的runnable对象创建的线程。线程t1和t2共享demo的同步锁，当一个线程运行时另一个线程处于阻塞状态，无法执行。

class MyThread extends Thread{ public MyThread(String name){ super(name); } @Override public void run(){ synchronized(this){ try{ for(int i=0;i<5;i++){ Thread.sleep(100);//休眠100ms System.out.println(Thread.currentThread.getName()+"loop"+i); } }catch(InterruptedException ie){ } } } }; public class Demo_02{ public static void main(String[] args){ Thread t1=new MyThread("t1"); Thread t2=new MyThread("t2"); t1.start(); t2.start(); } }

执行结果：

t1 loop 0 t2 loop 0 t1 loop 1 t2 loop 1 t1 loop 2 t2 loop 2 t1 loop 3 t2 loop 3 t1 loop 4 t2 loop 4

结果分析： synchronized(this)中的this代表的是MyThread对象，而t1和t2是两个不同的MyThread对象，因此t1和t2在执行synchronized(this)时，获取的是不同对象的同步锁。所以会交叉进行执行…

//2、当一个线程访问某对象的synchronized方法或者synchronized代码块时，其他线程仍然可以访问该对象的非同步代码块 class Count { // 含有synchronized同步块的方法 public void synMethod() { synchronized(this) { try { for (int i = 0; i < 5; i++) { Thread.sleep(100); // 休眠100ms System.out.println(Thread.currentThread().getName() + " synMethod loop " + i); } } catch (InterruptedException ie) { } } } // 非同步的方法 public void nonSynMethod() { try { for (int i = 0; i < 5; i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i); } } catch (InterruptedException ie) { } } } public class Demo2 { public static void main(String[] args) { final Count count = new Count(); // 新建t1, t1会调用“count对象”的synMethod()方法 Thread t1 = new Thread( new Runnable() { @Override public void run() { count.synMethod(); } }, "t1"); // 新建t2, t2会调用“count对象”的nonSynMethod()方法 Thread t2 = new Thread( new Runnable() { @Override public void run() { count.nonSynMethod(); } }, "t2"); t1.start(); // 启动t1 t2.start(); // 启动t2 } }

执行结果：

t1 synMethod loop 0 t2 nonSynMethod loop 0 t1 synMethod loop 1 t2 nonSynMethod loop 1 t1 synMethod loop 2 t2 nonSynMethod loop 2 t1 synMethod loop 3 t2 nonSynMethod loop 3 t1 synMethod loop 4 t2 nonSynMethod loop 4

结果分析： 因为t2线程中执行的是count对象的非同步方法，所以虽然t1也在占用count的同步锁，但是仍然可以执行，没有造成阻塞

//当一个线程访问某个对象的synchronized方法或者synchronized代码块时，其他线程对该对象的其他synchronized方法或者synchronized代码块的访问将被阻塞 class Count { // 含有synchronized同步块的方法 public void synMethod() { synchronized(this) { try { for (int i = 0; i < 5; i++) { Thread.sleep(100); // 休眠100ms System.out.println(Thread.currentThread().getName() + " synMethod loop " + i); } } catch (InterruptedException ie) { } } } // 也包含synchronized同步块的方法 public void nonSynMethod() { synchronized(this) { try { for (int i = 0; i < 5; i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i); } } catch (InterruptedException ie) { } } } } public class Demo3 { public static void main(String[] args) { final Count count = new Count(); // 新建t1, t1会调用“count对象”的synMethod()方法 Thread t1 = new Thread( new Runnable() { @Override public void run() { count.synMethod(); } }, "t1"); // 新建t2, t2会调用“count对象”的nonSynMethod()方法 Thread t2 = new Thread( new Runnable() { @Override public void run() { count.nonSynMethod(); } }, "t2"); t1.start(); // 启动t1 t2.start(); // 启动t2 } }

执行结果：

t1 synMethod loop 0 t1 synMethod loop 1 t1 synMethod loop 2 t1 synMethod loop 3 t1 synMethod loop 4 t2 nonSynMethod loop 0 t2 nonSynMethod loop 1 t2 nonSynMethod loop 2 t2 nonSynMethod loop 3 t2 nonSynMethod loop 4

因为t1线程和t2线程都需要使用count对象同步锁，所以在t1运行时t2会被阻塞，等t1执行结束释放count对象的同步锁之后，t2才能获取count对象同步锁执行。

synchronized方法和代码块有什么区别吗？

答案是肯定的，字面意思–>synchronized方法是用synchronized修饰方法，synchronized代码块使用synchronized修饰代码块。

synchronized方法 public synchronized void fool(){ System.out.println("syschronized method"); } synchronized代码块 public void fool2(){ synchronized (this){ System.out.println("syschronized method"); } }

synchronized代码块中的this是指当前对象。也可以将this替换成其他对象，例如将this替换成obj，则foo2()在执行synchronized(obj)时就获取的是obj的同步锁。

但是更加提倡使用syschronized代码块，因为代码块可以更精确的控制冲突限制访问区域，有着更高的执行效率

实例锁和全局锁又是什么？

学过Java编程的大家应该都知道实例的概念，更多的是加上对象二字–>实例对象，而实例锁就是加在实例对象上的锁；而全局锁则是针对的整个类，无论实例多少个对象，线程都共享该锁，当然如果实例对象的类是实例的，那么实例锁也就具有了全局锁的概念 全局锁通常对应的就是static synchronized 如：

pulbic class Something { public synchronized void isSyncA(){} public synchronized void isSyncB(){} public static synchronized void cSyncA(){} public static synchronized void cSyncB(){} }

一定一定要注意synchronized关键字的三大规则，在实例锁和全局锁中也是存在这个问题。