-----概要--------------------
1、synchronized原理
2、synchronized基本规则
3、synchronized方法和synchronized代码块
4、实例锁和全局锁
-----synchronized原理---------------------
在java中,每一个对象有且仅有一个同步锁,这也意味着,同步锁是依赖于对象而存在。
当我们调用某对象的synchronized方法时,就获取了该对象的同步锁。如:synchronized(obj)就获取了"obj这个对象"的同步锁。
不同线程对同步锁访问时互斥的,也就是锁,在某个时间点,对象的同步锁只能被一个线程获取到,通过同步锁,我们就能在多线程中,实现对"对象/方法"的互斥访问。如:现在有俩个线程A和线程B,他们都会访问"对象obj的同步锁"。假设,某一个时刻,线程A获取到"obj的同步锁"并在执行一些操作,而此时,线程B也企图获取"obj"的同步锁,线程B会获取失败,它必须等待,知道线程A释放了"该对象的同步锁之后线程B才能获取到"obj的同步锁",从而可以运行。
-----synchronized基本规则---------------------
我们将synchronized的基本规则归结为下面三条,病痛难过实例对他们进行说明
第一条:
当一个线程访问"某对象"的"synchronized方法"或者"synchronized代码块"时,其他线程对"该对象"的该"synchronized方法"或者"synchronized代码块"的访问将被阻塞。
演示代码:
public class SynchronizedTest 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 e){
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Runnable runnable = new SynchronizedTest();
Thread thread1 = new Thread(runnable,"t1");
Thread thread2 = new Thread(runnable,"t2");
thread1.start();
thread2.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都是基于main中的这个"Runnable对象"创建的线程。这就意味着,我们可以将synchronized(this)中的this看做是"main中这个Runnable对象",因此,线程t1和t2共享"Runnable对象的同步锁"。所以,当一个线程运行的时候,另一个线程必须等待"运行线程"释放"Runnable的同步锁"之后才可以运行。
再看下面一块代码:
public class SynchronizedTest extends Thread{
public SynchronizedTest(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 e){
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Thread thread1 = new SynchronizedTest("t1");
Thread thread2 = new SynchronizedTest("t2");
thread1.start();
thread2.start();
}
}
运行结果:
t2 loop 0
t1 loop 0
t1 loop 1
t2 loop 1
t2 loop 2
t1 loop 2
t2 loop 3
t1 loop 3
t2 loop 4
t1 loop 4
代码说明:
synchronized(this)中的this是指"当前的类对象",即synchronized(this)所在的类对应的当前对象,它的作用是获取"当前对象的同步锁"。
第二条:
当一个线程访问"某对象"的"synchronized方法"或者"synchronized代码块"时,其他线程任认识你可以告诉你个人"该对象"的非同步代码块。
演示代码:
public class NoSynchronizedTest {
//含有synchronized同步代码块方法
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 e){
e.printStackTrace();
}
}
}
//非同步方法
public void nonSynchronized(){
try{
for (int i = 0; i < 5; i++){
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i);
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
public static void main(String[] args){
final NoSynchronizedTest noSynchronizedTest = new NoSynchronizedTest();
Thread t1 = new Thread(
new Runnable() {
@Override
public void run() {
noSynchronizedTest.synMethod();
}
},"t1");
Thread t2 = new Thread(
new Runnable() {
@Override
public void run() {
noSynchronizedTest.nonSynchronized();
}
},"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
t2 nonSynMethod loop 3
t1 synMethod loop 3
t2 nonSynMethod loop 4
t1 synMethod loop 4
主线程中新建了两字子线程t1和t2,t1会调用NoSynchronizedTest对象的synMethod()方法,该发放内还有同步快,而t2则会调用NoSynchronized对象的nonSynMethon()方法,该方法不是同步方法,t1运行时,虽然调用synchronized(this)获取"NoSynchronizedTest的同步锁",但是并没有造成t2的阻塞,因为t2没有用到"NoSynchronizedTest"同步锁。第三条:
当一个线程访问"某对象"的"synchronized方法"或者"synchronized代码块"时,其他线程对"该对象"的其他的"synchronized方法"或者"synchronized代码块"的访问将被阻塞。
演示代码:
public class NoSynchronizedTest {
//含有synchronized同步代码块方法
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 e){
e.printStackTrace();
}
}
}
//非同步方法
public void nonSynchronized(){
synchronized (this){
try{
for (int i = 0; i < 5; i++){
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i);
}
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
public static void main(String[] args){
final NoSynchronizedTest noSynchronizedTest = new NoSynchronizedTest();
Thread t1 = new Thread(
new Runnable() {
@Override
public void run() {
noSynchronizedTest.synMethod();
}
},"t1");
Thread t2 = new Thread(
new Runnable() {
@Override
public void run() {
noSynchronizedTest.nonSynchronized();
}
},"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,t1和t2运行时都调用synchronized(this),这个this是NoSynchronized对象,而t1和t2共用NoSynchronized,因此,在t1运行时,t2会被阻塞,等待t1运行释放"NoSynchronized对象的同步锁",t2才可以运行。
-----synchronized方法和synchronized代码块--------------------
"synchronized方法"使用synchronized修饰方法,而"synchronized代码块"则是用synchronized修饰代码块。
synchronized方法事例:
public synchronized void test1() {
System.out.println("synchronized methoed");
}
synchronized代码块事例:
public void test() {
synchronized (this) {
System.out.println("synchronized methoed");
}
}
synchronized代码块中的this是指当前对象,也可以将this替换成其他对象,例如:将this替换成obj,则test2()在执行synchronized(obj)时就获取的时obj的同步锁。
synchronized代码块可以更精确的控制冲突限制访问区域,有时候变现的更高效率,以下为事例:
public class SynchronizedDemo {
public synchronized void synMethon(){
for (int i = 0; i < 1000000; i++){
;
}
}
public void synBlock(){
synchronized (this){
for (int i = 0; i < 1000000; i++){
;
}
}
}
public static void main(String[] args){
SynchronizedDemo demo = new SynchronizedDemo();
long start,diff;
start = System.currentTimeMillis();
demo.synMethon();
diff = System.currentTimeMillis() - start;
System.out.println("synMethon(): " + diff);
start = System.currentTimeMillis();
demo.synBlock();
diff = System.currentTimeMillis() - start;
System.out.println("synBlock():" + diff);
}
}
某一次运行结果:
synMethon(): 4
synBlock():3
-----实例所和全局锁----------------------
实例锁 -- 锁在某一个实例对象上,如果该类是单利,那么该所也是全局锁的概念。实例锁对应的就是synchronized关键字。
全局锁 -- 该锁针对的是类,无论实例多少个对象,那么线程都共享该锁,全局锁对应的就是static synchronized(或者是锁在该类的class或者classloader对象上),
如下为"实例锁"和"全局锁"有一个很形象的例子
pulbic class Something {
public synchronized void isSyncA(){}
public synchronized void isSyncB(){}
public static synchronized void cSyncA(){}
public static synchronized void cSyncB(){}
}
假设,Something有两个实例x和y,分析下面4组表达式获取锁的情况
(01) x.isSyncA()与x.isSyncB()
(02) x.isSyncA()与y.isSyncA()
(03) x.cSyncA()与y.cSyncB()
(04) x.isSyncA()与Something.cSyncA()
(01) 不能被同时访问。因为isSyncA()和isSyncB()都是访问同一个对象(对象x)的同步锁!
(02) 可以同时被访问。因为访问的不是同一个对象的同步锁,x.isSyncA()访问的是x的同步锁,而y.isSyncA()访问的是y的同步锁。
(03) 不能被同时访问。因为cSyncA()和cSyncB()都是static类型,x.cSyncA()相当于Something.isSyncA(),y.cSyncB()相当于Something.isSyncB(),因此它们共用一个同步锁,不能被同时反问。
(04) 可以被同时访问。因为isSyncA()是实例方法,x.isSyncA()使用的是对象x的锁;而cSyncA()是静态方法,Something.cSyncA()可以理解对使用的是“类的锁”。因此,它们是可以被同时访问的。
----------------------------------------------备注--------------------------------------
此篇文章来自java架构师之路
多多指教!!!