Java多线程4-synchronized关键字
1、synchronized原理
在Java中,每一个对象有且仅有一个同步锁。这也意味着同步锁依赖于对象而存在
当我们调用某对象的synchronized方法时,就获得了该对象的同步锁。例如,synchronized(obj)就获取了"obj这个对象"的同步锁
不同线程对同步锁的访问是互斥的,也即,在某时间点,对象的同步锁只能被一个线程获取到。通过同步锁,我们就能在多线程中,实现对“对象或方法”的互斥访问。例如现在有两个线程A和线程B,它们都会访问“对象obj”的同步锁。假设,在某一时刻,线程A获取到“obj”的同步锁并在执行一些操作;而此时线程B也希望获取“obj”的同步锁,则线程B会获取失败,它必须等待,直到线程A释放了“obj”的同步锁之后线程B才能获取到“obj”的同步锁,从而可以运行
2、synchronized基本规则
第一条:当一个线程访问“某对象”的synchronized方法或者synchronized代码块时,其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞
第二条:当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时,其他线程仍然可以访问“该对象”的非同步代码块
第三条:当一个线程访问“某对象”的“synchronized方法”或则“synchronized代码块”时,其他线程对“该对象”的其他“synchronized方法”或者“synchronized代码块”的访问将被阻塞
第一条
当一个线程访问“某对象”的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); System.out.println(Thread.currentThread().getName()+" loop "+i); } } catch(InterruptedException ie) {} } } } public class problem1 { public static void main(String[] args) { Runnable demo = new MyRunnable(); 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(this)”代码块,而且t1和t2都是基于demo这个Runnable对象创建的线程。这意味着,我们可以将synchronized(this)中的this看作是demo这个Runnable对象;因此,线程t1和t2共享demo对象的同步锁。所以当一个线程运行的时候,另外一个线程必须等待“运行线程”释放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); System.out.println(Thread.currentThread().getName()+" loop "+i); } } catch(InterruptedException ie) {} } } } public class problem1 { 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 t2 loop 2 t1 loop 2 t1 loop 3 t2 loop 3 t1 loop 4 t2 loop 4
结果说明:
synchronized(this)中的this是指“当前的类的对象”,即synchronized(this)所在的类对应的当前对象,它的作用是获取“当前对象的同步锁”。对于以上的程序,synchronized(this)中的this是指MyThread对象,而t1和t2是两个不同的MyThread对象,因此t1和t2在执行synchronized(this)时,获取的是不同对象的同步锁。而之前的代码中,synchronized(this)中的this代表的是MyRunnable对象,t1和t2共享一个MyRunnable对象,因此,一个线程获取了对象的同步锁,会造成另外一个线程等待
第二条
当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时,其他线程仍然可以访问“该对象”的非同步代码块
演示程序:
class Count { public void synMethod() { synchronized(this) { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); 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 problem1 { public static void main(String[] args) { Count count = new Count(); Thread t1 = new Thread( new Runnable() { @Override public void run() { count.synMethod(); } },"t1"); Thread t2 = new Thread( new Runnable() { @Override public void run() { count.nonSynMethod(); } },"t2"); t1.start(); t2.start(); } }
运行结果:
t2 nonSynMethod loop 0 t1 synMethod loop 0 t2 nonSynMethod loop 1 t1 synMethod 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
结果说明:
主线程中新建了两个子线程t1和t2。t1会调用count对象的synMethod()方法,该方法内含有同步块;而t2会调用count对象的nonSynMethod()方法,该方法不是同步方法。t1运行时,虽然调用synchronized(this)获取“count”的同步锁;但是并没有造成t2的阻塞,因为t2没有用到count的同步锁
第三条
当一个线程访问“某对象”的“synchronized方法”或则“synchronized代码块”时,其他线程对“该对象”的其他“synchronized方法”或者“synchronized代码块”的访问将被阻塞
演示程序:
class Count { public void synMethod() { synchronized(this) { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()+" synMethod loop "+i); } } catch(InterruptedException ie) {} } } 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 problem1 { public static void main(String[] args) { Count count = new Count(); Thread t1 = new Thread( new Runnable() { @Override public void run() { count.synMethod(); } },"t1"); Thread t2 = new Thread( new Runnable() { @Override public void run() { count.nonSynMethod(); } },"t2"); t1.start(); t2.start(); } }
运行结果:
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。它们运行时都调用synchronized(this),这个this是count对象,而t1和t2共用count。因此,在t1运行的时候,t2会被阻塞,等待t1运行释放count对象的同步锁,t2才能运行
3、synchronized方法和synchronized代码块
“synchronized方法”是用synchronized修饰方法,而“synchronized代码块”则是用synchronized修饰代码块
synchronized方法示例:
public synchronized void foo1() { System.out.println("synchronized method"); }
synchronized代码块示例:
public void foo2() { synchronized(this) { System.out.println("Synchronnized method"); } }
synchronized代码块可以更精确地控制冲突限制访问区域,有时候表现更高效率。下面是演示程序:
public class Problem1 { public synchronized void synMethod() { for(int i = 0;i < 1000000;i++) ; } public void synBlock() { synchronized(this) { for(int i = 0;i <1000;i++) ; } } public static void main(String[] args) { Problem1 demo = new Problem1(); long start; long diff; start = System.currentTimeMillis(); demo.synMethod(); diff = System.currentTimeMillis() - start; System.out.println("synMethod(): "+diff); start = System.currentTimeMillis(); demo.synBlock(); diff = System.currentTimeMillis() - start; System.out.println("synBlock(): "+ diff); } }
运行结果:
synMethod(): 2
synBlock(): 0
4、实例锁 和 全局锁
实例锁--锁在某一个实例对象上。如果该类是单例,那么该锁也具有全局锁的概念。实例锁对应的就是synchronized关键字。
全局锁--该锁针对的是类,无论实例多少个对象,那么线程都共享该锁。全局锁对应的是static synchronized(或者是锁在该类的class或者class loader对象上)
一个例子:
public class Something { public synchronized void isSyncA(){} public synchronized void isSyncB(){} public static synchronized void cSyncA(){} public static synchronized void cSyncB(){} }
己设,something类有两个实例x和y。分析以下四组表达式获取的锁的情况:
(1)、x.isSyncA()与x.isSyncB()
(2)、x.isSyncA()与y.isSyncA()
(3)、x.cSyncA()与y.cSyncB()
(4)、x.isSyncA()与Something.cSyncA()
(1)、不能同时访问,因为访问的是同一个对象x的同步锁
class Something { public synchronized void isSyncA() { synchronized(this) { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()+" synMethod loop "+i); } } catch(InterruptedException ie) {} } } public synchronized void isSyncB() { 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 Problem1 { Something x = new Something(); Something y = new Something(); private void test1() { Thread t1 = new Thread( new Runnable(){ @Override public void run() { x.isSyncA(); } },"t1"); Thread t2 = new Thread( new Runnable() { @Override public void run() { x.isSyncB(); } },"t2"); t1.start(); t2.start(); } public static void main(String[] args) { Problem1 demo = new Problem1(); demo.test1(); } }
运行结果:
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
(2)、可以同时被访问,x.isSyncA()访问的是x的同步锁,而y.isSyncA()访问的是y的同步锁
class Something { public synchronized void isSyncA() { synchronized(this) { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()+" isSyncA "+i); } } catch(InterruptedException ie) {} } } public synchronized void isSyncB() { synchronized(this) { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()+" isSyncB "+i); } } catch(InterruptedException ie) {} } } } public class Problem1 { Something x = new Something(); Something y = new Something(); private void test1() { Thread t1 = new Thread( new Runnable(){ @Override public void run() { x.isSyncA(); } },"t1"); Thread t2 = new Thread( new Runnable() { @Override public void run() { y.isSyncB(); } },"t2"); t1.start(); t2.start(); } public static void main(String[] args) { Problem1 demo = new Problem1(); demo.test1(); } }
运行结果:
t1 isSyncA 0 t2 isSyncB 0 t1 isSyncA 1 t2 isSyncB 1 t1 isSyncA 2 t2 isSyncB 2 t1 isSyncA 3 t2 isSyncB 3 t1 isSyncA 4 t2 isSyncB 4
(3)、不能被同时访问,因为cSyncA()和cSyncB()都是static类型,x.cSynca()相当于Something.isSyncA(),y.cSyncB()相当于Something.isSyncB(),因此它们共用同一把锁
class Something { public synchronized void isSyncA() { synchronized(this) { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()+" isSyncA "+i); } } catch(InterruptedException ie) {} } } public synchronized void isSyncB() { synchronized(this) { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()+" isSyncB "+i); } } catch(InterruptedException ie) {} } } public static synchronized void cSyncA() { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()+" cSyncA "+i); } } catch(InterruptedException ie) {} } public static synchronized void cSyncB() { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()+" cSyncB "+i); } } catch(InterruptedException ie) {} } } public class Problem1 { Something x = new Something(); Something y = new Something(); private void test1() { Thread t1 = new Thread( new Runnable(){ @Override public void run() { x.cSyncA(); } },"t1"); Thread t2 = new Thread( new Runnable() { @Override public void run() { y.cSyncB(); } },"t2"); t1.start(); t2.start(); } public static void main(String[] args) { Problem1 demo = new Problem1(); demo.test1(); } }
运行结果:
t1 cSyncA 0 t1 cSyncA 1 t1 cSyncA 2 t1 cSyncA 3 t1 cSyncA 4 t2 cSyncB 0 t2 cSyncB 1 t2 cSyncB 2 t2 cSyncB 3 t2 cSyncB 4
(4)、可以被同时访问,因为isSyncA()是实例方法,x.isSyncA()使用的是对象x的锁;而cSyncA()是静态方法,Something.cSyncA()可以理解为使用类的锁,因此可以同时访问
class Something { public synchronized void isSyncA() { synchronized(this) { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()+" isSyncA "+i); } } catch(InterruptedException ie) {} } } public synchronized void isSyncB() { synchronized(this) { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()+" isSyncB "+i); } } catch(InterruptedException ie) {} } } public static synchronized void cSyncA() { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()+" cSyncA "+i); } } catch(InterruptedException ie) {} } public static synchronized void cSyncB() { try { for(int i = 0;i < 5;i++) { Thread.sleep(100); System.out.println(Thread.currentThread().getName()+" cSyncB "+i); } } catch(InterruptedException ie) {} } } public class Problem1 { Something x = new Something(); Something y = new Something(); private void test1() { Thread t1 = new Thread( new Runnable(){ @Override public void run() { x.isSyncA(); } },"t1"); Thread t2 = new Thread( new Runnable() { @Override public void run() { Something.cSyncA(); } },"t2"); t1.start(); t2.start(); } public static void main(String[] args) { Problem1 demo = new Problem1(); demo.test1(); } }
运行结果:
t2 cSyncA 0 t1 isSyncA 0 t2 cSyncA 1 t1 isSyncA 1 t2 cSyncA 2 t1 isSyncA 2 t1 isSyncA 3 t2 cSyncA 3 t2 cSyncA 4 t1 isSyncA 4